typescript 4.9.0-dev.20221027 → 4.9.0-dev.20221029

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.
Files changed (7) hide show
  1. package/lib/tsc.js +42 -12
  2. package/lib/tsserver.js +76 -23
  3. package/lib/tsserverlibrary.js +76 -23
  4. package/lib/typescript.js +76 -23
  5. package/lib/typescriptServices.js +76 -23
  6. package/lib/typingsInstaller.js +55 -22
  7. package/package.json +1 -1
package/lib/tsc.js CHANGED
@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
69
69
  var ts;
70
70
  (function (ts) {
71
71
  ts.versionMajorMinor = "4.9";
72
- ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221027");
72
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
73
73
  var NativeCollections;
74
74
  (function (NativeCollections) {
75
75
  var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -59898,6 +59898,7 @@ var ts;
59898
59898
  ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
59899
59899
  }
59900
59900
  function getExplicitTypeOfSymbol(symbol, diagnostic) {
59901
+ symbol = resolveSymbol(symbol);
59901
59902
  if (symbol.flags & (16 | 8192 | 32 | 512)) {
59902
59903
  return getTypeOfSymbol(symbol);
59903
59904
  }
@@ -59932,7 +59933,7 @@ var ts;
59932
59933
  switch (node.kind) {
59933
59934
  case 79:
59934
59935
  var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
59935
- return getExplicitTypeOfSymbol(symbol.flags & 2097152 ? resolveAlias(symbol) : symbol, diagnostic);
59936
+ return getExplicitTypeOfSymbol(symbol, diagnostic);
59936
59937
  case 108:
59937
59938
  return getExplicitThisType(node);
59938
59939
  case 106:
@@ -83312,11 +83313,22 @@ var ts;
83312
83313
  }
83313
83314
  return node;
83314
83315
  }
83315
- function convertForOfStatementHead(node, boundValue) {
83316
- var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
83316
+ function convertForOfStatementHead(node, boundValue, nonUserCode) {
83317
+ var value = factory.createTempVariable(hoistVariableDeclaration);
83318
+ var iteratorValueExpression = factory.createAssignment(value, boundValue);
83319
+ var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
83320
+ ts.setSourceMapRange(iteratorValueStatement, node.expression);
83321
+ var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
83322
+ var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
83323
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
83324
+ var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
83325
+ var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
83326
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
83327
+ var statements = [];
83328
+ var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
83329
+ statements.push(ts.visitNode(binding, visitor, ts.isStatement));
83317
83330
  var bodyLocation;
83318
83331
  var statementsLocation;
83319
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
83320
83332
  var statement = ts.visitIterationBody(node.statement, visitor, context);
83321
83333
  if (ts.isBlock(statement)) {
83322
83334
  ts.addRange(statements, statement.statements);
@@ -83326,7 +83338,14 @@ var ts;
83326
83338
  else {
83327
83339
  statements.push(statement);
83328
83340
  }
83329
- return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), true), bodyLocation), 48 | 384);
83341
+ var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), true), bodyLocation), 48 | 384);
83342
+ return factory.createBlock([
83343
+ iteratorValueStatement,
83344
+ exitNonUserCodeStatement,
83345
+ factory.createTryStatement(body, undefined, factory.createBlock([
83346
+ enterNonUserCodeStatement
83347
+ ]))
83348
+ ]);
83330
83349
  }
83331
83350
  function createDownlevelAwait(expression) {
83332
83351
  return enclosingFunctionFlags & 1
@@ -83337,6 +83356,8 @@ var ts;
83337
83356
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
83338
83357
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(undefined);
83339
83358
  var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(undefined);
83359
+ var nonUserCode = factory.createTempVariable(undefined);
83360
+ var done = factory.createTempVariable(hoistVariableDeclaration);
83340
83361
  var errorRecord = factory.createUniqueName("e");
83341
83362
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
83342
83363
  var returnMethod = factory.createTempVariable(undefined);
@@ -83351,9 +83372,14 @@ var ts;
83351
83372
  factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), callValues]) :
83352
83373
  callValues;
83353
83374
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
83375
+ factory.createVariableDeclaration(nonUserCode, undefined, undefined, factory.createTrue()),
83354
83376
  ts.setTextRange(factory.createVariableDeclaration(iterator, undefined, undefined, initializer), node.expression),
83355
83377
  factory.createVariableDeclaration(result)
83356
- ]), node.expression), 2097152), factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)), undefined, convertForOfStatementHead(node, getValue)), node), 256);
83378
+ ]), node.expression), 2097152), factory.inlineExpressions([
83379
+ factory.createAssignment(result, createDownlevelAwait(callNext)),
83380
+ factory.createAssignment(done, getDone),
83381
+ factory.createLogicalNot(done)
83382
+ ]), undefined, convertForOfStatementHead(node, getValue, nonUserCode)), node), 256);
83357
83383
  ts.setOriginalNode(forStatement, node);
83358
83384
  return factory.createTryStatement(factory.createBlock([
83359
83385
  factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement)
@@ -83363,7 +83389,7 @@ var ts;
83363
83389
  ])))
83364
83390
  ]), 1)), factory.createBlock([
83365
83391
  factory.createTryStatement(factory.createBlock([
83366
- ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1)
83392
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1)
83367
83393
  ]), undefined, ts.setEmitFlags(factory.createBlock([
83368
83394
  ts.setEmitFlags(factory.createIfStatement(errorRecord, factory.createThrowStatement(factory.createPropertyAccessExpression(errorRecord, "error"))), 1)
83369
83395
  ]), 1))
@@ -87465,19 +87491,23 @@ var ts;
87465
87491
  }
87466
87492
  function transformAndEmitForInStatement(node) {
87467
87493
  if (containsYield(node)) {
87494
+ var obj = declareLocal();
87468
87495
  var keysArray = declareLocal();
87469
87496
  var key = declareLocal();
87470
87497
  var keysIndex = factory.createLoopVariable();
87471
87498
  var initializer = node.initializer;
87472
87499
  hoistVariableDeclaration(keysIndex);
87500
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
87473
87501
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
87474
- emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), undefined, [key]))));
87502
+ emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), undefined, [key]))));
87475
87503
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
87476
87504
  var conditionLabel = defineLabel();
87477
87505
  var incrementLabel = defineLabel();
87478
- var endLabel = beginLoopBlock(incrementLabel);
87506
+ var endLoopLabel = beginLoopBlock(incrementLabel);
87479
87507
  markLabel(conditionLabel);
87480
- emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
87508
+ emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
87509
+ emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
87510
+ emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101, obj));
87481
87511
  var variable = void 0;
87482
87512
  if (ts.isVariableDeclarationList(initializer)) {
87483
87513
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -87490,7 +87520,7 @@ var ts;
87490
87520
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
87491
87521
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
87492
87522
  }
87493
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
87523
+ emitAssignment(variable, key);
87494
87524
  transformAndEmitEmbeddedStatement(node.statement);
87495
87525
  markLabel(incrementLabel);
87496
87526
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
package/lib/tsserver.js CHANGED
@@ -109,7 +109,7 @@ var ts;
109
109
  // The following is baselined as a literal template type without intervention
110
110
  /** The version of the TypeScript compiler release */
111
111
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
112
- ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221027");
112
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
113
113
  /* @internal */
114
114
  var Comparison;
115
115
  (function (Comparison) {
@@ -71611,6 +71611,7 @@ var ts;
71611
71611
  ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
71612
71612
  }
71613
71613
  function getExplicitTypeOfSymbol(symbol, diagnostic) {
71614
+ symbol = resolveSymbol(symbol);
71614
71615
  if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) {
71615
71616
  return getTypeOfSymbol(symbol);
71616
71617
  }
@@ -71649,7 +71650,7 @@ var ts;
71649
71650
  switch (node.kind) {
71650
71651
  case 79 /* SyntaxKind.Identifier */:
71651
71652
  var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
71652
- return getExplicitTypeOfSymbol(symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol, diagnostic);
71653
+ return getExplicitTypeOfSymbol(symbol, diagnostic);
71653
71654
  case 108 /* SyntaxKind.ThisKeyword */:
71654
71655
  return getExplicitThisType(node);
71655
71656
  case 106 /* SyntaxKind.SuperKeyword */:
@@ -99514,11 +99515,22 @@ var ts;
99514
99515
  }
99515
99516
  return node;
99516
99517
  }
99517
- function convertForOfStatementHead(node, boundValue) {
99518
- var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
99518
+ function convertForOfStatementHead(node, boundValue, nonUserCode) {
99519
+ var value = factory.createTempVariable(hoistVariableDeclaration);
99520
+ var iteratorValueExpression = factory.createAssignment(value, boundValue);
99521
+ var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
99522
+ ts.setSourceMapRange(iteratorValueStatement, node.expression);
99523
+ var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
99524
+ var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
99525
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99526
+ var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
99527
+ var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
99528
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99529
+ var statements = [];
99530
+ var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
99531
+ statements.push(ts.visitNode(binding, visitor, ts.isStatement));
99519
99532
  var bodyLocation;
99520
99533
  var statementsLocation;
99521
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99522
99534
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99523
99535
  if (ts.isBlock(statement)) {
99524
99536
  ts.addRange(statements, statement.statements);
@@ -99528,8 +99540,16 @@ var ts;
99528
99540
  else {
99529
99541
  statements.push(statement);
99530
99542
  }
99531
- return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99543
+ var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99532
99544
  /*multiLine*/ true), bodyLocation), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */);
99545
+ return factory.createBlock([
99546
+ iteratorValueStatement,
99547
+ exitNonUserCodeStatement,
99548
+ factory.createTryStatement(body,
99549
+ /*catchClause*/ undefined, factory.createBlock([
99550
+ enterNonUserCodeStatement
99551
+ ]))
99552
+ ]);
99533
99553
  }
99534
99554
  function createDownlevelAwait(expression) {
99535
99555
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99540,6 +99560,8 @@ var ts;
99540
99560
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99541
99561
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99542
99562
  var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99563
+ var nonUserCode = factory.createTempVariable(/*recordTempVariable*/ undefined);
99564
+ var done = factory.createTempVariable(hoistVariableDeclaration);
99543
99565
  var errorRecord = factory.createUniqueName("e");
99544
99566
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99545
99567
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99556,12 +99578,17 @@ var ts;
99556
99578
  callValues;
99557
99579
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99558
99580
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99581
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99559
99582
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99560
99583
  factory.createVariableDeclaration(result)
99561
99584
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99562
- /*condition*/ factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)),
99585
+ /*condition*/ factory.inlineExpressions([
99586
+ factory.createAssignment(result, createDownlevelAwait(callNext)),
99587
+ factory.createAssignment(done, getDone),
99588
+ factory.createLogicalNot(done)
99589
+ ]),
99563
99590
  /*incrementor*/ undefined,
99564
- /*statement*/ convertForOfStatementHead(node, getValue)),
99591
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99565
99592
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99566
99593
  ts.setOriginalNode(forStatement, node);
99567
99594
  return factory.createTryStatement(factory.createBlock([
@@ -99573,7 +99600,7 @@ var ts;
99573
99600
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99574
99601
  factory.createTryStatement(
99575
99602
  /*tryBlock*/ factory.createBlock([
99576
- ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99603
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99577
99604
  ]),
99578
99605
  /*catchClause*/ undefined,
99579
99606
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105571,7 +105598,6 @@ var ts;
105571
105598
  return node;
105572
105599
  }
105573
105600
  function transformAndEmitForInStatement(node) {
105574
- // TODO(rbuckton): Source map locations
105575
105601
  if (containsYield(node)) {
105576
105602
  // [source]
105577
105603
  // for (var p in o) {
@@ -105579,34 +105605,41 @@ var ts;
105579
105605
  // }
105580
105606
  //
105581
105607
  // [intermediate]
105582
- // .local _a, _b, _i
105583
- // _a = [];
105584
- // for (_b in o) _a.push(_b);
105608
+ // .local _b, _a, _c, _i
105609
+ // _b = [];
105610
+ // _a = o;
105611
+ // for (_c in _a) _b.push(_c);
105585
105612
  // _i = 0;
105586
105613
  // .loop incrementLabel, endLoopLabel
105587
105614
  // .mark conditionLabel
105588
- // .brfalse endLoopLabel, (_i < _a.length)
105589
- // p = _a[_i];
105615
+ // .brfalse endLoopLabel, (_i < _b.length)
105616
+ // _c = _b[_i];
105617
+ // .brfalse incrementLabel, (_c in _a)
105618
+ // p = _c;
105590
105619
  // /*body*/
105591
105620
  // .mark incrementLabel
105592
- // _b++;
105621
+ // _c++;
105593
105622
  // .br conditionLabel
105594
105623
  // .endloop
105595
105624
  // .mark endLoopLabel
105596
- var keysArray = declareLocal(); // _a
105597
- var key = declareLocal(); // _b
105625
+ var obj = declareLocal(); // _a
105626
+ var keysArray = declareLocal(); // _b
105627
+ var key = declareLocal(); // _c
105598
105628
  var keysIndex = factory.createLoopVariable(); // _i
105599
105629
  var initializer = node.initializer;
105600
105630
  hoistVariableDeclaration(keysIndex);
105631
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105601
105632
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105602
- emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105633
+ emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105603
105634
  /*typeArguments*/ undefined, [key]))));
105604
105635
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105605
105636
  var conditionLabel = defineLabel();
105606
105637
  var incrementLabel = defineLabel();
105607
- var endLabel = beginLoopBlock(incrementLabel);
105638
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105608
105639
  markLabel(conditionLabel);
105609
- emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105640
+ emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105641
+ emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
105642
+ emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101 /* SyntaxKind.InKeyword */, obj));
105610
105643
  var variable = void 0;
105611
105644
  if (ts.isVariableDeclarationList(initializer)) {
105612
105645
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105619,7 +105652,7 @@ var ts;
105619
105652
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105620
105653
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105621
105654
  }
105622
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105655
+ emitAssignment(variable, key);
105623
105656
  transformAndEmitEmbeddedStatement(node.statement);
105624
105657
  markLabel(incrementLabel);
105625
105658
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
@@ -152872,6 +152905,26 @@ var ts;
152872
152905
  function startPositionToDeleteNodeInList(sourceFile, node) {
152873
152906
  return ts.skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
152874
152907
  }
152908
+ function endPositionToDeleteNodeInList(sourceFile, node, prevNode, nextNode) {
152909
+ var end = startPositionToDeleteNodeInList(sourceFile, nextNode);
152910
+ if (prevNode === undefined || ts.positionsAreOnSameLine(getAdjustedEndPosition(sourceFile, node, {}), end, sourceFile)) {
152911
+ return end;
152912
+ }
152913
+ var token = ts.findPrecedingToken(nextNode.getStart(sourceFile), sourceFile);
152914
+ if (isSeparator(node, token)) {
152915
+ var prevToken = ts.findPrecedingToken(node.getStart(sourceFile), sourceFile);
152916
+ if (isSeparator(prevNode, prevToken)) {
152917
+ var pos = ts.skipTrivia(sourceFile.text, token.getEnd(), /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);
152918
+ if (ts.positionsAreOnSameLine(prevToken.getStart(sourceFile), token.getStart(sourceFile), sourceFile)) {
152919
+ return ts.isLineBreak(sourceFile.text.charCodeAt(pos - 1)) ? pos - 1 : pos;
152920
+ }
152921
+ if (ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
152922
+ return pos;
152923
+ }
152924
+ }
152925
+ }
152926
+ return end;
152927
+ }
152875
152928
  function getClassOrObjectBraceEnds(cls, sourceFile) {
152876
152929
  var open = ts.findChildOfKind(cls, 18 /* SyntaxKind.OpenBraceToken */, sourceFile);
152877
152930
  var close = ts.findChildOfKind(cls, 19 /* SyntaxKind.CloseBraceToken */, sourceFile);
@@ -153429,7 +153482,7 @@ var ts;
153429
153482
  deletedNodesInLists.add(node);
153430
153483
  changes.deleteRange(sourceFile, {
153431
153484
  pos: startPositionToDeleteNodeInList(sourceFile, node),
153432
- end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : startPositionToDeleteNodeInList(sourceFile, containingList[index + 1]),
153485
+ end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : endPositionToDeleteNodeInList(sourceFile, node, containingList[index - 1], containingList[index + 1]),
153433
153486
  });
153434
153487
  }
153435
153488
  })(textChanges = ts.textChanges || (ts.textChanges = {}));
package/lib/tsserverlibrary.js CHANGED
@@ -108,7 +108,7 @@ var ts;
108
108
  // The following is baselined as a literal template type without intervention
109
109
  /** The version of the TypeScript compiler release */
110
110
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
111
- ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221027");
111
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
112
112
  /* @internal */
113
113
  var Comparison;
114
114
  (function (Comparison) {
@@ -71610,6 +71610,7 @@ var ts;
71610
71610
  ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
71611
71611
  }
71612
71612
  function getExplicitTypeOfSymbol(symbol, diagnostic) {
71613
+ symbol = resolveSymbol(symbol);
71613
71614
  if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) {
71614
71615
  return getTypeOfSymbol(symbol);
71615
71616
  }
@@ -71648,7 +71649,7 @@ var ts;
71648
71649
  switch (node.kind) {
71649
71650
  case 79 /* SyntaxKind.Identifier */:
71650
71651
  var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
71651
- return getExplicitTypeOfSymbol(symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol, diagnostic);
71652
+ return getExplicitTypeOfSymbol(symbol, diagnostic);
71652
71653
  case 108 /* SyntaxKind.ThisKeyword */:
71653
71654
  return getExplicitThisType(node);
71654
71655
  case 106 /* SyntaxKind.SuperKeyword */:
@@ -99513,11 +99514,22 @@ var ts;
99513
99514
  }
99514
99515
  return node;
99515
99516
  }
99516
- function convertForOfStatementHead(node, boundValue) {
99517
- var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
99517
+ function convertForOfStatementHead(node, boundValue, nonUserCode) {
99518
+ var value = factory.createTempVariable(hoistVariableDeclaration);
99519
+ var iteratorValueExpression = factory.createAssignment(value, boundValue);
99520
+ var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
99521
+ ts.setSourceMapRange(iteratorValueStatement, node.expression);
99522
+ var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
99523
+ var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
99524
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99525
+ var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
99526
+ var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
99527
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99528
+ var statements = [];
99529
+ var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
99530
+ statements.push(ts.visitNode(binding, visitor, ts.isStatement));
99518
99531
  var bodyLocation;
99519
99532
  var statementsLocation;
99520
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99521
99533
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99522
99534
  if (ts.isBlock(statement)) {
99523
99535
  ts.addRange(statements, statement.statements);
@@ -99527,8 +99539,16 @@ var ts;
99527
99539
  else {
99528
99540
  statements.push(statement);
99529
99541
  }
99530
- return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99542
+ var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99531
99543
  /*multiLine*/ true), bodyLocation), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */);
99544
+ return factory.createBlock([
99545
+ iteratorValueStatement,
99546
+ exitNonUserCodeStatement,
99547
+ factory.createTryStatement(body,
99548
+ /*catchClause*/ undefined, factory.createBlock([
99549
+ enterNonUserCodeStatement
99550
+ ]))
99551
+ ]);
99532
99552
  }
99533
99553
  function createDownlevelAwait(expression) {
99534
99554
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99539,6 +99559,8 @@ var ts;
99539
99559
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99540
99560
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99541
99561
  var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99562
+ var nonUserCode = factory.createTempVariable(/*recordTempVariable*/ undefined);
99563
+ var done = factory.createTempVariable(hoistVariableDeclaration);
99542
99564
  var errorRecord = factory.createUniqueName("e");
99543
99565
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99544
99566
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99555,12 +99577,17 @@ var ts;
99555
99577
  callValues;
99556
99578
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99557
99579
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99580
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99558
99581
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99559
99582
  factory.createVariableDeclaration(result)
99560
99583
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99561
- /*condition*/ factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)),
99584
+ /*condition*/ factory.inlineExpressions([
99585
+ factory.createAssignment(result, createDownlevelAwait(callNext)),
99586
+ factory.createAssignment(done, getDone),
99587
+ factory.createLogicalNot(done)
99588
+ ]),
99562
99589
  /*incrementor*/ undefined,
99563
- /*statement*/ convertForOfStatementHead(node, getValue)),
99590
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99564
99591
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99565
99592
  ts.setOriginalNode(forStatement, node);
99566
99593
  return factory.createTryStatement(factory.createBlock([
@@ -99572,7 +99599,7 @@ var ts;
99572
99599
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99573
99600
  factory.createTryStatement(
99574
99601
  /*tryBlock*/ factory.createBlock([
99575
- ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99602
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99576
99603
  ]),
99577
99604
  /*catchClause*/ undefined,
99578
99605
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105570,7 +105597,6 @@ var ts;
105570
105597
  return node;
105571
105598
  }
105572
105599
  function transformAndEmitForInStatement(node) {
105573
- // TODO(rbuckton): Source map locations
105574
105600
  if (containsYield(node)) {
105575
105601
  // [source]
105576
105602
  // for (var p in o) {
@@ -105578,34 +105604,41 @@ var ts;
105578
105604
  // }
105579
105605
  //
105580
105606
  // [intermediate]
105581
- // .local _a, _b, _i
105582
- // _a = [];
105583
- // for (_b in o) _a.push(_b);
105607
+ // .local _b, _a, _c, _i
105608
+ // _b = [];
105609
+ // _a = o;
105610
+ // for (_c in _a) _b.push(_c);
105584
105611
  // _i = 0;
105585
105612
  // .loop incrementLabel, endLoopLabel
105586
105613
  // .mark conditionLabel
105587
- // .brfalse endLoopLabel, (_i < _a.length)
105588
- // p = _a[_i];
105614
+ // .brfalse endLoopLabel, (_i < _b.length)
105615
+ // _c = _b[_i];
105616
+ // .brfalse incrementLabel, (_c in _a)
105617
+ // p = _c;
105589
105618
  // /*body*/
105590
105619
  // .mark incrementLabel
105591
- // _b++;
105620
+ // _c++;
105592
105621
  // .br conditionLabel
105593
105622
  // .endloop
105594
105623
  // .mark endLoopLabel
105595
- var keysArray = declareLocal(); // _a
105596
- var key = declareLocal(); // _b
105624
+ var obj = declareLocal(); // _a
105625
+ var keysArray = declareLocal(); // _b
105626
+ var key = declareLocal(); // _c
105597
105627
  var keysIndex = factory.createLoopVariable(); // _i
105598
105628
  var initializer = node.initializer;
105599
105629
  hoistVariableDeclaration(keysIndex);
105630
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105600
105631
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105601
- emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105632
+ emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105602
105633
  /*typeArguments*/ undefined, [key]))));
105603
105634
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105604
105635
  var conditionLabel = defineLabel();
105605
105636
  var incrementLabel = defineLabel();
105606
- var endLabel = beginLoopBlock(incrementLabel);
105637
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105607
105638
  markLabel(conditionLabel);
105608
- emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105639
+ emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105640
+ emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
105641
+ emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101 /* SyntaxKind.InKeyword */, obj));
105609
105642
  var variable = void 0;
105610
105643
  if (ts.isVariableDeclarationList(initializer)) {
105611
105644
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105618,7 +105651,7 @@ var ts;
105618
105651
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105619
105652
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105620
105653
  }
105621
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105654
+ emitAssignment(variable, key);
105622
105655
  transformAndEmitEmbeddedStatement(node.statement);
105623
105656
  markLabel(incrementLabel);
105624
105657
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
@@ -153290,6 +153323,26 @@ var ts;
153290
153323
  function startPositionToDeleteNodeInList(sourceFile, node) {
153291
153324
  return ts.skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
153292
153325
  }
153326
+ function endPositionToDeleteNodeInList(sourceFile, node, prevNode, nextNode) {
153327
+ var end = startPositionToDeleteNodeInList(sourceFile, nextNode);
153328
+ if (prevNode === undefined || ts.positionsAreOnSameLine(getAdjustedEndPosition(sourceFile, node, {}), end, sourceFile)) {
153329
+ return end;
153330
+ }
153331
+ var token = ts.findPrecedingToken(nextNode.getStart(sourceFile), sourceFile);
153332
+ if (isSeparator(node, token)) {
153333
+ var prevToken = ts.findPrecedingToken(node.getStart(sourceFile), sourceFile);
153334
+ if (isSeparator(prevNode, prevToken)) {
153335
+ var pos = ts.skipTrivia(sourceFile.text, token.getEnd(), /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);
153336
+ if (ts.positionsAreOnSameLine(prevToken.getStart(sourceFile), token.getStart(sourceFile), sourceFile)) {
153337
+ return ts.isLineBreak(sourceFile.text.charCodeAt(pos - 1)) ? pos - 1 : pos;
153338
+ }
153339
+ if (ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
153340
+ return pos;
153341
+ }
153342
+ }
153343
+ }
153344
+ return end;
153345
+ }
153293
153346
  function getClassOrObjectBraceEnds(cls, sourceFile) {
153294
153347
  var open = ts.findChildOfKind(cls, 18 /* SyntaxKind.OpenBraceToken */, sourceFile);
153295
153348
  var close = ts.findChildOfKind(cls, 19 /* SyntaxKind.CloseBraceToken */, sourceFile);
@@ -153847,7 +153900,7 @@ var ts;
153847
153900
  deletedNodesInLists.add(node);
153848
153901
  changes.deleteRange(sourceFile, {
153849
153902
  pos: startPositionToDeleteNodeInList(sourceFile, node),
153850
- end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : startPositionToDeleteNodeInList(sourceFile, containingList[index + 1]),
153903
+ end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : endPositionToDeleteNodeInList(sourceFile, node, containingList[index - 1], containingList[index + 1]),
153851
153904
  });
153852
153905
  }
153853
153906
  })(textChanges = ts.textChanges || (ts.textChanges = {}));
package/lib/typescript.js CHANGED
@@ -99,7 +99,7 @@ var ts;
99
99
  // The following is baselined as a literal template type without intervention
100
100
  /** The version of the TypeScript compiler release */
101
101
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
102
- ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221027");
102
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
103
103
  /* @internal */
104
104
  var Comparison;
105
105
  (function (Comparison) {
@@ -71601,6 +71601,7 @@ var ts;
71601
71601
  ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
71602
71602
  }
71603
71603
  function getExplicitTypeOfSymbol(symbol, diagnostic) {
71604
+ symbol = resolveSymbol(symbol);
71604
71605
  if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) {
71605
71606
  return getTypeOfSymbol(symbol);
71606
71607
  }
@@ -71639,7 +71640,7 @@ var ts;
71639
71640
  switch (node.kind) {
71640
71641
  case 79 /* SyntaxKind.Identifier */:
71641
71642
  var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
71642
- return getExplicitTypeOfSymbol(symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol, diagnostic);
71643
+ return getExplicitTypeOfSymbol(symbol, diagnostic);
71643
71644
  case 108 /* SyntaxKind.ThisKeyword */:
71644
71645
  return getExplicitThisType(node);
71645
71646
  case 106 /* SyntaxKind.SuperKeyword */:
@@ -99504,11 +99505,22 @@ var ts;
99504
99505
  }
99505
99506
  return node;
99506
99507
  }
99507
- function convertForOfStatementHead(node, boundValue) {
99508
- var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
99508
+ function convertForOfStatementHead(node, boundValue, nonUserCode) {
99509
+ var value = factory.createTempVariable(hoistVariableDeclaration);
99510
+ var iteratorValueExpression = factory.createAssignment(value, boundValue);
99511
+ var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
99512
+ ts.setSourceMapRange(iteratorValueStatement, node.expression);
99513
+ var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
99514
+ var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
99515
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99516
+ var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
99517
+ var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
99518
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99519
+ var statements = [];
99520
+ var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
99521
+ statements.push(ts.visitNode(binding, visitor, ts.isStatement));
99509
99522
  var bodyLocation;
99510
99523
  var statementsLocation;
99511
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99512
99524
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99513
99525
  if (ts.isBlock(statement)) {
99514
99526
  ts.addRange(statements, statement.statements);
@@ -99518,8 +99530,16 @@ var ts;
99518
99530
  else {
99519
99531
  statements.push(statement);
99520
99532
  }
99521
- return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99533
+ var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99522
99534
  /*multiLine*/ true), bodyLocation), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */);
99535
+ return factory.createBlock([
99536
+ iteratorValueStatement,
99537
+ exitNonUserCodeStatement,
99538
+ factory.createTryStatement(body,
99539
+ /*catchClause*/ undefined, factory.createBlock([
99540
+ enterNonUserCodeStatement
99541
+ ]))
99542
+ ]);
99523
99543
  }
99524
99544
  function createDownlevelAwait(expression) {
99525
99545
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99530,6 +99550,8 @@ var ts;
99530
99550
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99531
99551
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99532
99552
  var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99553
+ var nonUserCode = factory.createTempVariable(/*recordTempVariable*/ undefined);
99554
+ var done = factory.createTempVariable(hoistVariableDeclaration);
99533
99555
  var errorRecord = factory.createUniqueName("e");
99534
99556
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99535
99557
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99546,12 +99568,17 @@ var ts;
99546
99568
  callValues;
99547
99569
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99548
99570
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99571
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99549
99572
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99550
99573
  factory.createVariableDeclaration(result)
99551
99574
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99552
- /*condition*/ factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)),
99575
+ /*condition*/ factory.inlineExpressions([
99576
+ factory.createAssignment(result, createDownlevelAwait(callNext)),
99577
+ factory.createAssignment(done, getDone),
99578
+ factory.createLogicalNot(done)
99579
+ ]),
99553
99580
  /*incrementor*/ undefined,
99554
- /*statement*/ convertForOfStatementHead(node, getValue)),
99581
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99555
99582
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99556
99583
  ts.setOriginalNode(forStatement, node);
99557
99584
  return factory.createTryStatement(factory.createBlock([
@@ -99563,7 +99590,7 @@ var ts;
99563
99590
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99564
99591
  factory.createTryStatement(
99565
99592
  /*tryBlock*/ factory.createBlock([
99566
- ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99593
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99567
99594
  ]),
99568
99595
  /*catchClause*/ undefined,
99569
99596
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105561,7 +105588,6 @@ var ts;
105561
105588
  return node;
105562
105589
  }
105563
105590
  function transformAndEmitForInStatement(node) {
105564
- // TODO(rbuckton): Source map locations
105565
105591
  if (containsYield(node)) {
105566
105592
  // [source]
105567
105593
  // for (var p in o) {
@@ -105569,34 +105595,41 @@ var ts;
105569
105595
  // }
105570
105596
  //
105571
105597
  // [intermediate]
105572
- // .local _a, _b, _i
105573
- // _a = [];
105574
- // for (_b in o) _a.push(_b);
105598
+ // .local _b, _a, _c, _i
105599
+ // _b = [];
105600
+ // _a = o;
105601
+ // for (_c in _a) _b.push(_c);
105575
105602
  // _i = 0;
105576
105603
  // .loop incrementLabel, endLoopLabel
105577
105604
  // .mark conditionLabel
105578
- // .brfalse endLoopLabel, (_i < _a.length)
105579
- // p = _a[_i];
105605
+ // .brfalse endLoopLabel, (_i < _b.length)
105606
+ // _c = _b[_i];
105607
+ // .brfalse incrementLabel, (_c in _a)
105608
+ // p = _c;
105580
105609
  // /*body*/
105581
105610
  // .mark incrementLabel
105582
- // _b++;
105611
+ // _c++;
105583
105612
  // .br conditionLabel
105584
105613
  // .endloop
105585
105614
  // .mark endLoopLabel
105586
- var keysArray = declareLocal(); // _a
105587
- var key = declareLocal(); // _b
105615
+ var obj = declareLocal(); // _a
105616
+ var keysArray = declareLocal(); // _b
105617
+ var key = declareLocal(); // _c
105588
105618
  var keysIndex = factory.createLoopVariable(); // _i
105589
105619
  var initializer = node.initializer;
105590
105620
  hoistVariableDeclaration(keysIndex);
105621
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105591
105622
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105592
- emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105623
+ emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105593
105624
  /*typeArguments*/ undefined, [key]))));
105594
105625
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105595
105626
  var conditionLabel = defineLabel();
105596
105627
  var incrementLabel = defineLabel();
105597
- var endLabel = beginLoopBlock(incrementLabel);
105628
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105598
105629
  markLabel(conditionLabel);
105599
- emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105630
+ emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105631
+ emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
105632
+ emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101 /* SyntaxKind.InKeyword */, obj));
105600
105633
  var variable = void 0;
105601
105634
  if (ts.isVariableDeclarationList(initializer)) {
105602
105635
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105609,7 +105642,7 @@ var ts;
105609
105642
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105610
105643
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105611
105644
  }
105612
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105645
+ emitAssignment(variable, key);
105613
105646
  transformAndEmitEmbeddedStatement(node.statement);
105614
105647
  markLabel(incrementLabel);
105615
105648
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
@@ -153281,6 +153314,26 @@ var ts;
153281
153314
  function startPositionToDeleteNodeInList(sourceFile, node) {
153282
153315
  return ts.skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
153283
153316
  }
153317
+ function endPositionToDeleteNodeInList(sourceFile, node, prevNode, nextNode) {
153318
+ var end = startPositionToDeleteNodeInList(sourceFile, nextNode);
153319
+ if (prevNode === undefined || ts.positionsAreOnSameLine(getAdjustedEndPosition(sourceFile, node, {}), end, sourceFile)) {
153320
+ return end;
153321
+ }
153322
+ var token = ts.findPrecedingToken(nextNode.getStart(sourceFile), sourceFile);
153323
+ if (isSeparator(node, token)) {
153324
+ var prevToken = ts.findPrecedingToken(node.getStart(sourceFile), sourceFile);
153325
+ if (isSeparator(prevNode, prevToken)) {
153326
+ var pos = ts.skipTrivia(sourceFile.text, token.getEnd(), /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);
153327
+ if (ts.positionsAreOnSameLine(prevToken.getStart(sourceFile), token.getStart(sourceFile), sourceFile)) {
153328
+ return ts.isLineBreak(sourceFile.text.charCodeAt(pos - 1)) ? pos - 1 : pos;
153329
+ }
153330
+ if (ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
153331
+ return pos;
153332
+ }
153333
+ }
153334
+ }
153335
+ return end;
153336
+ }
153284
153337
  function getClassOrObjectBraceEnds(cls, sourceFile) {
153285
153338
  var open = ts.findChildOfKind(cls, 18 /* SyntaxKind.OpenBraceToken */, sourceFile);
153286
153339
  var close = ts.findChildOfKind(cls, 19 /* SyntaxKind.CloseBraceToken */, sourceFile);
@@ -153838,7 +153891,7 @@ var ts;
153838
153891
  deletedNodesInLists.add(node);
153839
153892
  changes.deleteRange(sourceFile, {
153840
153893
  pos: startPositionToDeleteNodeInList(sourceFile, node),
153841
- end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : startPositionToDeleteNodeInList(sourceFile, containingList[index + 1]),
153894
+ end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : endPositionToDeleteNodeInList(sourceFile, node, containingList[index - 1], containingList[index + 1]),
153842
153895
  });
153843
153896
  }
153844
153897
  })(textChanges = ts.textChanges || (ts.textChanges = {}));
package/lib/typescriptServices.js CHANGED
@@ -99,7 +99,7 @@ var ts;
99
99
  // The following is baselined as a literal template type without intervention
100
100
  /** The version of the TypeScript compiler release */
101
101
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
102
- ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221027");
102
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
103
103
  /* @internal */
104
104
  var Comparison;
105
105
  (function (Comparison) {
@@ -71601,6 +71601,7 @@ var ts;
71601
71601
  ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
71602
71602
  }
71603
71603
  function getExplicitTypeOfSymbol(symbol, diagnostic) {
71604
+ symbol = resolveSymbol(symbol);
71604
71605
  if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) {
71605
71606
  return getTypeOfSymbol(symbol);
71606
71607
  }
@@ -71639,7 +71640,7 @@ var ts;
71639
71640
  switch (node.kind) {
71640
71641
  case 79 /* SyntaxKind.Identifier */:
71641
71642
  var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
71642
- return getExplicitTypeOfSymbol(symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol, diagnostic);
71643
+ return getExplicitTypeOfSymbol(symbol, diagnostic);
71643
71644
  case 108 /* SyntaxKind.ThisKeyword */:
71644
71645
  return getExplicitThisType(node);
71645
71646
  case 106 /* SyntaxKind.SuperKeyword */:
@@ -99504,11 +99505,22 @@ var ts;
99504
99505
  }
99505
99506
  return node;
99506
99507
  }
99507
- function convertForOfStatementHead(node, boundValue) {
99508
- var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
99508
+ function convertForOfStatementHead(node, boundValue, nonUserCode) {
99509
+ var value = factory.createTempVariable(hoistVariableDeclaration);
99510
+ var iteratorValueExpression = factory.createAssignment(value, boundValue);
99511
+ var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
99512
+ ts.setSourceMapRange(iteratorValueStatement, node.expression);
99513
+ var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
99514
+ var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
99515
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99516
+ var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
99517
+ var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
99518
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99519
+ var statements = [];
99520
+ var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
99521
+ statements.push(ts.visitNode(binding, visitor, ts.isStatement));
99509
99522
  var bodyLocation;
99510
99523
  var statementsLocation;
99511
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99512
99524
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99513
99525
  if (ts.isBlock(statement)) {
99514
99526
  ts.addRange(statements, statement.statements);
@@ -99518,8 +99530,16 @@ var ts;
99518
99530
  else {
99519
99531
  statements.push(statement);
99520
99532
  }
99521
- return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99533
+ var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99522
99534
  /*multiLine*/ true), bodyLocation), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */);
99535
+ return factory.createBlock([
99536
+ iteratorValueStatement,
99537
+ exitNonUserCodeStatement,
99538
+ factory.createTryStatement(body,
99539
+ /*catchClause*/ undefined, factory.createBlock([
99540
+ enterNonUserCodeStatement
99541
+ ]))
99542
+ ]);
99523
99543
  }
99524
99544
  function createDownlevelAwait(expression) {
99525
99545
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99530,6 +99550,8 @@ var ts;
99530
99550
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99531
99551
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99532
99552
  var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99553
+ var nonUserCode = factory.createTempVariable(/*recordTempVariable*/ undefined);
99554
+ var done = factory.createTempVariable(hoistVariableDeclaration);
99533
99555
  var errorRecord = factory.createUniqueName("e");
99534
99556
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99535
99557
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99546,12 +99568,17 @@ var ts;
99546
99568
  callValues;
99547
99569
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99548
99570
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99571
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99549
99572
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99550
99573
  factory.createVariableDeclaration(result)
99551
99574
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99552
- /*condition*/ factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)),
99575
+ /*condition*/ factory.inlineExpressions([
99576
+ factory.createAssignment(result, createDownlevelAwait(callNext)),
99577
+ factory.createAssignment(done, getDone),
99578
+ factory.createLogicalNot(done)
99579
+ ]),
99553
99580
  /*incrementor*/ undefined,
99554
- /*statement*/ convertForOfStatementHead(node, getValue)),
99581
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99555
99582
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99556
99583
  ts.setOriginalNode(forStatement, node);
99557
99584
  return factory.createTryStatement(factory.createBlock([
@@ -99563,7 +99590,7 @@ var ts;
99563
99590
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99564
99591
  factory.createTryStatement(
99565
99592
  /*tryBlock*/ factory.createBlock([
99566
- ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99593
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99567
99594
  ]),
99568
99595
  /*catchClause*/ undefined,
99569
99596
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105561,7 +105588,6 @@ var ts;
105561
105588
  return node;
105562
105589
  }
105563
105590
  function transformAndEmitForInStatement(node) {
105564
- // TODO(rbuckton): Source map locations
105565
105591
  if (containsYield(node)) {
105566
105592
  // [source]
105567
105593
  // for (var p in o) {
@@ -105569,34 +105595,41 @@ var ts;
105569
105595
  // }
105570
105596
  //
105571
105597
  // [intermediate]
105572
- // .local _a, _b, _i
105573
- // _a = [];
105574
- // for (_b in o) _a.push(_b);
105598
+ // .local _b, _a, _c, _i
105599
+ // _b = [];
105600
+ // _a = o;
105601
+ // for (_c in _a) _b.push(_c);
105575
105602
  // _i = 0;
105576
105603
  // .loop incrementLabel, endLoopLabel
105577
105604
  // .mark conditionLabel
105578
- // .brfalse endLoopLabel, (_i < _a.length)
105579
- // p = _a[_i];
105605
+ // .brfalse endLoopLabel, (_i < _b.length)
105606
+ // _c = _b[_i];
105607
+ // .brfalse incrementLabel, (_c in _a)
105608
+ // p = _c;
105580
105609
  // /*body*/
105581
105610
  // .mark incrementLabel
105582
- // _b++;
105611
+ // _c++;
105583
105612
  // .br conditionLabel
105584
105613
  // .endloop
105585
105614
  // .mark endLoopLabel
105586
- var keysArray = declareLocal(); // _a
105587
- var key = declareLocal(); // _b
105615
+ var obj = declareLocal(); // _a
105616
+ var keysArray = declareLocal(); // _b
105617
+ var key = declareLocal(); // _c
105588
105618
  var keysIndex = factory.createLoopVariable(); // _i
105589
105619
  var initializer = node.initializer;
105590
105620
  hoistVariableDeclaration(keysIndex);
105621
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105591
105622
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105592
- emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105623
+ emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105593
105624
  /*typeArguments*/ undefined, [key]))));
105594
105625
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105595
105626
  var conditionLabel = defineLabel();
105596
105627
  var incrementLabel = defineLabel();
105597
- var endLabel = beginLoopBlock(incrementLabel);
105628
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105598
105629
  markLabel(conditionLabel);
105599
- emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105630
+ emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105631
+ emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
105632
+ emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101 /* SyntaxKind.InKeyword */, obj));
105600
105633
  var variable = void 0;
105601
105634
  if (ts.isVariableDeclarationList(initializer)) {
105602
105635
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105609,7 +105642,7 @@ var ts;
105609
105642
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105610
105643
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105611
105644
  }
105612
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105645
+ emitAssignment(variable, key);
105613
105646
  transformAndEmitEmbeddedStatement(node.statement);
105614
105647
  markLabel(incrementLabel);
105615
105648
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
@@ -153281,6 +153314,26 @@ var ts;
153281
153314
  function startPositionToDeleteNodeInList(sourceFile, node) {
153282
153315
  return ts.skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
153283
153316
  }
153317
+ function endPositionToDeleteNodeInList(sourceFile, node, prevNode, nextNode) {
153318
+ var end = startPositionToDeleteNodeInList(sourceFile, nextNode);
153319
+ if (prevNode === undefined || ts.positionsAreOnSameLine(getAdjustedEndPosition(sourceFile, node, {}), end, sourceFile)) {
153320
+ return end;
153321
+ }
153322
+ var token = ts.findPrecedingToken(nextNode.getStart(sourceFile), sourceFile);
153323
+ if (isSeparator(node, token)) {
153324
+ var prevToken = ts.findPrecedingToken(node.getStart(sourceFile), sourceFile);
153325
+ if (isSeparator(prevNode, prevToken)) {
153326
+ var pos = ts.skipTrivia(sourceFile.text, token.getEnd(), /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);
153327
+ if (ts.positionsAreOnSameLine(prevToken.getStart(sourceFile), token.getStart(sourceFile), sourceFile)) {
153328
+ return ts.isLineBreak(sourceFile.text.charCodeAt(pos - 1)) ? pos - 1 : pos;
153329
+ }
153330
+ if (ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
153331
+ return pos;
153332
+ }
153333
+ }
153334
+ }
153335
+ return end;
153336
+ }
153284
153337
  function getClassOrObjectBraceEnds(cls, sourceFile) {
153285
153338
  var open = ts.findChildOfKind(cls, 18 /* SyntaxKind.OpenBraceToken */, sourceFile);
153286
153339
  var close = ts.findChildOfKind(cls, 19 /* SyntaxKind.CloseBraceToken */, sourceFile);
@@ -153838,7 +153891,7 @@ var ts;
153838
153891
  deletedNodesInLists.add(node);
153839
153892
  changes.deleteRange(sourceFile, {
153840
153893
  pos: startPositionToDeleteNodeInList(sourceFile, node),
153841
- end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : startPositionToDeleteNodeInList(sourceFile, containingList[index + 1]),
153894
+ end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : endPositionToDeleteNodeInList(sourceFile, node, containingList[index - 1], containingList[index + 1]),
153842
153895
  });
153843
153896
  }
153844
153897
  })(textChanges = ts.textChanges || (ts.textChanges = {}));
package/lib/typingsInstaller.js CHANGED
@@ -89,7 +89,7 @@ var ts;
89
89
  // The following is baselined as a literal template type without intervention
90
90
  /** The version of the TypeScript compiler release */
91
91
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
92
- ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221027");
92
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
93
93
  /* @internal */
94
94
  var Comparison;
95
95
  (function (Comparison) {
@@ -71591,6 +71591,7 @@ var ts;
71591
71591
  ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
71592
71592
  }
71593
71593
  function getExplicitTypeOfSymbol(symbol, diagnostic) {
71594
+ symbol = resolveSymbol(symbol);
71594
71595
  if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) {
71595
71596
  return getTypeOfSymbol(symbol);
71596
71597
  }
@@ -71629,7 +71630,7 @@ var ts;
71629
71630
  switch (node.kind) {
71630
71631
  case 79 /* SyntaxKind.Identifier */:
71631
71632
  var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
71632
- return getExplicitTypeOfSymbol(symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol, diagnostic);
71633
+ return getExplicitTypeOfSymbol(symbol, diagnostic);
71633
71634
  case 108 /* SyntaxKind.ThisKeyword */:
71634
71635
  return getExplicitThisType(node);
71635
71636
  case 106 /* SyntaxKind.SuperKeyword */:
@@ -99494,11 +99495,22 @@ var ts;
99494
99495
  }
99495
99496
  return node;
99496
99497
  }
99497
- function convertForOfStatementHead(node, boundValue) {
99498
- var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
99498
+ function convertForOfStatementHead(node, boundValue, nonUserCode) {
99499
+ var value = factory.createTempVariable(hoistVariableDeclaration);
99500
+ var iteratorValueExpression = factory.createAssignment(value, boundValue);
99501
+ var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
99502
+ ts.setSourceMapRange(iteratorValueStatement, node.expression);
99503
+ var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
99504
+ var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
99505
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99506
+ var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
99507
+ var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
99508
+ ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
99509
+ var statements = [];
99510
+ var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
99511
+ statements.push(ts.visitNode(binding, visitor, ts.isStatement));
99499
99512
  var bodyLocation;
99500
99513
  var statementsLocation;
99501
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99502
99514
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99503
99515
  if (ts.isBlock(statement)) {
99504
99516
  ts.addRange(statements, statement.statements);
@@ -99508,8 +99520,16 @@ var ts;
99508
99520
  else {
99509
99521
  statements.push(statement);
99510
99522
  }
99511
- return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99523
+ var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation),
99512
99524
  /*multiLine*/ true), bodyLocation), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */);
99525
+ return factory.createBlock([
99526
+ iteratorValueStatement,
99527
+ exitNonUserCodeStatement,
99528
+ factory.createTryStatement(body,
99529
+ /*catchClause*/ undefined, factory.createBlock([
99530
+ enterNonUserCodeStatement
99531
+ ]))
99532
+ ]);
99513
99533
  }
99514
99534
  function createDownlevelAwait(expression) {
99515
99535
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99520,6 +99540,8 @@ var ts;
99520
99540
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99521
99541
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99522
99542
  var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99543
+ var nonUserCode = factory.createTempVariable(/*recordTempVariable*/ undefined);
99544
+ var done = factory.createTempVariable(hoistVariableDeclaration);
99523
99545
  var errorRecord = factory.createUniqueName("e");
99524
99546
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99525
99547
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99536,12 +99558,17 @@ var ts;
99536
99558
  callValues;
99537
99559
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99538
99560
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99561
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99539
99562
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99540
99563
  factory.createVariableDeclaration(result)
99541
99564
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99542
- /*condition*/ factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)),
99565
+ /*condition*/ factory.inlineExpressions([
99566
+ factory.createAssignment(result, createDownlevelAwait(callNext)),
99567
+ factory.createAssignment(done, getDone),
99568
+ factory.createLogicalNot(done)
99569
+ ]),
99543
99570
  /*incrementor*/ undefined,
99544
- /*statement*/ convertForOfStatementHead(node, getValue)),
99571
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99545
99572
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99546
99573
  ts.setOriginalNode(forStatement, node);
99547
99574
  return factory.createTryStatement(factory.createBlock([
@@ -99553,7 +99580,7 @@ var ts;
99553
99580
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99554
99581
  factory.createTryStatement(
99555
99582
  /*tryBlock*/ factory.createBlock([
99556
- ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99583
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
99557
99584
  ]),
99558
99585
  /*catchClause*/ undefined,
99559
99586
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105551,7 +105578,6 @@ var ts;
105551
105578
  return node;
105552
105579
  }
105553
105580
  function transformAndEmitForInStatement(node) {
105554
- // TODO(rbuckton): Source map locations
105555
105581
  if (containsYield(node)) {
105556
105582
  // [source]
105557
105583
  // for (var p in o) {
@@ -105559,34 +105585,41 @@ var ts;
105559
105585
  // }
105560
105586
  //
105561
105587
  // [intermediate]
105562
- // .local _a, _b, _i
105563
- // _a = [];
105564
- // for (_b in o) _a.push(_b);
105588
+ // .local _b, _a, _c, _i
105589
+ // _b = [];
105590
+ // _a = o;
105591
+ // for (_c in _a) _b.push(_c);
105565
105592
  // _i = 0;
105566
105593
  // .loop incrementLabel, endLoopLabel
105567
105594
  // .mark conditionLabel
105568
- // .brfalse endLoopLabel, (_i < _a.length)
105569
- // p = _a[_i];
105595
+ // .brfalse endLoopLabel, (_i < _b.length)
105596
+ // _c = _b[_i];
105597
+ // .brfalse incrementLabel, (_c in _a)
105598
+ // p = _c;
105570
105599
  // /*body*/
105571
105600
  // .mark incrementLabel
105572
- // _b++;
105601
+ // _c++;
105573
105602
  // .br conditionLabel
105574
105603
  // .endloop
105575
105604
  // .mark endLoopLabel
105576
- var keysArray = declareLocal(); // _a
105577
- var key = declareLocal(); // _b
105605
+ var obj = declareLocal(); // _a
105606
+ var keysArray = declareLocal(); // _b
105607
+ var key = declareLocal(); // _c
105578
105608
  var keysIndex = factory.createLoopVariable(); // _i
105579
105609
  var initializer = node.initializer;
105580
105610
  hoistVariableDeclaration(keysIndex);
105611
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105581
105612
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105582
- emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105613
+ emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"),
105583
105614
  /*typeArguments*/ undefined, [key]))));
105584
105615
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105585
105616
  var conditionLabel = defineLabel();
105586
105617
  var incrementLabel = defineLabel();
105587
- var endLabel = beginLoopBlock(incrementLabel);
105618
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105588
105619
  markLabel(conditionLabel);
105589
- emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105620
+ emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
105621
+ emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
105622
+ emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101 /* SyntaxKind.InKeyword */, obj));
105590
105623
  var variable = void 0;
105591
105624
  if (ts.isVariableDeclarationList(initializer)) {
105592
105625
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105599,7 +105632,7 @@ var ts;
105599
105632
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105600
105633
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105601
105634
  }
105602
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105635
+ emitAssignment(variable, key);
105603
105636
  transformAndEmitEmbeddedStatement(node.statement);
105604
105637
  markLabel(incrementLabel);
105605
105638
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "typescript",
3
3
  "author": "Microsoft Corp.",
4
4
  "homepage": "https://www.typescriptlang.org/",
5
- "version": "4.9.0-dev.20221027",
5
+ "version": "4.9.0-dev.20221029",
6
6
  "license": "Apache-2.0",
7
7
  "description": "TypeScript is a language for application scale JavaScript development",
8
8
  "keywords": [