@typescript-deploys/pr-build 5.5.0-pr-58440-3 → 5.5.0-pr-58440-13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/tsc.js CHANGED
@@ -18,7 +18,7 @@ and limitations under the License.
18
18
 
19
19
  // src/compiler/corePublic.ts
20
20
  var versionMajorMinor = "5.5";
21
- var version = `${versionMajorMinor}.0-insiders.20240505`;
21
+ var version = `${versionMajorMinor}.0-insiders.20240506`;
22
22
 
23
23
  // src/compiler/core.ts
24
24
  var emptyArray = [];
@@ -71182,13 +71182,14 @@ function createTypeChecker(host) {
71182
71182
  const paramName = leftName === rightName ? leftName : !leftName ? rightName : !rightName ? leftName : void 0;
71183
71183
  const paramSymbol = createSymbol(
71184
71184
  1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0),
71185
- paramName || `arg${i}`
71185
+ paramName || `arg${i}`,
71186
+ isRestParam ? 32768 /* RestParameter */ : isOptional ? 16384 /* OptionalParameter */ : 0
71186
71187
  );
71187
71188
  paramSymbol.links.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
71188
71189
  params[i] = paramSymbol;
71189
71190
  }
71190
71191
  if (needsExtraRestElement) {
71191
- const restParamSymbol = createSymbol(1 /* FunctionScopedVariable */, "args");
71192
+ const restParamSymbol = createSymbol(1 /* FunctionScopedVariable */, "args", 32768 /* RestParameter */);
71192
71193
  restParamSymbol.links.type = createArrayType(getTypeAtPosition(shorter, longestCount));
71193
71194
  if (shorter === right) {
71194
71195
  restParamSymbol.links.type = instantiateType(restParamSymbol.links.type, mapper);
@@ -114221,13 +114222,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114221
114222
  }
114222
114223
  }
114223
114224
  function emitComputedPropertyName(node) {
114224
- const savedPrivateNameTempFlags = privateNameTempFlags;
114225
- const savedReservedMemberNames = reservedPrivateNames;
114226
- popPrivateNameGenerationScope();
114227
114225
  writePunctuation("[");
114228
114226
  emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfComputedPropertyName);
114229
114227
  writePunctuation("]");
114230
- pushPrivateNameGenerationScope(savedPrivateNameTempFlags, savedReservedMemberNames);
114231
114228
  }
114232
114229
  function emitTypeParameter(node) {
114233
114230
  emitModifierList(node, node.modifiers);
@@ -114288,15 +114285,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114288
114285
  writeTrailingSemicolon();
114289
114286
  }
114290
114287
  function emitMethodSignature(node) {
114291
- pushNameGenerationScope(node);
114292
114288
  emitModifierList(node, node.modifiers);
114293
114289
  emit(node.name);
114294
114290
  emit(node.questionToken);
114295
- emitTypeParameters(node, node.typeParameters);
114296
- emitParameters(node, node.parameters);
114297
- emitTypeAnnotation(node.type);
114298
- writeTrailingSemicolon();
114299
- popNameGenerationScope(node);
114291
+ emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody);
114300
114292
  }
114301
114293
  function emitMethodDeclaration(node) {
114302
114294
  emitDecoratorsAndModifiers(
@@ -114308,11 +114300,13 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114308
114300
  emit(node.asteriskToken);
114309
114301
  emit(node.name);
114310
114302
  emit(node.questionToken);
114311
- emitSignatureAndBody(node, emitSignatureHead);
114303
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
114312
114304
  }
114313
114305
  function emitClassStaticBlockDeclaration(node) {
114314
114306
  writeKeyword("static");
114307
+ pushNameGenerationScope(node);
114315
114308
  emitBlockFunctionBody(node.body);
114309
+ popNameGenerationScope(node);
114316
114310
  }
114317
114311
  function emitConstructor(node) {
114318
114312
  emitDecoratorsAndModifiers(
@@ -114322,7 +114316,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114322
114316
  false
114323
114317
  );
114324
114318
  writeKeyword("constructor");
114325
- emitSignatureAndBody(node, emitSignatureHead);
114319
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
114326
114320
  }
114327
114321
  function emitAccessorDeclaration(node) {
114328
114322
  const pos = emitDecoratorsAndModifiers(
@@ -114335,25 +114329,15 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114335
114329
  emitTokenWithComment(token, pos, writeKeyword, node);
114336
114330
  writeSpace();
114337
114331
  emit(node.name);
114338
- emitSignatureAndBody(node, emitSignatureHead);
114332
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
114339
114333
  }
114340
114334
  function emitCallSignature(node) {
114341
- pushNameGenerationScope(node);
114342
- emitTypeParameters(node, node.typeParameters);
114343
- emitParameters(node, node.parameters);
114344
- emitTypeAnnotation(node.type);
114345
- writeTrailingSemicolon();
114346
- popNameGenerationScope(node);
114335
+ emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody);
114347
114336
  }
114348
114337
  function emitConstructSignature(node) {
114349
- pushNameGenerationScope(node);
114350
114338
  writeKeyword("new");
114351
114339
  writeSpace();
114352
- emitTypeParameters(node, node.typeParameters);
114353
- emitParameters(node, node.parameters);
114354
- emitTypeAnnotation(node.type);
114355
- writeTrailingSemicolon();
114356
- popNameGenerationScope(node);
114340
+ emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody);
114357
114341
  }
114358
114342
  function emitIndexSignature(node) {
114359
114343
  emitDecoratorsAndModifiers(
@@ -114391,14 +114375,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114391
114375
  emitTypeArguments(node, node.typeArguments);
114392
114376
  }
114393
114377
  function emitFunctionType(node) {
114394
- pushNameGenerationScope(node);
114378
+ emitSignatureAndBody(node, emitFunctionTypeHead, emitFunctionTypeBody);
114379
+ }
114380
+ function emitFunctionTypeHead(node) {
114395
114381
  emitTypeParameters(node, node.typeParameters);
114396
114382
  emitParametersForArrow(node, node.parameters);
114397
114383
  writeSpace();
114398
114384
  writePunctuation("=>");
114385
+ }
114386
+ function emitFunctionTypeBody(node) {
114399
114387
  writeSpace();
114400
114388
  emit(node.type);
114401
- popNameGenerationScope(node);
114402
114389
  }
114403
114390
  function emitJSDocFunctionType(node) {
114404
114391
  writeKeyword("function");
@@ -114419,17 +114406,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114419
114406
  writePunctuation("=");
114420
114407
  }
114421
114408
  function emitConstructorType(node) {
114422
- pushNameGenerationScope(node);
114423
114409
  emitModifierList(node, node.modifiers);
114424
114410
  writeKeyword("new");
114425
114411
  writeSpace();
114426
- emitTypeParameters(node, node.typeParameters);
114427
- emitParameters(node, node.parameters);
114428
- writeSpace();
114429
- writePunctuation("=>");
114430
- writeSpace();
114431
- emit(node.type);
114432
- popNameGenerationScope(node);
114412
+ emitSignatureAndBody(node, emitFunctionTypeHead, emitFunctionTypeBody);
114433
114413
  }
114434
114414
  function emitTypeQuery(node) {
114435
114415
  writeKeyword("typeof");
@@ -114438,16 +114418,13 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114438
114418
  emitTypeArguments(node, node.typeArguments);
114439
114419
  }
114440
114420
  function emitTypeLiteral(node) {
114441
- pushPrivateNameGenerationScope(
114442
- 0 /* Auto */,
114443
- /*newReservedMemberNames*/
114444
- void 0
114445
- );
114421
+ pushNameGenerationScope(node);
114422
+ forEach(node.members, generateMemberNames);
114446
114423
  writePunctuation("{");
114447
114424
  const flags = getEmitFlags(node) & 1 /* SingleLine */ ? 768 /* SingleLineTypeLiteralMembers */ : 32897 /* MultiLineTypeLiteralMembers */;
114448
114425
  emitList(node, node.members, flags | 524288 /* NoSpaceIfEmpty */);
114449
114426
  writePunctuation("}");
114450
- popPrivateNameGenerationScope();
114427
+ popNameGenerationScope(node);
114451
114428
  }
114452
114429
  function emitArrayType(node) {
114453
114430
  emit(node.elementType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
@@ -114619,11 +114596,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114619
114596
  emitExpressionList(node, elements, 8914 /* ArrayLiteralExpressionElements */ | preferNewLine, parenthesizer.parenthesizeExpressionForDisallowedComma);
114620
114597
  }
114621
114598
  function emitObjectLiteralExpression(node) {
114622
- pushPrivateNameGenerationScope(
114623
- 0 /* Auto */,
114624
- /*newReservedMemberNames*/
114625
- void 0
114626
- );
114599
+ pushNameGenerationScope(node);
114627
114600
  forEach(node.properties, generateMemberNames);
114628
114601
  const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
114629
114602
  if (indentedFlag) {
@@ -114635,7 +114608,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114635
114608
  if (indentedFlag) {
114636
114609
  decreaseIndent();
114637
114610
  }
114638
- popPrivateNameGenerationScope();
114611
+ popNameGenerationScope(node);
114639
114612
  }
114640
114613
  function emitPropertyAccessExpression(node) {
114641
114614
  emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
@@ -114750,7 +114723,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114750
114723
  }
114751
114724
  function emitArrowFunction(node) {
114752
114725
  emitModifierList(node, node.modifiers);
114753
- emitSignatureAndBody(node, emitArrowFunctionHead);
114726
+ emitSignatureAndBody(node, emitArrowFunctionHead, emitArrowFunctionBody);
114754
114727
  }
114755
114728
  function emitArrowFunctionHead(node) {
114756
114729
  emitTypeParameters(node, node.typeParameters);
@@ -114759,6 +114732,14 @@ function createPrinter(printerOptions = {}, handlers = {}) {
114759
114732
  writeSpace();
114760
114733
  emit(node.equalsGreaterThanToken);
114761
114734
  }
114735
+ function emitArrowFunctionBody(node) {
114736
+ if (isBlock(node.body)) {
114737
+ emitBlockFunctionBody(node.body);
114738
+ } else {
114739
+ writeSpace();
114740
+ emitExpression(node.body, parenthesizer.parenthesizeConciseBodyOfArrowFunction);
114741
+ }
114742
+ }
114762
114743
  function emitDeleteExpression(node) {
114763
114744
  emitTokenWithComment(91 /* DeleteKeyword */, node.pos, writeKeyword, node);
114764
114745
  writeSpace();
@@ -115306,35 +115287,33 @@ function createPrinter(printerOptions = {}, handlers = {}) {
115306
115287
  emit(node.asteriskToken);
115307
115288
  writeSpace();
115308
115289
  emitIdentifierName(node.name);
115309
- emitSignatureAndBody(node, emitSignatureHead);
115290
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
115310
115291
  }
115311
- function emitSignatureAndBody(node, emitSignatureHead2) {
115292
+ function emitSignatureAndBody(node, emitSignatureHead2, emitBody) {
115293
+ const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
115294
+ if (indentedFlag) {
115295
+ increaseIndent();
115296
+ }
115297
+ pushNameGenerationScope(node);
115298
+ forEach(node.parameters, generateNames);
115299
+ emitSignatureHead2(node);
115300
+ emitBody(node);
115301
+ popNameGenerationScope(node);
115302
+ if (indentedFlag) {
115303
+ decreaseIndent();
115304
+ }
115305
+ }
115306
+ function emitFunctionBody(node) {
115312
115307
  const body = node.body;
115313
115308
  if (body) {
115314
- if (isBlock(body)) {
115315
- const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
115316
- if (indentedFlag) {
115317
- increaseIndent();
115318
- }
115319
- pushNameGenerationScope(node);
115320
- forEach(node.parameters, generateNames);
115321
- generateNames(node.body);
115322
- emitSignatureHead2(node);
115323
- emitBlockFunctionBody(body);
115324
- popNameGenerationScope(node);
115325
- if (indentedFlag) {
115326
- decreaseIndent();
115327
- }
115328
- } else {
115329
- emitSignatureHead2(node);
115330
- writeSpace();
115331
- emitExpression(body, parenthesizer.parenthesizeConciseBodyOfArrowFunction);
115332
- }
115309
+ emitBlockFunctionBody(body);
115333
115310
  } else {
115334
- emitSignatureHead2(node);
115335
115311
  writeTrailingSemicolon();
115336
115312
  }
115337
115313
  }
115314
+ function emitEmptyFunctionBody(_node) {
115315
+ writeTrailingSemicolon();
115316
+ }
115338
115317
  function emitSignatureHead(node) {
115339
115318
  emitTypeParameters(node, node.typeParameters);
115340
115319
  emitParameters(node, node.parameters);
@@ -115363,6 +115342,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
115363
115342
  return true;
115364
115343
  }
115365
115344
  function emitBlockFunctionBody(body) {
115345
+ generateNames(body);
115366
115346
  onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(body);
115367
115347
  writeSpace();
115368
115348
  writePunctuation("{");
@@ -115403,12 +115383,6 @@ function createPrinter(printerOptions = {}, handlers = {}) {
115403
115383
  emitClassDeclarationOrExpression(node);
115404
115384
  }
115405
115385
  function emitClassDeclarationOrExpression(node) {
115406
- pushPrivateNameGenerationScope(
115407
- 0 /* Auto */,
115408
- /*newReservedMemberNames*/
115409
- void 0
115410
- );
115411
- forEach(node.members, generateMemberNames);
115412
115386
  emitDecoratorsAndModifiers(
115413
115387
  node,
115414
115388
  node.modifiers,
@@ -115428,19 +115402,16 @@ function createPrinter(printerOptions = {}, handlers = {}) {
115428
115402
  emitList(node, node.heritageClauses, 0 /* ClassHeritageClauses */);
115429
115403
  writeSpace();
115430
115404
  writePunctuation("{");
115405
+ pushNameGenerationScope(node);
115406
+ forEach(node.members, generateMemberNames);
115431
115407
  emitList(node, node.members, 129 /* ClassMembers */);
115408
+ popNameGenerationScope(node);
115432
115409
  writePunctuation("}");
115433
115410
  if (indentedFlag) {
115434
115411
  decreaseIndent();
115435
115412
  }
115436
- popPrivateNameGenerationScope();
115437
115413
  }
115438
115414
  function emitInterfaceDeclaration(node) {
115439
- pushPrivateNameGenerationScope(
115440
- 0 /* Auto */,
115441
- /*newReservedMemberNames*/
115442
- void 0
115443
- );
115444
115415
  emitDecoratorsAndModifiers(
115445
115416
  node,
115446
115417
  node.modifiers,
@@ -115454,9 +115425,11 @@ function createPrinter(printerOptions = {}, handlers = {}) {
115454
115425
  emitList(node, node.heritageClauses, 512 /* HeritageClauses */);
115455
115426
  writeSpace();
115456
115427
  writePunctuation("{");
115428
+ pushNameGenerationScope(node);
115429
+ forEach(node.members, generateMemberNames);
115457
115430
  emitList(node, node.members, 129 /* InterfaceMembers */);
115431
+ popNameGenerationScope(node);
115458
115432
  writePunctuation("}");
115459
- popPrivateNameGenerationScope();
115460
115433
  }
115461
115434
  function emitTypeAliasDeclaration(node) {
115462
115435
  emitDecoratorsAndModifiers(
@@ -116837,6 +116810,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
116837
116810
  return getLiteralText(node, currentSourceFile, flags);
116838
116811
  }
116839
116812
  function pushNameGenerationScope(node) {
116813
+ privateNameTempFlagsStack.push(privateNameTempFlags);
116814
+ privateNameTempFlags = 0 /* Auto */;
116815
+ reservedPrivateNamesStack.push(reservedPrivateNames);
116840
116816
  if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
116841
116817
  return;
116842
116818
  }
@@ -116847,6 +116823,8 @@ function createPrinter(printerOptions = {}, handlers = {}) {
116847
116823
  reservedNamesStack.push(reservedNames);
116848
116824
  }
116849
116825
  function popNameGenerationScope(node) {
116826
+ privateNameTempFlags = privateNameTempFlagsStack.pop();
116827
+ reservedPrivateNames = reservedPrivateNamesStack.pop();
116850
116828
  if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
116851
116829
  return;
116852
116830
  }
@@ -116860,16 +116838,6 @@ function createPrinter(printerOptions = {}, handlers = {}) {
116860
116838
  }
116861
116839
  reservedNames.add(name);
116862
116840
  }
116863
- function pushPrivateNameGenerationScope(newPrivateNameTempFlags, newReservedMemberNames) {
116864
- privateNameTempFlagsStack.push(privateNameTempFlags);
116865
- privateNameTempFlags = newPrivateNameTempFlags;
116866
- reservedPrivateNamesStack.push(reservedNames);
116867
- reservedPrivateNames = newReservedMemberNames;
116868
- }
116869
- function popPrivateNameGenerationScope() {
116870
- privateNameTempFlags = privateNameTempFlagsStack.pop();
116871
- reservedPrivateNames = reservedPrivateNamesStack.pop();
116872
- }
116873
116841
  function reservePrivateNameInNestedScopes(name) {
116874
116842
  if (!reservedPrivateNames || reservedPrivateNames === lastOrUndefined(reservedPrivateNamesStack)) {
116875
116843
  reservedPrivateNames = /* @__PURE__ */ new Set();
@@ -116969,7 +116937,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
116969
116937
  case 303 /* PropertyAssignment */:
116970
116938
  case 304 /* ShorthandPropertyAssignment */:
116971
116939
  case 172 /* PropertyDeclaration */:
116940
+ case 171 /* PropertySignature */:
116972
116941
  case 174 /* MethodDeclaration */:
116942
+ case 173 /* MethodSignature */:
116973
116943
  case 177 /* GetAccessor */:
116974
116944
  case 178 /* SetAccessor */:
116975
116945
  generateNameIfNeeded(node.name);
@@ -117003,7 +116973,28 @@ function createPrinter(printerOptions = {}, handlers = {}) {
117003
116973
  return isFileLevelUniqueNameInCurrentFile(name, privateName) && !isReservedName(name, privateName) && !generatedNames.has(name);
117004
116974
  }
117005
116975
  function isReservedName(name, privateName) {
117006
- return privateName ? !!(reservedPrivateNames == null ? void 0 : reservedPrivateNames.has(name)) : !!(reservedNames == null ? void 0 : reservedNames.has(name));
116976
+ let set;
116977
+ let stack;
116978
+ if (privateName) {
116979
+ set = reservedPrivateNames;
116980
+ stack = reservedPrivateNamesStack;
116981
+ } else {
116982
+ set = reservedNames;
116983
+ stack = reservedNamesStack;
116984
+ }
116985
+ if (set == null ? void 0 : set.has(name)) {
116986
+ return true;
116987
+ }
116988
+ for (let i = stack.length - 1; i >= 0; i--) {
116989
+ if (set === stack[i]) {
116990
+ continue;
116991
+ }
116992
+ set = stack[i];
116993
+ if (set == null ? void 0 : set.has(name)) {
116994
+ return true;
116995
+ }
116996
+ }
116997
+ return false;
117007
116998
  }
117008
116999
  function isFileLevelUniqueNameInCurrentFile(name, _isPrivate) {
117009
117000
  return currentSourceFile ? isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true;
package/lib/typescript.js CHANGED
@@ -2364,7 +2364,7 @@ module.exports = __toCommonJS(typescript_exports);
2364
2364
 
2365
2365
  // src/compiler/corePublic.ts
2366
2366
  var versionMajorMinor = "5.5";
2367
- var version = `${versionMajorMinor}.0-insiders.20240505`;
2367
+ var version = `${versionMajorMinor}.0-insiders.20240506`;
2368
2368
  var Comparison = /* @__PURE__ */ ((Comparison3) => {
2369
2369
  Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
2370
2370
  Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -76022,13 +76022,14 @@ function createTypeChecker(host) {
76022
76022
  const paramName = leftName === rightName ? leftName : !leftName ? rightName : !rightName ? leftName : void 0;
76023
76023
  const paramSymbol = createSymbol(
76024
76024
  1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0),
76025
- paramName || `arg${i}`
76025
+ paramName || `arg${i}`,
76026
+ isRestParam ? 32768 /* RestParameter */ : isOptional ? 16384 /* OptionalParameter */ : 0
76026
76027
  );
76027
76028
  paramSymbol.links.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
76028
76029
  params[i] = paramSymbol;
76029
76030
  }
76030
76031
  if (needsExtraRestElement) {
76031
- const restParamSymbol = createSymbol(1 /* FunctionScopedVariable */, "args");
76032
+ const restParamSymbol = createSymbol(1 /* FunctionScopedVariable */, "args", 32768 /* RestParameter */);
76032
76033
  restParamSymbol.links.type = createArrayType(getTypeAtPosition(shorter, longestCount));
76033
76034
  if (shorter === right) {
76034
76035
  restParamSymbol.links.type = instantiateType(restParamSymbol.links.type, mapper);
@@ -119259,13 +119260,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119259
119260
  }
119260
119261
  }
119261
119262
  function emitComputedPropertyName(node) {
119262
- const savedPrivateNameTempFlags = privateNameTempFlags;
119263
- const savedReservedMemberNames = reservedPrivateNames;
119264
- popPrivateNameGenerationScope();
119265
119263
  writePunctuation("[");
119266
119264
  emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfComputedPropertyName);
119267
119265
  writePunctuation("]");
119268
- pushPrivateNameGenerationScope(savedPrivateNameTempFlags, savedReservedMemberNames);
119269
119266
  }
119270
119267
  function emitTypeParameter(node) {
119271
119268
  emitModifierList(node, node.modifiers);
@@ -119326,15 +119323,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119326
119323
  writeTrailingSemicolon();
119327
119324
  }
119328
119325
  function emitMethodSignature(node) {
119329
- pushNameGenerationScope(node);
119330
119326
  emitModifierList(node, node.modifiers);
119331
119327
  emit(node.name);
119332
119328
  emit(node.questionToken);
119333
- emitTypeParameters(node, node.typeParameters);
119334
- emitParameters(node, node.parameters);
119335
- emitTypeAnnotation(node.type);
119336
- writeTrailingSemicolon();
119337
- popNameGenerationScope(node);
119329
+ emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody);
119338
119330
  }
119339
119331
  function emitMethodDeclaration(node) {
119340
119332
  emitDecoratorsAndModifiers(
@@ -119346,11 +119338,13 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119346
119338
  emit(node.asteriskToken);
119347
119339
  emit(node.name);
119348
119340
  emit(node.questionToken);
119349
- emitSignatureAndBody(node, emitSignatureHead);
119341
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
119350
119342
  }
119351
119343
  function emitClassStaticBlockDeclaration(node) {
119352
119344
  writeKeyword("static");
119345
+ pushNameGenerationScope(node);
119353
119346
  emitBlockFunctionBody(node.body);
119347
+ popNameGenerationScope(node);
119354
119348
  }
119355
119349
  function emitConstructor(node) {
119356
119350
  emitDecoratorsAndModifiers(
@@ -119360,7 +119354,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119360
119354
  false
119361
119355
  );
119362
119356
  writeKeyword("constructor");
119363
- emitSignatureAndBody(node, emitSignatureHead);
119357
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
119364
119358
  }
119365
119359
  function emitAccessorDeclaration(node) {
119366
119360
  const pos = emitDecoratorsAndModifiers(
@@ -119373,25 +119367,15 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119373
119367
  emitTokenWithComment(token, pos, writeKeyword, node);
119374
119368
  writeSpace();
119375
119369
  emit(node.name);
119376
- emitSignatureAndBody(node, emitSignatureHead);
119370
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
119377
119371
  }
119378
119372
  function emitCallSignature(node) {
119379
- pushNameGenerationScope(node);
119380
- emitTypeParameters(node, node.typeParameters);
119381
- emitParameters(node, node.parameters);
119382
- emitTypeAnnotation(node.type);
119383
- writeTrailingSemicolon();
119384
- popNameGenerationScope(node);
119373
+ emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody);
119385
119374
  }
119386
119375
  function emitConstructSignature(node) {
119387
- pushNameGenerationScope(node);
119388
119376
  writeKeyword("new");
119389
119377
  writeSpace();
119390
- emitTypeParameters(node, node.typeParameters);
119391
- emitParameters(node, node.parameters);
119392
- emitTypeAnnotation(node.type);
119393
- writeTrailingSemicolon();
119394
- popNameGenerationScope(node);
119378
+ emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody);
119395
119379
  }
119396
119380
  function emitIndexSignature(node) {
119397
119381
  emitDecoratorsAndModifiers(
@@ -119429,14 +119413,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119429
119413
  emitTypeArguments(node, node.typeArguments);
119430
119414
  }
119431
119415
  function emitFunctionType(node) {
119432
- pushNameGenerationScope(node);
119416
+ emitSignatureAndBody(node, emitFunctionTypeHead, emitFunctionTypeBody);
119417
+ }
119418
+ function emitFunctionTypeHead(node) {
119433
119419
  emitTypeParameters(node, node.typeParameters);
119434
119420
  emitParametersForArrow(node, node.parameters);
119435
119421
  writeSpace();
119436
119422
  writePunctuation("=>");
119423
+ }
119424
+ function emitFunctionTypeBody(node) {
119437
119425
  writeSpace();
119438
119426
  emit(node.type);
119439
- popNameGenerationScope(node);
119440
119427
  }
119441
119428
  function emitJSDocFunctionType(node) {
119442
119429
  writeKeyword("function");
@@ -119457,17 +119444,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119457
119444
  writePunctuation("=");
119458
119445
  }
119459
119446
  function emitConstructorType(node) {
119460
- pushNameGenerationScope(node);
119461
119447
  emitModifierList(node, node.modifiers);
119462
119448
  writeKeyword("new");
119463
119449
  writeSpace();
119464
- emitTypeParameters(node, node.typeParameters);
119465
- emitParameters(node, node.parameters);
119466
- writeSpace();
119467
- writePunctuation("=>");
119468
- writeSpace();
119469
- emit(node.type);
119470
- popNameGenerationScope(node);
119450
+ emitSignatureAndBody(node, emitFunctionTypeHead, emitFunctionTypeBody);
119471
119451
  }
119472
119452
  function emitTypeQuery(node) {
119473
119453
  writeKeyword("typeof");
@@ -119476,16 +119456,13 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119476
119456
  emitTypeArguments(node, node.typeArguments);
119477
119457
  }
119478
119458
  function emitTypeLiteral(node) {
119479
- pushPrivateNameGenerationScope(
119480
- 0 /* Auto */,
119481
- /*newReservedMemberNames*/
119482
- void 0
119483
- );
119459
+ pushNameGenerationScope(node);
119460
+ forEach(node.members, generateMemberNames);
119484
119461
  writePunctuation("{");
119485
119462
  const flags = getEmitFlags(node) & 1 /* SingleLine */ ? 768 /* SingleLineTypeLiteralMembers */ : 32897 /* MultiLineTypeLiteralMembers */;
119486
119463
  emitList(node, node.members, flags | 524288 /* NoSpaceIfEmpty */);
119487
119464
  writePunctuation("}");
119488
- popPrivateNameGenerationScope();
119465
+ popNameGenerationScope(node);
119489
119466
  }
119490
119467
  function emitArrayType(node) {
119491
119468
  emit(node.elementType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
@@ -119657,11 +119634,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119657
119634
  emitExpressionList(node, elements, 8914 /* ArrayLiteralExpressionElements */ | preferNewLine, parenthesizer.parenthesizeExpressionForDisallowedComma);
119658
119635
  }
119659
119636
  function emitObjectLiteralExpression(node) {
119660
- pushPrivateNameGenerationScope(
119661
- 0 /* Auto */,
119662
- /*newReservedMemberNames*/
119663
- void 0
119664
- );
119637
+ pushNameGenerationScope(node);
119665
119638
  forEach(node.properties, generateMemberNames);
119666
119639
  const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
119667
119640
  if (indentedFlag) {
@@ -119673,7 +119646,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119673
119646
  if (indentedFlag) {
119674
119647
  decreaseIndent();
119675
119648
  }
119676
- popPrivateNameGenerationScope();
119649
+ popNameGenerationScope(node);
119677
119650
  }
119678
119651
  function emitPropertyAccessExpression(node) {
119679
119652
  emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
@@ -119788,7 +119761,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119788
119761
  }
119789
119762
  function emitArrowFunction(node) {
119790
119763
  emitModifierList(node, node.modifiers);
119791
- emitSignatureAndBody(node, emitArrowFunctionHead);
119764
+ emitSignatureAndBody(node, emitArrowFunctionHead, emitArrowFunctionBody);
119792
119765
  }
119793
119766
  function emitArrowFunctionHead(node) {
119794
119767
  emitTypeParameters(node, node.typeParameters);
@@ -119797,6 +119770,14 @@ function createPrinter(printerOptions = {}, handlers = {}) {
119797
119770
  writeSpace();
119798
119771
  emit(node.equalsGreaterThanToken);
119799
119772
  }
119773
+ function emitArrowFunctionBody(node) {
119774
+ if (isBlock(node.body)) {
119775
+ emitBlockFunctionBody(node.body);
119776
+ } else {
119777
+ writeSpace();
119778
+ emitExpression(node.body, parenthesizer.parenthesizeConciseBodyOfArrowFunction);
119779
+ }
119780
+ }
119800
119781
  function emitDeleteExpression(node) {
119801
119782
  emitTokenWithComment(91 /* DeleteKeyword */, node.pos, writeKeyword, node);
119802
119783
  writeSpace();
@@ -120344,35 +120325,33 @@ function createPrinter(printerOptions = {}, handlers = {}) {
120344
120325
  emit(node.asteriskToken);
120345
120326
  writeSpace();
120346
120327
  emitIdentifierName(node.name);
120347
- emitSignatureAndBody(node, emitSignatureHead);
120328
+ emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody);
120348
120329
  }
120349
- function emitSignatureAndBody(node, emitSignatureHead2) {
120330
+ function emitSignatureAndBody(node, emitSignatureHead2, emitBody) {
120331
+ const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
120332
+ if (indentedFlag) {
120333
+ increaseIndent();
120334
+ }
120335
+ pushNameGenerationScope(node);
120336
+ forEach(node.parameters, generateNames);
120337
+ emitSignatureHead2(node);
120338
+ emitBody(node);
120339
+ popNameGenerationScope(node);
120340
+ if (indentedFlag) {
120341
+ decreaseIndent();
120342
+ }
120343
+ }
120344
+ function emitFunctionBody(node) {
120350
120345
  const body = node.body;
120351
120346
  if (body) {
120352
- if (isBlock(body)) {
120353
- const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
120354
- if (indentedFlag) {
120355
- increaseIndent();
120356
- }
120357
- pushNameGenerationScope(node);
120358
- forEach(node.parameters, generateNames);
120359
- generateNames(node.body);
120360
- emitSignatureHead2(node);
120361
- emitBlockFunctionBody(body);
120362
- popNameGenerationScope(node);
120363
- if (indentedFlag) {
120364
- decreaseIndent();
120365
- }
120366
- } else {
120367
- emitSignatureHead2(node);
120368
- writeSpace();
120369
- emitExpression(body, parenthesizer.parenthesizeConciseBodyOfArrowFunction);
120370
- }
120347
+ emitBlockFunctionBody(body);
120371
120348
  } else {
120372
- emitSignatureHead2(node);
120373
120349
  writeTrailingSemicolon();
120374
120350
  }
120375
120351
  }
120352
+ function emitEmptyFunctionBody(_node) {
120353
+ writeTrailingSemicolon();
120354
+ }
120376
120355
  function emitSignatureHead(node) {
120377
120356
  emitTypeParameters(node, node.typeParameters);
120378
120357
  emitParameters(node, node.parameters);
@@ -120401,6 +120380,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
120401
120380
  return true;
120402
120381
  }
120403
120382
  function emitBlockFunctionBody(body) {
120383
+ generateNames(body);
120404
120384
  onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(body);
120405
120385
  writeSpace();
120406
120386
  writePunctuation("{");
@@ -120441,12 +120421,6 @@ function createPrinter(printerOptions = {}, handlers = {}) {
120441
120421
  emitClassDeclarationOrExpression(node);
120442
120422
  }
120443
120423
  function emitClassDeclarationOrExpression(node) {
120444
- pushPrivateNameGenerationScope(
120445
- 0 /* Auto */,
120446
- /*newReservedMemberNames*/
120447
- void 0
120448
- );
120449
- forEach(node.members, generateMemberNames);
120450
120424
  emitDecoratorsAndModifiers(
120451
120425
  node,
120452
120426
  node.modifiers,
@@ -120466,19 +120440,16 @@ function createPrinter(printerOptions = {}, handlers = {}) {
120466
120440
  emitList(node, node.heritageClauses, 0 /* ClassHeritageClauses */);
120467
120441
  writeSpace();
120468
120442
  writePunctuation("{");
120443
+ pushNameGenerationScope(node);
120444
+ forEach(node.members, generateMemberNames);
120469
120445
  emitList(node, node.members, 129 /* ClassMembers */);
120446
+ popNameGenerationScope(node);
120470
120447
  writePunctuation("}");
120471
120448
  if (indentedFlag) {
120472
120449
  decreaseIndent();
120473
120450
  }
120474
- popPrivateNameGenerationScope();
120475
120451
  }
120476
120452
  function emitInterfaceDeclaration(node) {
120477
- pushPrivateNameGenerationScope(
120478
- 0 /* Auto */,
120479
- /*newReservedMemberNames*/
120480
- void 0
120481
- );
120482
120453
  emitDecoratorsAndModifiers(
120483
120454
  node,
120484
120455
  node.modifiers,
@@ -120492,9 +120463,11 @@ function createPrinter(printerOptions = {}, handlers = {}) {
120492
120463
  emitList(node, node.heritageClauses, 512 /* HeritageClauses */);
120493
120464
  writeSpace();
120494
120465
  writePunctuation("{");
120466
+ pushNameGenerationScope(node);
120467
+ forEach(node.members, generateMemberNames);
120495
120468
  emitList(node, node.members, 129 /* InterfaceMembers */);
120469
+ popNameGenerationScope(node);
120496
120470
  writePunctuation("}");
120497
- popPrivateNameGenerationScope();
120498
120471
  }
120499
120472
  function emitTypeAliasDeclaration(node) {
120500
120473
  emitDecoratorsAndModifiers(
@@ -121875,6 +121848,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
121875
121848
  return getLiteralText(node, currentSourceFile, flags);
121876
121849
  }
121877
121850
  function pushNameGenerationScope(node) {
121851
+ privateNameTempFlagsStack.push(privateNameTempFlags);
121852
+ privateNameTempFlags = 0 /* Auto */;
121853
+ reservedPrivateNamesStack.push(reservedPrivateNames);
121878
121854
  if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
121879
121855
  return;
121880
121856
  }
@@ -121885,6 +121861,8 @@ function createPrinter(printerOptions = {}, handlers = {}) {
121885
121861
  reservedNamesStack.push(reservedNames);
121886
121862
  }
121887
121863
  function popNameGenerationScope(node) {
121864
+ privateNameTempFlags = privateNameTempFlagsStack.pop();
121865
+ reservedPrivateNames = reservedPrivateNamesStack.pop();
121888
121866
  if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
121889
121867
  return;
121890
121868
  }
@@ -121898,16 +121876,6 @@ function createPrinter(printerOptions = {}, handlers = {}) {
121898
121876
  }
121899
121877
  reservedNames.add(name);
121900
121878
  }
121901
- function pushPrivateNameGenerationScope(newPrivateNameTempFlags, newReservedMemberNames) {
121902
- privateNameTempFlagsStack.push(privateNameTempFlags);
121903
- privateNameTempFlags = newPrivateNameTempFlags;
121904
- reservedPrivateNamesStack.push(reservedNames);
121905
- reservedPrivateNames = newReservedMemberNames;
121906
- }
121907
- function popPrivateNameGenerationScope() {
121908
- privateNameTempFlags = privateNameTempFlagsStack.pop();
121909
- reservedPrivateNames = reservedPrivateNamesStack.pop();
121910
- }
121911
121879
  function reservePrivateNameInNestedScopes(name) {
121912
121880
  if (!reservedPrivateNames || reservedPrivateNames === lastOrUndefined(reservedPrivateNamesStack)) {
121913
121881
  reservedPrivateNames = /* @__PURE__ */ new Set();
@@ -122007,7 +121975,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
122007
121975
  case 303 /* PropertyAssignment */:
122008
121976
  case 304 /* ShorthandPropertyAssignment */:
122009
121977
  case 172 /* PropertyDeclaration */:
121978
+ case 171 /* PropertySignature */:
122010
121979
  case 174 /* MethodDeclaration */:
121980
+ case 173 /* MethodSignature */:
122011
121981
  case 177 /* GetAccessor */:
122012
121982
  case 178 /* SetAccessor */:
122013
121983
  generateNameIfNeeded(node.name);
@@ -122041,7 +122011,28 @@ function createPrinter(printerOptions = {}, handlers = {}) {
122041
122011
  return isFileLevelUniqueNameInCurrentFile(name, privateName) && !isReservedName(name, privateName) && !generatedNames.has(name);
122042
122012
  }
122043
122013
  function isReservedName(name, privateName) {
122044
- return privateName ? !!(reservedPrivateNames == null ? void 0 : reservedPrivateNames.has(name)) : !!(reservedNames == null ? void 0 : reservedNames.has(name));
122014
+ let set;
122015
+ let stack;
122016
+ if (privateName) {
122017
+ set = reservedPrivateNames;
122018
+ stack = reservedPrivateNamesStack;
122019
+ } else {
122020
+ set = reservedNames;
122021
+ stack = reservedNamesStack;
122022
+ }
122023
+ if (set == null ? void 0 : set.has(name)) {
122024
+ return true;
122025
+ }
122026
+ for (let i = stack.length - 1; i >= 0; i--) {
122027
+ if (set === stack[i]) {
122028
+ continue;
122029
+ }
122030
+ set = stack[i];
122031
+ if (set == null ? void 0 : set.has(name)) {
122032
+ return true;
122033
+ }
122034
+ }
122035
+ return false;
122045
122036
  }
122046
122037
  function isFileLevelUniqueNameInCurrentFile(name, _isPrivate) {
122047
122038
  return currentSourceFile ? isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true;
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "@typescript-deploys/pr-build",
3
3
  "author": "Microsoft Corp.",
4
4
  "homepage": "https://www.typescriptlang.org/",
5
- "version": "5.5.0-pr-58440-3",
5
+ "version": "5.5.0-pr-58440-13",
6
6
  "license": "Apache-2.0",
7
7
  "description": "TypeScript is a language for application scale JavaScript development",
8
8
  "keywords": [