typescript 4.9.0-dev.20221028 → 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 +40 -11
  2. package/lib/tsserver.js +53 -21
  3. package/lib/tsserverlibrary.js +53 -21
  4. package/lib/typescript.js +53 -21
  5. package/lib/typescriptServices.js +53 -21
  6. package/lib/typingsInstaller.js +53 -21
  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.20221028");
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 :
@@ -83313,11 +83313,22 @@ var ts;
83313
83313
  }
83314
83314
  return node;
83315
83315
  }
83316
- function convertForOfStatementHead(node, boundValue) {
83317
- 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));
83318
83330
  var bodyLocation;
83319
83331
  var statementsLocation;
83320
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
83321
83332
  var statement = ts.visitIterationBody(node.statement, visitor, context);
83322
83333
  if (ts.isBlock(statement)) {
83323
83334
  ts.addRange(statements, statement.statements);
@@ -83327,7 +83338,14 @@ var ts;
83327
83338
  else {
83328
83339
  statements.push(statement);
83329
83340
  }
83330
- 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
+ ]);
83331
83349
  }
83332
83350
  function createDownlevelAwait(expression) {
83333
83351
  return enclosingFunctionFlags & 1
@@ -83338,6 +83356,8 @@ var ts;
83338
83356
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
83339
83357
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(undefined);
83340
83358
  var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(undefined);
83359
+ var nonUserCode = factory.createTempVariable(undefined);
83360
+ var done = factory.createTempVariable(hoistVariableDeclaration);
83341
83361
  var errorRecord = factory.createUniqueName("e");
83342
83362
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
83343
83363
  var returnMethod = factory.createTempVariable(undefined);
@@ -83352,9 +83372,14 @@ var ts;
83352
83372
  factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), callValues]) :
83353
83373
  callValues;
83354
83374
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
83375
+ factory.createVariableDeclaration(nonUserCode, undefined, undefined, factory.createTrue()),
83355
83376
  ts.setTextRange(factory.createVariableDeclaration(iterator, undefined, undefined, initializer), node.expression),
83356
83377
  factory.createVariableDeclaration(result)
83357
- ]), 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);
83358
83383
  ts.setOriginalNode(forStatement, node);
83359
83384
  return factory.createTryStatement(factory.createBlock([
83360
83385
  factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement)
@@ -83364,7 +83389,7 @@ var ts;
83364
83389
  ])))
83365
83390
  ]), 1)), factory.createBlock([
83366
83391
  factory.createTryStatement(factory.createBlock([
83367
- 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)
83368
83393
  ]), undefined, ts.setEmitFlags(factory.createBlock([
83369
83394
  ts.setEmitFlags(factory.createIfStatement(errorRecord, factory.createThrowStatement(factory.createPropertyAccessExpression(errorRecord, "error"))), 1)
83370
83395
  ]), 1))
@@ -87466,19 +87491,23 @@ var ts;
87466
87491
  }
87467
87492
  function transformAndEmitForInStatement(node) {
87468
87493
  if (containsYield(node)) {
87494
+ var obj = declareLocal();
87469
87495
  var keysArray = declareLocal();
87470
87496
  var key = declareLocal();
87471
87497
  var keysIndex = factory.createLoopVariable();
87472
87498
  var initializer = node.initializer;
87473
87499
  hoistVariableDeclaration(keysIndex);
87500
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
87474
87501
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
87475
- 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]))));
87476
87503
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
87477
87504
  var conditionLabel = defineLabel();
87478
87505
  var incrementLabel = defineLabel();
87479
- var endLabel = beginLoopBlock(incrementLabel);
87506
+ var endLoopLabel = beginLoopBlock(incrementLabel);
87480
87507
  markLabel(conditionLabel);
87481
- 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));
87482
87511
  var variable = void 0;
87483
87512
  if (ts.isVariableDeclarationList(initializer)) {
87484
87513
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -87491,7 +87520,7 @@ var ts;
87491
87520
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
87492
87521
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
87493
87522
  }
87494
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
87523
+ emitAssignment(variable, key);
87495
87524
  transformAndEmitEmbeddedStatement(node.statement);
87496
87525
  markLabel(incrementLabel);
87497
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.20221028");
112
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
113
113
  /* @internal */
114
114
  var Comparison;
115
115
  (function (Comparison) {
@@ -99515,11 +99515,22 @@ var ts;
99515
99515
  }
99516
99516
  return node;
99517
99517
  }
99518
- function convertForOfStatementHead(node, boundValue) {
99519
- 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));
99520
99532
  var bodyLocation;
99521
99533
  var statementsLocation;
99522
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99523
99534
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99524
99535
  if (ts.isBlock(statement)) {
99525
99536
  ts.addRange(statements, statement.statements);
@@ -99529,8 +99540,16 @@ var ts;
99529
99540
  else {
99530
99541
  statements.push(statement);
99531
99542
  }
99532
- 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),
99533
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
+ ]);
99534
99553
  }
99535
99554
  function createDownlevelAwait(expression) {
99536
99555
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99541,6 +99560,8 @@ var ts;
99541
99560
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99542
99561
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99543
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);
99544
99565
  var errorRecord = factory.createUniqueName("e");
99545
99566
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99546
99567
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99557,12 +99578,17 @@ var ts;
99557
99578
  callValues;
99558
99579
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99559
99580
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99581
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99560
99582
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99561
99583
  factory.createVariableDeclaration(result)
99562
99584
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99563
- /*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
+ ]),
99564
99590
  /*incrementor*/ undefined,
99565
- /*statement*/ convertForOfStatementHead(node, getValue)),
99591
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99566
99592
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99567
99593
  ts.setOriginalNode(forStatement, node);
99568
99594
  return factory.createTryStatement(factory.createBlock([
@@ -99574,7 +99600,7 @@ var ts;
99574
99600
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99575
99601
  factory.createTryStatement(
99576
99602
  /*tryBlock*/ factory.createBlock([
99577
- 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 */)
99578
99604
  ]),
99579
99605
  /*catchClause*/ undefined,
99580
99606
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105572,7 +105598,6 @@ var ts;
105572
105598
  return node;
105573
105599
  }
105574
105600
  function transformAndEmitForInStatement(node) {
105575
- // TODO(rbuckton): Source map locations
105576
105601
  if (containsYield(node)) {
105577
105602
  // [source]
105578
105603
  // for (var p in o) {
@@ -105580,34 +105605,41 @@ var ts;
105580
105605
  // }
105581
105606
  //
105582
105607
  // [intermediate]
105583
- // .local _a, _b, _i
105584
- // _a = [];
105585
- // 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);
105586
105612
  // _i = 0;
105587
105613
  // .loop incrementLabel, endLoopLabel
105588
105614
  // .mark conditionLabel
105589
- // .brfalse endLoopLabel, (_i < _a.length)
105590
- // p = _a[_i];
105615
+ // .brfalse endLoopLabel, (_i < _b.length)
105616
+ // _c = _b[_i];
105617
+ // .brfalse incrementLabel, (_c in _a)
105618
+ // p = _c;
105591
105619
  // /*body*/
105592
105620
  // .mark incrementLabel
105593
- // _b++;
105621
+ // _c++;
105594
105622
  // .br conditionLabel
105595
105623
  // .endloop
105596
105624
  // .mark endLoopLabel
105597
- var keysArray = declareLocal(); // _a
105598
- var key = declareLocal(); // _b
105625
+ var obj = declareLocal(); // _a
105626
+ var keysArray = declareLocal(); // _b
105627
+ var key = declareLocal(); // _c
105599
105628
  var keysIndex = factory.createLoopVariable(); // _i
105600
105629
  var initializer = node.initializer;
105601
105630
  hoistVariableDeclaration(keysIndex);
105631
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105602
105632
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105603
- 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"),
105604
105634
  /*typeArguments*/ undefined, [key]))));
105605
105635
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105606
105636
  var conditionLabel = defineLabel();
105607
105637
  var incrementLabel = defineLabel();
105608
- var endLabel = beginLoopBlock(incrementLabel);
105638
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105609
105639
  markLabel(conditionLabel);
105610
- 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));
105611
105643
  var variable = void 0;
105612
105644
  if (ts.isVariableDeclarationList(initializer)) {
105613
105645
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105620,7 +105652,7 @@ var ts;
105620
105652
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105621
105653
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105622
105654
  }
105623
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105655
+ emitAssignment(variable, key);
105624
105656
  transformAndEmitEmbeddedStatement(node.statement);
105625
105657
  markLabel(incrementLabel);
105626
105658
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
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.20221028");
111
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
112
112
  /* @internal */
113
113
  var Comparison;
114
114
  (function (Comparison) {
@@ -99514,11 +99514,22 @@ var ts;
99514
99514
  }
99515
99515
  return node;
99516
99516
  }
99517
- function convertForOfStatementHead(node, boundValue) {
99518
- 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));
99519
99531
  var bodyLocation;
99520
99532
  var statementsLocation;
99521
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99522
99533
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99523
99534
  if (ts.isBlock(statement)) {
99524
99535
  ts.addRange(statements, statement.statements);
@@ -99528,8 +99539,16 @@ var ts;
99528
99539
  else {
99529
99540
  statements.push(statement);
99530
99541
  }
99531
- 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),
99532
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
+ ]);
99533
99552
  }
99534
99553
  function createDownlevelAwait(expression) {
99535
99554
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99540,6 +99559,8 @@ var ts;
99540
99559
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99541
99560
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99542
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);
99543
99564
  var errorRecord = factory.createUniqueName("e");
99544
99565
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99545
99566
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99556,12 +99577,17 @@ var ts;
99556
99577
  callValues;
99557
99578
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99558
99579
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99580
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99559
99581
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99560
99582
  factory.createVariableDeclaration(result)
99561
99583
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99562
- /*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
+ ]),
99563
99589
  /*incrementor*/ undefined,
99564
- /*statement*/ convertForOfStatementHead(node, getValue)),
99590
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99565
99591
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99566
99592
  ts.setOriginalNode(forStatement, node);
99567
99593
  return factory.createTryStatement(factory.createBlock([
@@ -99573,7 +99599,7 @@ var ts;
99573
99599
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99574
99600
  factory.createTryStatement(
99575
99601
  /*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 */)
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 */)
99577
99603
  ]),
99578
99604
  /*catchClause*/ undefined,
99579
99605
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105571,7 +105597,6 @@ var ts;
105571
105597
  return node;
105572
105598
  }
105573
105599
  function transformAndEmitForInStatement(node) {
105574
- // TODO(rbuckton): Source map locations
105575
105600
  if (containsYield(node)) {
105576
105601
  // [source]
105577
105602
  // for (var p in o) {
@@ -105579,34 +105604,41 @@ var ts;
105579
105604
  // }
105580
105605
  //
105581
105606
  // [intermediate]
105582
- // .local _a, _b, _i
105583
- // _a = [];
105584
- // 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);
105585
105611
  // _i = 0;
105586
105612
  // .loop incrementLabel, endLoopLabel
105587
105613
  // .mark conditionLabel
105588
- // .brfalse endLoopLabel, (_i < _a.length)
105589
- // p = _a[_i];
105614
+ // .brfalse endLoopLabel, (_i < _b.length)
105615
+ // _c = _b[_i];
105616
+ // .brfalse incrementLabel, (_c in _a)
105617
+ // p = _c;
105590
105618
  // /*body*/
105591
105619
  // .mark incrementLabel
105592
- // _b++;
105620
+ // _c++;
105593
105621
  // .br conditionLabel
105594
105622
  // .endloop
105595
105623
  // .mark endLoopLabel
105596
- var keysArray = declareLocal(); // _a
105597
- var key = declareLocal(); // _b
105624
+ var obj = declareLocal(); // _a
105625
+ var keysArray = declareLocal(); // _b
105626
+ var key = declareLocal(); // _c
105598
105627
  var keysIndex = factory.createLoopVariable(); // _i
105599
105628
  var initializer = node.initializer;
105600
105629
  hoistVariableDeclaration(keysIndex);
105630
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105601
105631
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105602
- 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"),
105603
105633
  /*typeArguments*/ undefined, [key]))));
105604
105634
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105605
105635
  var conditionLabel = defineLabel();
105606
105636
  var incrementLabel = defineLabel();
105607
- var endLabel = beginLoopBlock(incrementLabel);
105637
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105608
105638
  markLabel(conditionLabel);
105609
- 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));
105610
105642
  var variable = void 0;
105611
105643
  if (ts.isVariableDeclarationList(initializer)) {
105612
105644
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105619,7 +105651,7 @@ var ts;
105619
105651
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105620
105652
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105621
105653
  }
105622
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105654
+ emitAssignment(variable, key);
105623
105655
  transformAndEmitEmbeddedStatement(node.statement);
105624
105656
  markLabel(incrementLabel);
105625
105657
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
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.20221028");
102
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
103
103
  /* @internal */
104
104
  var Comparison;
105
105
  (function (Comparison) {
@@ -99505,11 +99505,22 @@ var ts;
99505
99505
  }
99506
99506
  return node;
99507
99507
  }
99508
- function convertForOfStatementHead(node, boundValue) {
99509
- 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));
99510
99522
  var bodyLocation;
99511
99523
  var statementsLocation;
99512
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99513
99524
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99514
99525
  if (ts.isBlock(statement)) {
99515
99526
  ts.addRange(statements, statement.statements);
@@ -99519,8 +99530,16 @@ var ts;
99519
99530
  else {
99520
99531
  statements.push(statement);
99521
99532
  }
99522
- 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),
99523
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
+ ]);
99524
99543
  }
99525
99544
  function createDownlevelAwait(expression) {
99526
99545
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99531,6 +99550,8 @@ var ts;
99531
99550
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99532
99551
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99533
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);
99534
99555
  var errorRecord = factory.createUniqueName("e");
99535
99556
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99536
99557
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99547,12 +99568,17 @@ var ts;
99547
99568
  callValues;
99548
99569
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99549
99570
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99571
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99550
99572
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99551
99573
  factory.createVariableDeclaration(result)
99552
99574
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99553
- /*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
+ ]),
99554
99580
  /*incrementor*/ undefined,
99555
- /*statement*/ convertForOfStatementHead(node, getValue)),
99581
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99556
99582
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99557
99583
  ts.setOriginalNode(forStatement, node);
99558
99584
  return factory.createTryStatement(factory.createBlock([
@@ -99564,7 +99590,7 @@ var ts;
99564
99590
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99565
99591
  factory.createTryStatement(
99566
99592
  /*tryBlock*/ factory.createBlock([
99567
- 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 */)
99568
99594
  ]),
99569
99595
  /*catchClause*/ undefined,
99570
99596
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105562,7 +105588,6 @@ var ts;
105562
105588
  return node;
105563
105589
  }
105564
105590
  function transformAndEmitForInStatement(node) {
105565
- // TODO(rbuckton): Source map locations
105566
105591
  if (containsYield(node)) {
105567
105592
  // [source]
105568
105593
  // for (var p in o) {
@@ -105570,34 +105595,41 @@ var ts;
105570
105595
  // }
105571
105596
  //
105572
105597
  // [intermediate]
105573
- // .local _a, _b, _i
105574
- // _a = [];
105575
- // 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);
105576
105602
  // _i = 0;
105577
105603
  // .loop incrementLabel, endLoopLabel
105578
105604
  // .mark conditionLabel
105579
- // .brfalse endLoopLabel, (_i < _a.length)
105580
- // p = _a[_i];
105605
+ // .brfalse endLoopLabel, (_i < _b.length)
105606
+ // _c = _b[_i];
105607
+ // .brfalse incrementLabel, (_c in _a)
105608
+ // p = _c;
105581
105609
  // /*body*/
105582
105610
  // .mark incrementLabel
105583
- // _b++;
105611
+ // _c++;
105584
105612
  // .br conditionLabel
105585
105613
  // .endloop
105586
105614
  // .mark endLoopLabel
105587
- var keysArray = declareLocal(); // _a
105588
- var key = declareLocal(); // _b
105615
+ var obj = declareLocal(); // _a
105616
+ var keysArray = declareLocal(); // _b
105617
+ var key = declareLocal(); // _c
105589
105618
  var keysIndex = factory.createLoopVariable(); // _i
105590
105619
  var initializer = node.initializer;
105591
105620
  hoistVariableDeclaration(keysIndex);
105621
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105592
105622
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105593
- 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"),
105594
105624
  /*typeArguments*/ undefined, [key]))));
105595
105625
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105596
105626
  var conditionLabel = defineLabel();
105597
105627
  var incrementLabel = defineLabel();
105598
- var endLabel = beginLoopBlock(incrementLabel);
105628
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105599
105629
  markLabel(conditionLabel);
105600
- 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));
105601
105633
  var variable = void 0;
105602
105634
  if (ts.isVariableDeclarationList(initializer)) {
105603
105635
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105610,7 +105642,7 @@ var ts;
105610
105642
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105611
105643
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105612
105644
  }
105613
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105645
+ emitAssignment(variable, key);
105614
105646
  transformAndEmitEmbeddedStatement(node.statement);
105615
105647
  markLabel(incrementLabel);
105616
105648
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
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.20221028");
102
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
103
103
  /* @internal */
104
104
  var Comparison;
105
105
  (function (Comparison) {
@@ -99505,11 +99505,22 @@ var ts;
99505
99505
  }
99506
99506
  return node;
99507
99507
  }
99508
- function convertForOfStatementHead(node, boundValue) {
99509
- 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));
99510
99522
  var bodyLocation;
99511
99523
  var statementsLocation;
99512
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99513
99524
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99514
99525
  if (ts.isBlock(statement)) {
99515
99526
  ts.addRange(statements, statement.statements);
@@ -99519,8 +99530,16 @@ var ts;
99519
99530
  else {
99520
99531
  statements.push(statement);
99521
99532
  }
99522
- 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),
99523
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
+ ]);
99524
99543
  }
99525
99544
  function createDownlevelAwait(expression) {
99526
99545
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99531,6 +99550,8 @@ var ts;
99531
99550
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99532
99551
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99533
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);
99534
99555
  var errorRecord = factory.createUniqueName("e");
99535
99556
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99536
99557
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99547,12 +99568,17 @@ var ts;
99547
99568
  callValues;
99548
99569
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99549
99570
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99571
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99550
99572
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99551
99573
  factory.createVariableDeclaration(result)
99552
99574
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99553
- /*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
+ ]),
99554
99580
  /*incrementor*/ undefined,
99555
- /*statement*/ convertForOfStatementHead(node, getValue)),
99581
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99556
99582
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99557
99583
  ts.setOriginalNode(forStatement, node);
99558
99584
  return factory.createTryStatement(factory.createBlock([
@@ -99564,7 +99590,7 @@ var ts;
99564
99590
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99565
99591
  factory.createTryStatement(
99566
99592
  /*tryBlock*/ factory.createBlock([
99567
- 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 */)
99568
99594
  ]),
99569
99595
  /*catchClause*/ undefined,
99570
99596
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105562,7 +105588,6 @@ var ts;
105562
105588
  return node;
105563
105589
  }
105564
105590
  function transformAndEmitForInStatement(node) {
105565
- // TODO(rbuckton): Source map locations
105566
105591
  if (containsYield(node)) {
105567
105592
  // [source]
105568
105593
  // for (var p in o) {
@@ -105570,34 +105595,41 @@ var ts;
105570
105595
  // }
105571
105596
  //
105572
105597
  // [intermediate]
105573
- // .local _a, _b, _i
105574
- // _a = [];
105575
- // 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);
105576
105602
  // _i = 0;
105577
105603
  // .loop incrementLabel, endLoopLabel
105578
105604
  // .mark conditionLabel
105579
- // .brfalse endLoopLabel, (_i < _a.length)
105580
- // p = _a[_i];
105605
+ // .brfalse endLoopLabel, (_i < _b.length)
105606
+ // _c = _b[_i];
105607
+ // .brfalse incrementLabel, (_c in _a)
105608
+ // p = _c;
105581
105609
  // /*body*/
105582
105610
  // .mark incrementLabel
105583
- // _b++;
105611
+ // _c++;
105584
105612
  // .br conditionLabel
105585
105613
  // .endloop
105586
105614
  // .mark endLoopLabel
105587
- var keysArray = declareLocal(); // _a
105588
- var key = declareLocal(); // _b
105615
+ var obj = declareLocal(); // _a
105616
+ var keysArray = declareLocal(); // _b
105617
+ var key = declareLocal(); // _c
105589
105618
  var keysIndex = factory.createLoopVariable(); // _i
105590
105619
  var initializer = node.initializer;
105591
105620
  hoistVariableDeclaration(keysIndex);
105621
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105592
105622
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105593
- 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"),
105594
105624
  /*typeArguments*/ undefined, [key]))));
105595
105625
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105596
105626
  var conditionLabel = defineLabel();
105597
105627
  var incrementLabel = defineLabel();
105598
- var endLabel = beginLoopBlock(incrementLabel);
105628
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105599
105629
  markLabel(conditionLabel);
105600
- 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));
105601
105633
  var variable = void 0;
105602
105634
  if (ts.isVariableDeclarationList(initializer)) {
105603
105635
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105610,7 +105642,7 @@ var ts;
105610
105642
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105611
105643
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105612
105644
  }
105613
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105645
+ emitAssignment(variable, key);
105614
105646
  transformAndEmitEmbeddedStatement(node.statement);
105615
105647
  markLabel(incrementLabel);
105616
105648
  emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
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.20221028");
92
+ ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221029");
93
93
  /* @internal */
94
94
  var Comparison;
95
95
  (function (Comparison) {
@@ -99495,11 +99495,22 @@ var ts;
99495
99495
  }
99496
99496
  return node;
99497
99497
  }
99498
- function convertForOfStatementHead(node, boundValue) {
99499
- 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));
99500
99512
  var bodyLocation;
99501
99513
  var statementsLocation;
99502
- var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
99503
99514
  var statement = ts.visitIterationBody(node.statement, visitor, context);
99504
99515
  if (ts.isBlock(statement)) {
99505
99516
  ts.addRange(statements, statement.statements);
@@ -99509,8 +99520,16 @@ var ts;
99509
99520
  else {
99510
99521
  statements.push(statement);
99511
99522
  }
99512
- 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),
99513
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
+ ]);
99514
99533
  }
99515
99534
  function createDownlevelAwait(expression) {
99516
99535
  return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99521,6 +99540,8 @@ var ts;
99521
99540
  var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
99522
99541
  var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
99523
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);
99524
99545
  var errorRecord = factory.createUniqueName("e");
99525
99546
  var catchVariable = factory.getGeneratedNameForNode(errorRecord);
99526
99547
  var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99537,12 +99558,17 @@ var ts;
99537
99558
  callValues;
99538
99559
  var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
99539
99560
  /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
99561
+ factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
99540
99562
  ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
99541
99563
  factory.createVariableDeclaration(result)
99542
99564
  ]), node.expression), 2097152 /* EmitFlags.NoHoisting */),
99543
- /*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
+ ]),
99544
99570
  /*incrementor*/ undefined,
99545
- /*statement*/ convertForOfStatementHead(node, getValue)),
99571
+ /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)),
99546
99572
  /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
99547
99573
  ts.setOriginalNode(forStatement, node);
99548
99574
  return factory.createTryStatement(factory.createBlock([
@@ -99554,7 +99580,7 @@ var ts;
99554
99580
  ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
99555
99581
  factory.createTryStatement(
99556
99582
  /*tryBlock*/ factory.createBlock([
99557
- 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 */)
99558
99584
  ]),
99559
99585
  /*catchClause*/ undefined,
99560
99586
  /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -105552,7 +105578,6 @@ var ts;
105552
105578
  return node;
105553
105579
  }
105554
105580
  function transformAndEmitForInStatement(node) {
105555
- // TODO(rbuckton): Source map locations
105556
105581
  if (containsYield(node)) {
105557
105582
  // [source]
105558
105583
  // for (var p in o) {
@@ -105560,34 +105585,41 @@ var ts;
105560
105585
  // }
105561
105586
  //
105562
105587
  // [intermediate]
105563
- // .local _a, _b, _i
105564
- // _a = [];
105565
- // 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);
105566
105592
  // _i = 0;
105567
105593
  // .loop incrementLabel, endLoopLabel
105568
105594
  // .mark conditionLabel
105569
- // .brfalse endLoopLabel, (_i < _a.length)
105570
- // p = _a[_i];
105595
+ // .brfalse endLoopLabel, (_i < _b.length)
105596
+ // _c = _b[_i];
105597
+ // .brfalse incrementLabel, (_c in _a)
105598
+ // p = _c;
105571
105599
  // /*body*/
105572
105600
  // .mark incrementLabel
105573
- // _b++;
105601
+ // _c++;
105574
105602
  // .br conditionLabel
105575
105603
  // .endloop
105576
105604
  // .mark endLoopLabel
105577
- var keysArray = declareLocal(); // _a
105578
- var key = declareLocal(); // _b
105605
+ var obj = declareLocal(); // _a
105606
+ var keysArray = declareLocal(); // _b
105607
+ var key = declareLocal(); // _c
105579
105608
  var keysIndex = factory.createLoopVariable(); // _i
105580
105609
  var initializer = node.initializer;
105581
105610
  hoistVariableDeclaration(keysIndex);
105611
+ emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
105582
105612
  emitAssignment(keysArray, factory.createArrayLiteralExpression());
105583
- 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"),
105584
105614
  /*typeArguments*/ undefined, [key]))));
105585
105615
  emitAssignment(keysIndex, factory.createNumericLiteral(0));
105586
105616
  var conditionLabel = defineLabel();
105587
105617
  var incrementLabel = defineLabel();
105588
- var endLabel = beginLoopBlock(incrementLabel);
105618
+ var endLoopLabel = beginLoopBlock(incrementLabel);
105589
105619
  markLabel(conditionLabel);
105590
- 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));
105591
105623
  var variable = void 0;
105592
105624
  if (ts.isVariableDeclarationList(initializer)) {
105593
105625
  for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105600,7 +105632,7 @@ var ts;
105600
105632
  variable = ts.visitNode(initializer, visitor, ts.isExpression);
105601
105633
  ts.Debug.assert(ts.isLeftHandSideExpression(variable));
105602
105634
  }
105603
- emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
105635
+ emitAssignment(variable, key);
105604
105636
  transformAndEmitEmbeddedStatement(node.statement);
105605
105637
  markLabel(incrementLabel);
105606
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.20221028",
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": [