@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721

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 (184) hide show
  1. package/dist/analyzer/analyzerNodeInfo.js +74 -46
  2. package/dist/analyzer/analyzerNodeInfo.js.map +1 -1
  3. package/dist/analyzer/binder.js +506 -512
  4. package/dist/analyzer/binder.js.map +1 -1
  5. package/dist/analyzer/checker.js +672 -655
  6. package/dist/analyzer/checker.js.map +1 -1
  7. package/dist/analyzer/codeFlowEngine.d.ts +5 -3
  8. package/dist/analyzer/codeFlowEngine.js +112 -103
  9. package/dist/analyzer/codeFlowEngine.js.map +1 -1
  10. package/dist/analyzer/codeFlowTypes.js +30 -28
  11. package/dist/analyzer/codeFlowTypes.js.map +1 -1
  12. package/dist/analyzer/constraintSolver.js +70 -66
  13. package/dist/analyzer/constraintSolver.js.map +1 -1
  14. package/dist/analyzer/constructorTransform.d.ts +1 -2
  15. package/dist/analyzer/constructorTransform.js +26 -27
  16. package/dist/analyzer/constructorTransform.js.map +1 -1
  17. package/dist/analyzer/constructors.d.ts +2 -2
  18. package/dist/analyzer/constructors.js +95 -190
  19. package/dist/analyzer/constructors.js.map +1 -1
  20. package/dist/analyzer/dataClasses.js +110 -179
  21. package/dist/analyzer/dataClasses.js.map +1 -1
  22. package/dist/analyzer/declarationUtils.js +14 -15
  23. package/dist/analyzer/declarationUtils.js.map +1 -1
  24. package/dist/analyzer/decorators.js +78 -79
  25. package/dist/analyzer/decorators.js.map +1 -1
  26. package/dist/analyzer/enums.js +70 -56
  27. package/dist/analyzer/enums.js.map +1 -1
  28. package/dist/analyzer/functionTransform.js +8 -18
  29. package/dist/analyzer/functionTransform.js.map +1 -1
  30. package/dist/analyzer/importResolver.d.ts +2 -1
  31. package/dist/analyzer/importResolver.js +40 -29
  32. package/dist/analyzer/importResolver.js.map +1 -1
  33. package/dist/analyzer/importStatementUtils.js +27 -27
  34. package/dist/analyzer/importStatementUtils.js.map +1 -1
  35. package/dist/analyzer/namedTuples.js +33 -59
  36. package/dist/analyzer/namedTuples.js.map +1 -1
  37. package/dist/analyzer/operations.js +194 -145
  38. package/dist/analyzer/operations.js.map +1 -1
  39. package/dist/analyzer/packageTypeVerifier.js +66 -62
  40. package/dist/analyzer/packageTypeVerifier.js.map +1 -1
  41. package/dist/analyzer/parameterUtils.d.ts +4 -4
  42. package/dist/analyzer/parameterUtils.js +30 -47
  43. package/dist/analyzer/parameterUtils.js.map +1 -1
  44. package/dist/analyzer/parseTreeUtils.d.ts +1 -0
  45. package/dist/analyzer/parseTreeUtils.js +294 -272
  46. package/dist/analyzer/parseTreeUtils.js.map +1 -1
  47. package/dist/analyzer/parseTreeWalker.js +76 -76
  48. package/dist/analyzer/parseTreeWalker.js.map +1 -1
  49. package/dist/analyzer/patternMatching.js +178 -145
  50. package/dist/analyzer/patternMatching.js.map +1 -1
  51. package/dist/analyzer/program.js +1 -1
  52. package/dist/analyzer/program.js.map +1 -1
  53. package/dist/analyzer/properties.js +82 -147
  54. package/dist/analyzer/properties.js.map +1 -1
  55. package/dist/analyzer/protocols.js +29 -25
  56. package/dist/analyzer/protocols.js.map +1 -1
  57. package/dist/analyzer/sourceFile.js +3 -3
  58. package/dist/analyzer/sourceFile.js.map +1 -1
  59. package/dist/analyzer/sourceMapper.js +20 -19
  60. package/dist/analyzer/sourceMapper.js.map +1 -1
  61. package/dist/analyzer/staticExpressions.js +83 -84
  62. package/dist/analyzer/staticExpressions.js.map +1 -1
  63. package/dist/analyzer/testWalker.js +15 -3
  64. package/dist/analyzer/testWalker.js.map +1 -1
  65. package/dist/analyzer/tracePrinter.js +20 -20
  66. package/dist/analyzer/tracePrinter.js.map +1 -1
  67. package/dist/analyzer/typeDocStringUtils.js +25 -25
  68. package/dist/analyzer/typeDocStringUtils.js.map +1 -1
  69. package/dist/analyzer/typeEvaluator.js +2443 -2350
  70. package/dist/analyzer/typeEvaluator.js.map +1 -1
  71. package/dist/analyzer/typeEvaluatorTypes.d.ts +13 -9
  72. package/dist/analyzer/typeEvaluatorTypes.js +7 -1
  73. package/dist/analyzer/typeEvaluatorTypes.js.map +1 -1
  74. package/dist/analyzer/typeGuards.js +212 -215
  75. package/dist/analyzer/typeGuards.js.map +1 -1
  76. package/dist/analyzer/typePrinter.js +118 -115
  77. package/dist/analyzer/typePrinter.js.map +1 -1
  78. package/dist/analyzer/typeStubWriter.js +104 -103
  79. package/dist/analyzer/typeStubWriter.js.map +1 -1
  80. package/dist/analyzer/typeUtils.d.ts +30 -15
  81. package/dist/analyzer/typeUtils.js +534 -436
  82. package/dist/analyzer/typeUtils.js.map +1 -1
  83. package/dist/analyzer/typeVarContext.js +8 -8
  84. package/dist/analyzer/typeVarContext.js.map +1 -1
  85. package/dist/analyzer/typeWalker.js +13 -10
  86. package/dist/analyzer/typeWalker.js.map +1 -1
  87. package/dist/analyzer/typedDicts.js +97 -199
  88. package/dist/analyzer/typedDicts.js.map +1 -1
  89. package/dist/analyzer/types.d.ts +152 -106
  90. package/dist/analyzer/types.js +695 -496
  91. package/dist/analyzer/types.js.map +1 -1
  92. package/dist/commands/dumpFileDebugInfoCommand.js +34 -34
  93. package/dist/commands/dumpFileDebugInfoCommand.js.map +1 -1
  94. package/dist/common/fileSystem.d.ts +1 -0
  95. package/dist/common/fileSystem.js.map +1 -1
  96. package/dist/common/fullAccessHost.js +6 -4
  97. package/dist/common/fullAccessHost.js.map +1 -1
  98. package/dist/common/realFileSystem.d.ts +1 -0
  99. package/dist/common/realFileSystem.js +4 -0
  100. package/dist/common/realFileSystem.js.map +1 -1
  101. package/dist/common/textEditTracker.js +14 -14
  102. package/dist/common/textEditTracker.js.map +1 -1
  103. package/dist/languageService/autoImporter.js +10 -10
  104. package/dist/languageService/autoImporter.js.map +1 -1
  105. package/dist/languageService/callHierarchyProvider.js +23 -23
  106. package/dist/languageService/callHierarchyProvider.js.map +1 -1
  107. package/dist/languageService/completionProvider.js +153 -151
  108. package/dist/languageService/completionProvider.js.map +1 -1
  109. package/dist/languageService/definitionProvider.d.ts +1 -1
  110. package/dist/languageService/definitionProvider.js +3 -1
  111. package/dist/languageService/definitionProvider.js.map +1 -1
  112. package/dist/languageService/documentSymbolCollector.js +19 -19
  113. package/dist/languageService/documentSymbolCollector.js.map +1 -1
  114. package/dist/languageService/hoverProvider.js +36 -27
  115. package/dist/languageService/hoverProvider.js.map +1 -1
  116. package/dist/languageService/importSorter.js +8 -8
  117. package/dist/languageService/importSorter.js.map +1 -1
  118. package/dist/languageService/referencesProvider.d.ts +10 -4
  119. package/dist/languageService/referencesProvider.js +30 -18
  120. package/dist/languageService/referencesProvider.js.map +1 -1
  121. package/dist/languageService/renameProvider.js +21 -4
  122. package/dist/languageService/renameProvider.js.map +1 -1
  123. package/dist/languageService/signatureHelpProvider.d.ts +1 -1
  124. package/dist/languageService/signatureHelpProvider.js +6 -6
  125. package/dist/languageService/signatureHelpProvider.js.map +1 -1
  126. package/dist/languageService/symbolIndexer.js +3 -3
  127. package/dist/languageService/symbolIndexer.js.map +1 -1
  128. package/dist/languageService/tooltipUtils.js +13 -13
  129. package/dist/languageService/tooltipUtils.js.map +1 -1
  130. package/dist/localization/localize.d.ts +4 -3
  131. package/dist/localization/localize.js +2 -1
  132. package/dist/localization/localize.js.map +1 -1
  133. package/dist/localization/package.nls.cs.json +0 -1
  134. package/dist/localization/package.nls.de.json +0 -1
  135. package/dist/localization/package.nls.en-us.json +2 -1
  136. package/dist/localization/package.nls.es.json +0 -1
  137. package/dist/localization/package.nls.fr.json +0 -1
  138. package/dist/localization/package.nls.it.json +0 -1
  139. package/dist/localization/package.nls.ja.json +0 -1
  140. package/dist/localization/package.nls.ko.json +0 -1
  141. package/dist/localization/package.nls.pl.json +0 -1
  142. package/dist/localization/package.nls.pt-br.json +0 -1
  143. package/dist/localization/package.nls.qps-ploc.json +0 -1
  144. package/dist/localization/package.nls.ru.json +0 -1
  145. package/dist/localization/package.nls.tr.json +0 -1
  146. package/dist/localization/package.nls.zh-cn.json +0 -1
  147. package/dist/localization/package.nls.zh-tw.json +0 -1
  148. package/dist/parser/parseNodes.d.ts +471 -402
  149. package/dist/parser/parseNodes.js +629 -356
  150. package/dist/parser/parseNodes.js.map +1 -1
  151. package/dist/parser/parser.d.ts +1 -0
  152. package/dist/parser/parser.js +345 -300
  153. package/dist/parser/parser.js.map +1 -1
  154. package/dist/tests/classDeclaration.test.js +14 -14
  155. package/dist/tests/classDeclaration.test.js.map +1 -1
  156. package/dist/tests/fourslash/rename.args.fourslash.d.ts +1 -0
  157. package/dist/tests/fourslash/rename.args.fourslash.js +71 -0
  158. package/dist/tests/fourslash/rename.args.fourslash.js.map +1 -0
  159. package/dist/tests/harness/vfs/filesystem.d.ts +3 -2
  160. package/dist/tests/harness/vfs/filesystem.js +6 -2
  161. package/dist/tests/harness/vfs/filesystem.js.map +1 -1
  162. package/dist/tests/importResolver.test.js +4 -3
  163. package/dist/tests/importResolver.test.js.map +1 -1
  164. package/dist/tests/parseTreeUtils.test.js +5 -5
  165. package/dist/tests/parseTreeUtils.test.js.map +1 -1
  166. package/dist/tests/parser.test.js +8 -8
  167. package/dist/tests/parser.test.js.map +1 -1
  168. package/dist/tests/sourceMapperUtils.test.js +7 -7
  169. package/dist/tests/sourceMapperUtils.test.js.map +1 -1
  170. package/dist/tests/typeEvaluator1.test.js +17 -0
  171. package/dist/tests/typeEvaluator1.test.js.map +1 -1
  172. package/dist/tests/typeEvaluator2.test.js +4 -0
  173. package/dist/tests/typeEvaluator2.test.js.map +1 -1
  174. package/dist/tests/typeEvaluator3.test.js +8 -3
  175. package/dist/tests/typeEvaluator3.test.js.map +1 -1
  176. package/dist/tests/typeEvaluator4.test.js +10 -6
  177. package/dist/tests/typeEvaluator4.test.js.map +1 -1
  178. package/dist/tests/typeEvaluator6.test.js +6 -2
  179. package/dist/tests/typeEvaluator6.test.js.map +1 -1
  180. package/dist/tests/typeEvaluator7.test.js +7 -3
  181. package/dist/tests/typeEvaluator7.test.js.map +1 -1
  182. package/dist/tests/typePrinter.test.js +14 -39
  183. package/dist/tests/typePrinter.test.js.map +1 -1
  184. package/package.json +1 -1
@@ -87,6 +87,7 @@ class Parser {
87
87
  this._assignmentExpressionsAllowed = true;
88
88
  this._typingImportAliases = [];
89
89
  this._typingSymbolAliases = new Map();
90
+ this._maxChildDepthMap = new Map();
90
91
  }
91
92
  parseSourceFile(fileContents, parseOptions, diagSink) {
92
93
  timing_1.timingStats.tokenizeFileTime.timeOperation(() => {
@@ -115,7 +116,7 @@ class Parser {
115
116
  }
116
117
  else {
117
118
  statement.parent = moduleNode;
118
- moduleNode.statements.push(statement);
119
+ moduleNode.d.statements.push(statement);
119
120
  }
120
121
  }
121
122
  }
@@ -323,12 +324,12 @@ class Parser {
323
324
  }
324
325
  // type_param: ['*' | '**'] NAME [':' bound_expr] ['=' default_expr]
325
326
  _parseTypeParameter() {
326
- let typeParamCategory = parseNodes_1.TypeParameterCategory.TypeVar;
327
+ let typeParamCategory = parseNodes_1.TypeParameterKind.TypeVar;
327
328
  if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
328
- typeParamCategory = parseNodes_1.TypeParameterCategory.TypeVarTuple;
329
+ typeParamCategory = parseNodes_1.TypeParameterKind.TypeVarTuple;
329
330
  }
330
331
  else if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
331
- typeParamCategory = parseNodes_1.TypeParameterCategory.ParamSpec;
332
+ typeParamCategory = parseNodes_1.TypeParameterKind.ParamSpec;
332
333
  }
333
334
  const nameToken = this._getTokenIfIdentifier();
334
335
  if (!nameToken) {
@@ -339,14 +340,14 @@ class Parser {
339
340
  let boundExpression;
340
341
  if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
341
342
  boundExpression = this._parseExpression(/* allowUnpack */ false);
342
- if (typeParamCategory !== parseNodes_1.TypeParameterCategory.TypeVar) {
343
+ if (typeParamCategory !== parseNodes_1.TypeParameterKind.TypeVar) {
343
344
  this._addSyntaxError(localize_1.LocMessage.typeParameterBoundNotAllowed(), boundExpression);
344
345
  }
345
346
  }
346
347
  let defaultExpression;
347
348
  if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
348
349
  defaultExpression = this._parseExpression(
349
- /* allowUnpack */ typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple);
350
+ /* allowUnpack */ typeParamCategory === parseNodes_1.TypeParameterKind.TypeVarTuple);
350
351
  if (!this._parseOptions.isStubFile && this._getLanguageVersion().isLessThan(pythonVersion_1.pythonVersion3_13)) {
351
352
  this._addSyntaxError(localize_1.LocMessage.typeVarDefaultIllegal(), defaultExpression);
352
353
  }
@@ -430,7 +431,7 @@ class Parser {
430
431
  }
431
432
  else {
432
433
  caseStatement.parent = matchNode;
433
- matchNode.cases.push(caseStatement);
434
+ matchNode.d.cases.push(caseStatement);
434
435
  }
435
436
  const dedentToken = this._peekToken();
436
437
  if (this._consumeTokenIfType(4 /* TokenType.Dedent */)) {
@@ -447,8 +448,8 @@ class Parser {
447
448
  }
448
449
  }
449
450
  }
450
- if (matchNode.cases.length > 0) {
451
- (0, parseNodes_1.extendRange)(matchNode, matchNode.cases[matchNode.cases.length - 1]);
451
+ if (matchNode.d.cases.length > 0) {
452
+ (0, parseNodes_1.extendRange)(matchNode, matchNode.d.cases[matchNode.d.cases.length - 1]);
452
453
  }
453
454
  else {
454
455
  this._addSyntaxError(localize_1.LocMessage.zeroCaseStatementsFound(), matchToken);
@@ -459,10 +460,10 @@ class Parser {
459
460
  this._addSyntaxError(localize_1.LocMessage.matchIncompatible(), matchToken);
460
461
  }
461
462
  // Validate that only the last entry uses an irrefutable pattern.
462
- for (let i = 0; i < matchNode.cases.length - 1; i++) {
463
- const caseNode = matchNode.cases[i];
464
- if (!caseNode.guardExpression && caseNode.isIrrefutable) {
465
- this._addSyntaxError(localize_1.LocMessage.casePatternIsIrrefutable(), caseNode.pattern);
463
+ for (let i = 0; i < matchNode.d.cases.length - 1; i++) {
464
+ const caseNode = matchNode.d.cases[i];
465
+ if (!caseNode.d.guardExpr && caseNode.d.isIrrefutable) {
466
+ this._addSyntaxError(localize_1.LocMessage.casePatternIsIrrefutable(), caseNode.d.pattern);
466
467
  }
467
468
  }
468
469
  return matchNode;
@@ -486,8 +487,8 @@ class Parser {
486
487
  casePattern = parseNodes_1.ErrorNode.create(caseToken, 11 /* ErrorExpressionCategory.MissingPattern */);
487
488
  }
488
489
  else if (patternList.list.length === 1 && !patternList.trailingComma) {
489
- const pattern = patternList.list[0].orPatterns[0];
490
- if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.isStar) {
490
+ const pattern = patternList.list[0].d.orPatterns[0];
491
+ if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.d.isStar) {
491
492
  casePattern = parseNodes_1.PatternSequenceNode.create(patternList.list[0], patternList.list);
492
493
  }
493
494
  else {
@@ -516,7 +517,7 @@ class Parser {
516
517
  return true;
517
518
  }
518
519
  if (node.nodeType === 66 /* ParseNodeType.PatternAs */) {
519
- return node.orPatterns.some((pattern) => this._isPatternIrrefutable(pattern));
520
+ return node.d.orPatterns.some((pattern) => this._isPatternIrrefutable(pattern));
520
521
  }
521
522
  return false;
522
523
  }
@@ -526,33 +527,33 @@ class Parser {
526
527
  // as well as the targets we've seen locally within the current "or" clause.
527
528
  _reportDuplicatePatternCaptureTargets(node, globalNameMap, localNameMap) {
528
529
  const reportTargetIfDuplicate = (nameNode) => {
529
- if (globalNameMap.has(nameNode.value) || localNameMap.has(nameNode.value)) {
530
+ if (globalNameMap.has(nameNode.d.value) || localNameMap.has(nameNode.d.value)) {
530
531
  this._addSyntaxError(localize_1.LocMessage.duplicateCapturePatternTarget().format({
531
- name: nameNode.value,
532
+ name: nameNode.d.value,
532
533
  }), nameNode);
533
534
  }
534
535
  else {
535
- localNameMap.set(nameNode.value, nameNode);
536
+ localNameMap.set(nameNode.d.value, nameNode);
536
537
  }
537
538
  };
538
539
  switch (node.nodeType) {
539
540
  case 65 /* ParseNodeType.PatternSequence */: {
540
- node.entries.forEach((subpattern) => {
541
+ node.d.entries.forEach((subpattern) => {
541
542
  this._reportDuplicatePatternCaptureTargets(subpattern, globalNameMap, localNameMap);
542
543
  });
543
544
  break;
544
545
  }
545
546
  case 68 /* ParseNodeType.PatternClass */: {
546
- node.arguments.forEach((arg) => {
547
- this._reportDuplicatePatternCaptureTargets(arg.pattern, globalNameMap, localNameMap);
547
+ node.d.args.forEach((arg) => {
548
+ this._reportDuplicatePatternCaptureTargets(arg.d.pattern, globalNameMap, localNameMap);
548
549
  });
549
550
  break;
550
551
  }
551
552
  case 66 /* ParseNodeType.PatternAs */: {
552
- if (node.target) {
553
- reportTargetIfDuplicate(node.target);
553
+ if (node.d.target) {
554
+ reportTargetIfDuplicate(node.d.target);
554
555
  }
555
- const orLocalNameMaps = node.orPatterns.map((subpattern) => {
556
+ const orLocalNameMaps = node.d.orPatterns.map((subpattern) => {
556
557
  const orLocalNameMap = new Map();
557
558
  this._reportDuplicatePatternCaptureTargets(subpattern, localNameMap, orLocalNameMap);
558
559
  return orLocalNameMap;
@@ -560,8 +561,8 @@ class Parser {
560
561
  const combinedLocalOrNameMap = new Map();
561
562
  orLocalNameMaps.forEach((orLocalNameMap) => {
562
563
  orLocalNameMap.forEach((node) => {
563
- if (!combinedLocalOrNameMap.has(node.value)) {
564
- combinedLocalOrNameMap.set(node.value, node);
564
+ if (!combinedLocalOrNameMap.has(node.d.value)) {
565
+ combinedLocalOrNameMap.set(node.d.value, node);
565
566
  reportTargetIfDuplicate(node);
566
567
  }
567
568
  });
@@ -569,19 +570,19 @@ class Parser {
569
570
  break;
570
571
  }
571
572
  case 69 /* ParseNodeType.PatternCapture */: {
572
- if (!node.isWildcard) {
573
- reportTargetIfDuplicate(node.target);
573
+ if (!node.d.isWildcard) {
574
+ reportTargetIfDuplicate(node.d.target);
574
575
  }
575
576
  break;
576
577
  }
577
578
  case 70 /* ParseNodeType.PatternMapping */: {
578
- node.entries.forEach((mapEntry) => {
579
+ node.d.entries.forEach((mapEntry) => {
579
580
  if (mapEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
580
- reportTargetIfDuplicate(mapEntry.target);
581
+ reportTargetIfDuplicate(mapEntry.d.target);
581
582
  }
582
583
  else {
583
- this._reportDuplicatePatternCaptureTargets(mapEntry.keyPattern, globalNameMap, localNameMap);
584
- this._reportDuplicatePatternCaptureTargets(mapEntry.valuePattern, globalNameMap, localNameMap);
584
+ this._reportDuplicatePatternCaptureTargets(mapEntry.d.keyPattern, globalNameMap, localNameMap);
585
+ this._reportDuplicatePatternCaptureTargets(mapEntry.d.valuePattern, globalNameMap, localNameMap);
585
586
  }
586
587
  });
587
588
  break;
@@ -596,40 +597,40 @@ class Parser {
596
597
  _getPatternTargetNames(node, nameSet) {
597
598
  switch (node.nodeType) {
598
599
  case 65 /* ParseNodeType.PatternSequence */: {
599
- node.entries.forEach((subpattern) => {
600
+ node.d.entries.forEach((subpattern) => {
600
601
  this._getPatternTargetNames(subpattern, nameSet);
601
602
  });
602
603
  break;
603
604
  }
604
605
  case 68 /* ParseNodeType.PatternClass */: {
605
- node.arguments.forEach((arg) => {
606
- this._getPatternTargetNames(arg.pattern, nameSet);
606
+ node.d.args.forEach((arg) => {
607
+ this._getPatternTargetNames(arg.d.pattern, nameSet);
607
608
  });
608
609
  break;
609
610
  }
610
611
  case 66 /* ParseNodeType.PatternAs */: {
611
- if (node.target) {
612
- nameSet.add(node.target.value);
612
+ if (node.d.target) {
613
+ nameSet.add(node.d.target.d.value);
613
614
  }
614
- node.orPatterns.forEach((subpattern) => {
615
+ node.d.orPatterns.forEach((subpattern) => {
615
616
  this._getPatternTargetNames(subpattern, nameSet);
616
617
  });
617
618
  break;
618
619
  }
619
620
  case 69 /* ParseNodeType.PatternCapture */: {
620
- if (!node.isWildcard) {
621
- nameSet.add(node.target.value);
621
+ if (!node.d.isWildcard) {
622
+ nameSet.add(node.d.target.d.value);
622
623
  }
623
624
  break;
624
625
  }
625
626
  case 70 /* ParseNodeType.PatternMapping */: {
626
- node.entries.forEach((mapEntry) => {
627
+ node.d.entries.forEach((mapEntry) => {
627
628
  if (mapEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
628
- nameSet.add(mapEntry.target.value);
629
+ nameSet.add(mapEntry.d.target.d.value);
629
630
  }
630
631
  else {
631
- this._getPatternTargetNames(mapEntry.keyPattern, nameSet);
632
- this._getPatternTargetNames(mapEntry.valuePattern, nameSet);
632
+ this._getPatternTargetNames(mapEntry.d.keyPattern, nameSet);
633
+ this._getPatternTargetNames(mapEntry.d.valuePattern, nameSet);
633
634
  }
634
635
  });
635
636
  break;
@@ -644,11 +645,11 @@ class Parser {
644
645
  _parsePatternSequence() {
645
646
  const patternList = this._parseExpressionListGeneric(() => this._parsePatternAs());
646
647
  // Check for more than one star entry.
647
- const starEntries = patternList.list.filter((entry) => entry.orPatterns.length === 1 &&
648
- entry.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
649
- entry.orPatterns[0].isStar);
648
+ const starEntries = patternList.list.filter((entry) => entry.d.orPatterns.length === 1 &&
649
+ entry.d.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
650
+ entry.d.orPatterns[0].d.isStar);
650
651
  if (starEntries.length > 1) {
651
- this._addSyntaxError(localize_1.LocMessage.duplicateStarPattern(), starEntries[1].orPatterns[0]);
652
+ this._addSyntaxError(localize_1.LocMessage.duplicateStarPattern(), starEntries[1].d.orPatterns[0]);
652
653
  }
653
654
  return patternList;
654
655
  }
@@ -666,7 +667,7 @@ class Parser {
666
667
  if (orPatterns.length > 1) {
667
668
  // Star patterns cannot be ORed with other patterns.
668
669
  orPatterns.forEach((patternAtom) => {
669
- if (patternAtom.nodeType === 69 /* ParseNodeType.PatternCapture */ && patternAtom.isStar) {
670
+ if (patternAtom.nodeType === 69 /* ParseNodeType.PatternCapture */ && patternAtom.d.isStar) {
670
671
  this._addSyntaxError(localize_1.LocMessage.starPatternInOrPattern(), patternAtom);
671
672
  }
672
673
  });
@@ -685,7 +686,7 @@ class Parser {
685
686
  if (target &&
686
687
  orPatterns.length === 1 &&
687
688
  orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
688
- orPatterns[0].isStar) {
689
+ orPatterns[0].d.isStar) {
689
690
  this._addSyntaxError(localize_1.LocMessage.starPatternInAsPattern(), orPatterns[0]);
690
691
  }
691
692
  // Validate that irrefutable patterns are not in any entries other than the last.
@@ -740,8 +741,8 @@ class Parser {
740
741
  }
741
742
  const args = this._parseClassPatternArgList();
742
743
  const classNameExpr = patternCaptureOrValue.nodeType === 69 /* ParseNodeType.PatternCapture */
743
- ? patternCaptureOrValue.target
744
- : patternCaptureOrValue.expression;
744
+ ? patternCaptureOrValue.d.target
745
+ : patternCaptureOrValue.d.expr;
745
746
  const classPattern = parseNodes_1.PatternClassNode.create(classNameExpr, args);
746
747
  if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
747
748
  this._addSyntaxError(localize_1.LocMessage.expectedCloseParen(), openParenToken);
@@ -777,8 +778,8 @@ class Parser {
777
778
  else if (patternList.list.length === 1 &&
778
779
  !patternList.trailingComma &&
779
780
  startToken.type === 13 /* TokenType.OpenParenthesis */) {
780
- const pattern = patternList.list[0].orPatterns[0];
781
- if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.isStar) {
781
+ const pattern = patternList.list[0].d.orPatterns[0];
782
+ if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.d.isStar) {
782
783
  casePattern = parseNodes_1.PatternSequenceNode.create(startToken, patternList.list);
783
784
  }
784
785
  else {
@@ -835,10 +836,10 @@ class Parser {
835
836
  break;
836
837
  }
837
838
  const arg = this._parseClassPatternArgument();
838
- if (arg.name) {
839
+ if (arg.d.name) {
839
840
  sawKeywordArg = true;
840
841
  }
841
- else if (sawKeywordArg && !arg.name) {
842
+ else if (sawKeywordArg && !arg.d.name) {
842
843
  this._addSyntaxError(localize_1.LocMessage.positionArgAfterNamedArg(), arg);
843
844
  }
844
845
  argList.push(arg);
@@ -883,7 +884,7 @@ class Parser {
883
884
  const stringList = this._parseAtom();
884
885
  (0, debug_1.assert)(stringList.nodeType === 48 /* ParseNodeType.StringList */);
885
886
  // Check for f-strings, which are not allowed.
886
- stringList.strings.forEach((stringAtom) => {
887
+ stringList.d.strings.forEach((stringAtom) => {
887
888
  if (stringAtom.nodeType === 30 /* ParseNodeType.FormatString */) {
888
889
  this._addSyntaxError(localize_1.LocMessage.formatStringInPattern(), stringAtom);
889
890
  }
@@ -906,28 +907,28 @@ class Parser {
906
907
  let realValue;
907
908
  let imagValue;
908
909
  if (expression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
909
- if (expression.operator === 33 /* OperatorType.Subtract */ || expression.operator === 0 /* OperatorType.Add */) {
910
- realValue = expression.leftExpression;
911
- imagValue = expression.rightExpression;
910
+ if (expression.d.operator === 33 /* OperatorType.Subtract */ || expression.d.operator === 0 /* OperatorType.Add */) {
911
+ realValue = expression.d.leftExpr;
912
+ imagValue = expression.d.rightExpr;
912
913
  }
913
914
  }
914
915
  else {
915
916
  realValue = expression;
916
917
  }
917
918
  if (realValue) {
918
- if (realValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && realValue.operator === 33 /* OperatorType.Subtract */) {
919
- realValue = realValue.expression;
919
+ if (realValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && realValue.d.operator === 33 /* OperatorType.Subtract */) {
920
+ realValue = realValue.d.expr;
920
921
  }
921
- if (realValue.nodeType !== 40 /* ParseNodeType.Number */ || (imagValue !== undefined && realValue.isImaginary)) {
922
+ if (realValue.nodeType !== 40 /* ParseNodeType.Number */ || (imagValue !== undefined && realValue.d.isImaginary)) {
922
923
  this._addSyntaxError(localize_1.LocMessage.expectedComplexNumberLiteral(), expression);
923
924
  imagValue = undefined;
924
925
  }
925
926
  }
926
927
  if (imagValue) {
927
- if (imagValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && imagValue.operator === 33 /* OperatorType.Subtract */) {
928
- imagValue = imagValue.expression;
928
+ if (imagValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && imagValue.d.operator === 33 /* OperatorType.Subtract */) {
929
+ imagValue = imagValue.d.expr;
929
930
  }
930
- if (imagValue.nodeType !== 40 /* ParseNodeType.Number */ || !imagValue.isImaginary) {
931
+ if (imagValue.nodeType !== 40 /* ParseNodeType.Number */ || !imagValue.d.isImaginary) {
931
932
  this._addSyntaxError(localize_1.LocMessage.expectedComplexNumberLiteral(), expression);
932
933
  }
933
934
  }
@@ -1031,15 +1032,15 @@ class Parser {
1031
1032
  const suite = this._parseSuite(this._isInFunction);
1032
1033
  const ifNode = parseNodes_1.IfNode.create(ifOrElifToken, test, suite);
1033
1034
  if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
1034
- ifNode.elseSuite = this._parseSuite(this._isInFunction);
1035
- ifNode.elseSuite.parent = ifNode;
1036
- (0, parseNodes_1.extendRange)(ifNode, ifNode.elseSuite);
1035
+ ifNode.d.elseSuite = this._parseSuite(this._isInFunction);
1036
+ ifNode.d.elseSuite.parent = ifNode;
1037
+ (0, parseNodes_1.extendRange)(ifNode, ifNode.d.elseSuite);
1037
1038
  }
1038
1039
  else if (this._peekKeywordType() === 12 /* KeywordType.Elif */) {
1039
1040
  // Recursively handle an "elif" statement.
1040
- ifNode.elseSuite = this._parseIfStatement(12 /* KeywordType.Elif */);
1041
- ifNode.elseSuite.parent = ifNode;
1042
- (0, parseNodes_1.extendRange)(ifNode, ifNode.elseSuite);
1041
+ ifNode.d.elseSuite = this._parseIfStatement(12 /* KeywordType.Elif */);
1042
+ ifNode.d.elseSuite.parent = ifNode;
1043
+ (0, parseNodes_1.extendRange)(ifNode, ifNode.d.elseSuite);
1043
1044
  }
1044
1045
  return ifNode;
1045
1046
  }
@@ -1058,7 +1059,7 @@ class Parser {
1058
1059
  this._isInLoop = wasInLoop;
1059
1060
  this._isInFinally = wasInFinally;
1060
1061
  if (typeComment) {
1061
- suite.typeComment = typeComment;
1062
+ suite.d.typeComment = typeComment;
1062
1063
  }
1063
1064
  return suite;
1064
1065
  }
@@ -1156,7 +1157,7 @@ class Parser {
1156
1157
  // recovery. This allows a single dedent token to cause us to break out of
1157
1158
  // multiple levels of nested suites. Also extend the suite's range in this
1158
1159
  // case so it is multi-line as this works better with indentationUtils.
1159
- if (suite.statements.length > 0) {
1160
+ if (suite.d.statements.length > 0) {
1160
1161
  this._consumeTokenIfType(4 /* TokenType.Dedent */);
1161
1162
  }
1162
1163
  else {
@@ -1185,7 +1186,7 @@ class Parser {
1185
1186
  }
1186
1187
  else {
1187
1188
  statement.parent = suite;
1188
- suite.statements.push(statement);
1189
+ suite.d.statements.push(statement);
1189
1190
  }
1190
1191
  if (this._peekTokenType() === 1 /* TokenType.EndOfStream */) {
1191
1192
  break;
@@ -1194,11 +1195,11 @@ class Parser {
1194
1195
  }
1195
1196
  else {
1196
1197
  const simpleStatement = this._parseSimpleStatement();
1197
- suite.statements.push(simpleStatement);
1198
+ suite.d.statements.push(simpleStatement);
1198
1199
  simpleStatement.parent = suite;
1199
1200
  }
1200
- if (suite.statements.length > 0) {
1201
- (0, parseNodes_1.extendRange)(suite, suite.statements[suite.statements.length - 1]);
1201
+ if (suite.d.statements.length > 0) {
1202
+ (0, parseNodes_1.extendRange)(suite, suite.d.statements[suite.d.statements.length - 1]);
1202
1203
  }
1203
1204
  this._isInFunction = wasFunction;
1204
1205
  return suite;
@@ -1222,9 +1223,9 @@ class Parser {
1222
1223
  // Versions of Python earlier than 3.9 didn't allow unpack operators if the
1223
1224
  // tuple wasn't enclosed in parentheses.
1224
1225
  if (this._getLanguageVersion().isLessThan(pythonVersion_1.pythonVersion3_9) && !this._parseOptions.isStubFile) {
1225
- if (seqExpr.nodeType === 52 /* ParseNodeType.Tuple */ && !seqExpr.enclosedInParens) {
1226
+ if (seqExpr.nodeType === 52 /* ParseNodeType.Tuple */ && !seqExpr.d.hasParens) {
1226
1227
  let sawStar = false;
1227
- seqExpr.expressions.forEach((expr) => {
1228
+ seqExpr.d.items.forEach((expr) => {
1228
1229
  if (expr.nodeType === 56 /* ParseNodeType.Unpack */ && !sawStar) {
1229
1230
  this._addSyntaxError(localize_1.LocMessage.unpackOperatorNotAllowed(), expr);
1230
1231
  sawStar = true;
@@ -1237,18 +1238,18 @@ class Parser {
1237
1238
  }
1238
1239
  }
1239
1240
  const forNode = parseNodes_1.ForNode.create(forToken, targetExpr, seqExpr, forSuite);
1240
- forNode.elseSuite = elseSuite;
1241
+ forNode.d.elseSuite = elseSuite;
1241
1242
  if (elseSuite) {
1242
1243
  (0, parseNodes_1.extendRange)(forNode, elseSuite);
1243
1244
  elseSuite.parent = forNode;
1244
1245
  }
1245
1246
  if (asyncToken) {
1246
- forNode.isAsync = true;
1247
- forNode.asyncToken = asyncToken;
1247
+ forNode.d.isAsync = true;
1248
+ forNode.d.asyncToken = asyncToken;
1248
1249
  (0, parseNodes_1.extendRange)(forNode, asyncToken);
1249
1250
  }
1250
- if (forSuite.typeComment) {
1251
- forNode.typeComment = forSuite.typeComment;
1251
+ if (forSuite.d.typeComment) {
1252
+ forNode.d.typeComment = forSuite.d.typeComment;
1252
1253
  }
1253
1254
  return forNode;
1254
1255
  }
@@ -1274,7 +1275,7 @@ class Parser {
1274
1275
  compIter.parent = compNode;
1275
1276
  forIfList.push(compIter);
1276
1277
  }
1277
- compNode.forIfNodes = forIfList;
1278
+ compNode.d.forIfNodes = forIfList;
1278
1279
  if (forIfList.length > 0) {
1279
1280
  forIfList.forEach((comp) => {
1280
1281
  comp.parent = compNode;
@@ -1312,8 +1313,8 @@ class Parser {
1312
1313
  }
1313
1314
  const compForNode = parseNodes_1.ComprehensionForNode.create(asyncToken || forToken, targetExpr, seqExpr);
1314
1315
  if (asyncToken) {
1315
- compForNode.isAsync = true;
1316
- compForNode.asyncToken = asyncToken;
1316
+ compForNode.d.isAsync = true;
1317
+ compForNode.d.asyncToken = asyncToken;
1317
1318
  }
1318
1319
  return compForNode;
1319
1320
  }
@@ -1334,9 +1335,9 @@ class Parser {
1334
1335
  const whileToken = this._getKeywordToken(36 /* KeywordType.While */);
1335
1336
  const whileNode = parseNodes_1.WhileNode.create(whileToken, this._parseTestExpression(/* allowAssignmentExpression */ true), this._parseLoopSuite());
1336
1337
  if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
1337
- whileNode.elseSuite = this._parseSuite(this._isInFunction);
1338
- whileNode.elseSuite.parent = whileNode;
1339
- (0, parseNodes_1.extendRange)(whileNode, whileNode.elseSuite);
1338
+ whileNode.d.elseSuite = this._parseSuite(this._isInFunction);
1339
+ whileNode.d.elseSuite.parent = whileNode;
1340
+ (0, parseNodes_1.extendRange)(whileNode, whileNode.d.elseSuite);
1340
1341
  }
1341
1342
  return whileNode;
1342
1343
  }
@@ -1399,30 +1400,30 @@ class Parser {
1399
1400
  const exceptSuite = this._parseSuite(this._isInFunction);
1400
1401
  const exceptNode = parseNodes_1.ExceptNode.create(exceptToken, exceptSuite, isExceptGroup);
1401
1402
  if (typeExpr) {
1402
- exceptNode.typeExpression = typeExpr;
1403
- exceptNode.typeExpression.parent = exceptNode;
1403
+ exceptNode.d.typeExpr = typeExpr;
1404
+ exceptNode.d.typeExpr.parent = exceptNode;
1404
1405
  }
1405
1406
  if (symbolName) {
1406
- exceptNode.name = parseNodes_1.NameNode.create(symbolName);
1407
- exceptNode.name.parent = exceptNode;
1407
+ exceptNode.d.name = parseNodes_1.NameNode.create(symbolName);
1408
+ exceptNode.d.name.parent = exceptNode;
1408
1409
  }
1409
- tryNode.exceptClauses.push(exceptNode);
1410
+ tryNode.d.exceptClauses.push(exceptNode);
1410
1411
  exceptNode.parent = tryNode;
1411
1412
  }
1412
- if (tryNode.exceptClauses.length > 0) {
1413
- (0, parseNodes_1.extendRange)(tryNode, tryNode.exceptClauses[tryNode.exceptClauses.length - 1]);
1413
+ if (tryNode.d.exceptClauses.length > 0) {
1414
+ (0, parseNodes_1.extendRange)(tryNode, tryNode.d.exceptClauses[tryNode.d.exceptClauses.length - 1]);
1414
1415
  if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
1415
- tryNode.elseSuite = this._parseSuite(this._isInFunction);
1416
- tryNode.elseSuite.parent = tryNode;
1417
- (0, parseNodes_1.extendRange)(tryNode, tryNode.elseSuite);
1416
+ tryNode.d.elseSuite = this._parseSuite(this._isInFunction);
1417
+ tryNode.d.elseSuite.parent = tryNode;
1418
+ (0, parseNodes_1.extendRange)(tryNode, tryNode.d.elseSuite);
1418
1419
  }
1419
1420
  }
1420
1421
  if (this._consumeTokenIfKeyword(16 /* KeywordType.Finally */)) {
1421
- tryNode.finallySuite = this._parseSuite(this._isInFunction);
1422
- tryNode.finallySuite.parent = tryNode;
1423
- (0, parseNodes_1.extendRange)(tryNode, tryNode.finallySuite);
1422
+ tryNode.d.finallySuite = this._parseSuite(this._isInFunction);
1423
+ tryNode.d.finallySuite.parent = tryNode;
1424
+ (0, parseNodes_1.extendRange)(tryNode, tryNode.d.finallySuite);
1424
1425
  }
1425
- if (!tryNode.finallySuite && tryNode.exceptClauses.length === 0) {
1426
+ if (!tryNode.d.finallySuite && tryNode.d.exceptClauses.length === 0) {
1426
1427
  this._addSyntaxError(localize_1.LocMessage.tryWithoutExcept(), tryToken);
1427
1428
  }
1428
1429
  return tryNode;
@@ -1466,15 +1467,15 @@ class Parser {
1466
1467
  });
1467
1468
  const functionNode = parseNodes_1.FunctionNode.create(defToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
1468
1469
  if (asyncToken) {
1469
- functionNode.isAsync = true;
1470
+ functionNode.d.isAsync = true;
1470
1471
  (0, parseNodes_1.extendRange)(functionNode, asyncToken);
1471
1472
  }
1472
- functionNode.parameters = paramList;
1473
+ functionNode.d.params = paramList;
1473
1474
  paramList.forEach((param) => {
1474
1475
  param.parent = functionNode;
1475
1476
  });
1476
1477
  if (decorators) {
1477
- functionNode.decorators = decorators;
1478
+ functionNode.d.decorators = decorators;
1478
1479
  decorators.forEach((decorator) => {
1479
1480
  decorator.parent = functionNode;
1480
1481
  });
@@ -1483,8 +1484,8 @@ class Parser {
1483
1484
  }
1484
1485
  }
1485
1486
  if (returnType) {
1486
- functionNode.returnTypeAnnotation = returnType;
1487
- functionNode.returnTypeAnnotation.parent = functionNode;
1487
+ functionNode.d.returnAnnotation = returnType;
1488
+ functionNode.d.returnAnnotation.parent = functionNode;
1488
1489
  (0, parseNodes_1.extendRange)(functionNode, returnType);
1489
1490
  }
1490
1491
  // If there was a type annotation comment for the function,
@@ -1525,22 +1526,22 @@ class Parser {
1525
1526
  this._consumeTokensUntilType([terminator]);
1526
1527
  break;
1527
1528
  }
1528
- if (param.name) {
1529
- const name = param.name.value;
1529
+ if (param.d.name) {
1530
+ const name = param.d.name.d.value;
1530
1531
  if (paramMap.has(name)) {
1531
- this._addSyntaxError(localize_1.LocMessage.duplicateParam().format({ name }), param.name);
1532
+ this._addSyntaxError(localize_1.LocMessage.duplicateParam().format({ name }), param.d.name);
1532
1533
  }
1533
1534
  else {
1534
1535
  paramMap.set(name, name);
1535
1536
  }
1536
1537
  }
1537
- else if (param.category === 0 /* ParameterCategory.Simple */) {
1538
+ else if (param.d.category === 0 /* ParameterCategory.Simple */) {
1538
1539
  if (paramList.length === 0) {
1539
1540
  this._addSyntaxError(localize_1.LocMessage.positionOnlyFirstParam(), param);
1540
1541
  }
1541
1542
  }
1542
- if (param.category === 0 /* ParameterCategory.Simple */) {
1543
- if (!param.name) {
1543
+ if (param.d.category === 0 /* ParameterCategory.Simple */) {
1544
+ if (!param.d.name) {
1544
1545
  if (sawPositionOnlySeparator) {
1545
1546
  this._addSyntaxError(localize_1.LocMessage.duplicatePositionOnly(), param);
1546
1547
  }
@@ -1556,7 +1557,7 @@ class Parser {
1556
1557
  if (sawKeywordOnlySeparator) {
1557
1558
  sawKeywordOnlyParamAfterSeparator = true;
1558
1559
  }
1559
- if (param.defaultValue) {
1560
+ if (param.d.defaultValue) {
1560
1561
  sawDefaultParam = true;
1561
1562
  }
1562
1563
  else if (sawDefaultParam && !sawKeywordOnlySeparator && !sawArgs) {
@@ -1569,8 +1570,8 @@ class Parser {
1569
1570
  }
1570
1571
  }
1571
1572
  paramList.push(param);
1572
- if (param.category === 1 /* ParameterCategory.ArgsList */) {
1573
- if (!param.name) {
1573
+ if (param.d.category === 1 /* ParameterCategory.ArgsList */) {
1574
+ if (!param.d.name) {
1574
1575
  if (sawKeywordOnlySeparator) {
1575
1576
  this._addSyntaxError(localize_1.LocMessage.duplicateKeywordOnly(), param);
1576
1577
  }
@@ -1586,7 +1587,7 @@ class Parser {
1586
1587
  sawArgs = true;
1587
1588
  }
1588
1589
  }
1589
- if (param.category === 2 /* ParameterCategory.KwargsDict */) {
1590
+ if (param.d.category === 2 /* ParameterCategory.KwargsDict */) {
1590
1591
  if (sawKwArgs) {
1591
1592
  this._addSyntaxError(localize_1.LocMessage.duplicateKwargsParam(), param);
1592
1593
  }
@@ -1600,13 +1601,13 @@ class Parser {
1600
1601
  this._addSyntaxError(localize_1.LocMessage.paramAfterKwargsParam(), param);
1601
1602
  }
1602
1603
  const foundComma = this._consumeTokenIfType(12 /* TokenType.Comma */);
1603
- if (allowAnnotations && !param.typeAnnotation) {
1604
+ if (allowAnnotations && !param.d.annotation) {
1604
1605
  // Look for a type annotation comment at the end of the line.
1605
1606
  const typeAnnotationComment = this._parseVariableTypeAnnotationComment();
1606
1607
  if (typeAnnotationComment) {
1607
- param.typeAnnotationComment = typeAnnotationComment;
1608
- param.typeAnnotationComment.parent = param;
1609
- (0, parseNodes_1.extendRange)(param, param.typeAnnotationComment);
1608
+ param.d.annotationComment = typeAnnotationComment;
1609
+ param.d.annotationComment.parent = param;
1610
+ (0, parseNodes_1.extendRange)(param, param.d.annotationComment);
1610
1611
  }
1611
1612
  }
1612
1613
  if (!foundComma) {
@@ -1615,7 +1616,7 @@ class Parser {
1615
1616
  }
1616
1617
  if (paramList.length > 0) {
1617
1618
  const lastParam = paramList[paramList.length - 1];
1618
- if (lastParam.category === 1 /* ParameterCategory.ArgsList */ && !lastParam.name) {
1619
+ if (lastParam.d.category === 1 /* ParameterCategory.ArgsList */ && !lastParam.d.name) {
1619
1620
  this._addSyntaxError(localize_1.LocMessage.expectedNamedParameter(), lastParam);
1620
1621
  }
1621
1622
  }
@@ -1668,21 +1669,21 @@ class Parser {
1668
1669
  }
1669
1670
  const paramNode = parseNodes_1.ParameterNode.create(firstToken, paramType);
1670
1671
  if (paramName) {
1671
- paramNode.name = parseNodes_1.NameNode.create(paramName);
1672
- paramNode.name.parent = paramNode;
1672
+ paramNode.d.name = parseNodes_1.NameNode.create(paramName);
1673
+ paramNode.d.name.parent = paramNode;
1673
1674
  (0, parseNodes_1.extendRange)(paramNode, paramName);
1674
1675
  }
1675
1676
  if (allowAnnotations && this._consumeTokenIfType(10 /* TokenType.Colon */)) {
1676
- paramNode.typeAnnotation = this._parseTypeAnnotation(paramType === 1 /* ParameterCategory.ArgsList */);
1677
- paramNode.typeAnnotation.parent = paramNode;
1678
- (0, parseNodes_1.extendRange)(paramNode, paramNode.typeAnnotation);
1677
+ paramNode.d.annotation = this._parseTypeAnnotation(paramType === 1 /* ParameterCategory.ArgsList */);
1678
+ paramNode.d.annotation.parent = paramNode;
1679
+ (0, parseNodes_1.extendRange)(paramNode, paramNode.d.annotation);
1679
1680
  }
1680
1681
  if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
1681
- paramNode.defaultValue = this._parseTestExpression(/* allowAssignmentExpression */ false);
1682
- paramNode.defaultValue.parent = paramNode;
1683
- (0, parseNodes_1.extendRange)(paramNode, paramNode.defaultValue);
1682
+ paramNode.d.defaultValue = this._parseTestExpression(/* allowAssignmentExpression */ false);
1683
+ paramNode.d.defaultValue.parent = paramNode;
1684
+ (0, parseNodes_1.extendRange)(paramNode, paramNode.d.defaultValue);
1684
1685
  if (starCount > 0) {
1685
- this._addSyntaxError(localize_1.LocMessage.defaultValueNotAllowed(), paramNode.defaultValue);
1686
+ this._addSyntaxError(localize_1.LocMessage.defaultValueNotAllowed(), paramNode.d.defaultValue);
1686
1687
  }
1687
1688
  }
1688
1689
  return paramNode;
@@ -1714,7 +1715,7 @@ class Parser {
1714
1715
  }
1715
1716
  if (this._peekToken().type === 14 /* TokenType.CloseParenthesis */ &&
1716
1717
  this._peekToken(1).type === 10 /* TokenType.Colon */) {
1717
- isParenthesizedWithItemList = withItemList.length !== 1 || withItemList[0].target !== undefined;
1718
+ isParenthesizedWithItemList = withItemList.length !== 1 || withItemList[0].d.target !== undefined;
1718
1719
  }
1719
1720
  this._tokenIndex = openParenTokenIndex;
1720
1721
  withItemList = [];
@@ -1749,14 +1750,14 @@ class Parser {
1749
1750
  });
1750
1751
  const withNode = parseNodes_1.WithNode.create(withToken, withSuite);
1751
1752
  if (asyncToken) {
1752
- withNode.isAsync = true;
1753
- withNode.asyncToken = asyncToken;
1753
+ withNode.d.isAsync = true;
1754
+ withNode.d.asyncToken = asyncToken;
1754
1755
  (0, parseNodes_1.extendRange)(withNode, asyncToken);
1755
1756
  }
1756
1757
  if (typeComment) {
1757
- withNode.typeComment = typeComment;
1758
+ withNode.d.typeComment = typeComment;
1758
1759
  }
1759
- withNode.withItems = withItemList;
1760
+ withNode.d.withItems = withItemList;
1760
1761
  withItemList.forEach((withItem) => {
1761
1762
  withItem.parent = withNode;
1762
1763
  });
@@ -1767,9 +1768,9 @@ class Parser {
1767
1768
  const expr = this._parseTestExpression(/* allowAssignmentExpression */ true);
1768
1769
  const itemNode = parseNodes_1.WithItemNode.create(expr);
1769
1770
  if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
1770
- itemNode.target = this._parseExpression(/* allowUnpack */ false);
1771
- itemNode.target.parent = itemNode;
1772
- (0, parseNodes_1.extendRange)(itemNode, itemNode.target);
1771
+ itemNode.d.target = this._parseExpression(/* allowUnpack */ false);
1772
+ itemNode.d.target.parent = itemNode;
1773
+ (0, parseNodes_1.extendRange)(itemNode, itemNode.d.target);
1773
1774
  }
1774
1775
  return itemNode;
1775
1776
  }
@@ -1821,7 +1822,7 @@ class Parser {
1821
1822
  isSupportedExpressionForm = true;
1822
1823
  }
1823
1824
  else if (expression.nodeType === 9 /* ParseNodeType.Call */ &&
1824
- this._isNameOrMemberAccessExpression(expression.leftExpression)) {
1825
+ this._isNameOrMemberAccessExpression(expression.d.leftExpr)) {
1825
1826
  isSupportedExpressionForm = true;
1826
1827
  }
1827
1828
  if (!isSupportedExpressionForm) {
@@ -1840,7 +1841,7 @@ class Parser {
1840
1841
  return true;
1841
1842
  }
1842
1843
  else if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
1843
- return this._isNameOrMemberAccessExpression(expression.leftExpression);
1844
+ return this._isNameOrMemberAccessExpression(expression.d.leftExpr);
1844
1845
  }
1845
1846
  return false;
1846
1847
  }
@@ -1870,12 +1871,12 @@ class Parser {
1870
1871
  }
1871
1872
  const suite = this._parseSuite(/* isFunction */ false, this._parseOptions.skipFunctionAndClassBody);
1872
1873
  const classNode = parseNodes_1.ClassNode.create(classToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
1873
- classNode.arguments = argList;
1874
+ classNode.d.arguments = argList;
1874
1875
  argList.forEach((arg) => {
1875
1876
  arg.parent = classNode;
1876
1877
  });
1877
1878
  if (decorators) {
1878
- classNode.decorators = decorators;
1879
+ classNode.d.decorators = decorators;
1879
1880
  if (decorators.length > 0) {
1880
1881
  decorators.forEach((decorator) => {
1881
1882
  decorator.parent = classNode;
@@ -1917,8 +1918,8 @@ class Parser {
1917
1918
  /* allowAssignmentExpression */ true,
1918
1919
  /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedReturnExpr());
1919
1920
  this._reportConditionalErrorForStarTupleElement(returnExpr);
1920
- returnNode.returnExpression = returnExpr;
1921
- returnNode.returnExpression.parent = returnNode;
1921
+ returnNode.d.expr = returnExpr;
1922
+ returnNode.d.expr.parent = returnNode;
1922
1923
  (0, parseNodes_1.extendRange)(returnNode, returnExpr);
1923
1924
  }
1924
1925
  return returnNode;
@@ -1933,12 +1934,14 @@ class Parser {
1933
1934
  const importFromNode = parseNodes_1.ImportFromNode.create(fromToken, modName);
1934
1935
  // Handle imports from __future__ specially because they can
1935
1936
  // change the way we interpret the rest of the file.
1936
- const isFutureImport = modName.leadingDots === 0 && modName.nameParts.length === 1 && modName.nameParts[0].value === '__future__';
1937
+ const isFutureImport = modName.d.leadingDots === 0 &&
1938
+ modName.d.nameParts.length === 1 &&
1939
+ modName.d.nameParts[0].d.value === '__future__';
1937
1940
  const possibleInputToken = this._peekToken();
1938
1941
  if (!this._consumeTokenIfKeyword(21 /* KeywordType.Import */)) {
1939
1942
  this._addSyntaxError(localize_1.LocMessage.expectedImport(), this._peekToken());
1940
- if (!modName.hasTrailingDot) {
1941
- importFromNode.missingImportKeyword = true;
1943
+ if (!modName.d.hasTrailingDot) {
1944
+ importFromNode.d.missingImport = true;
1942
1945
  }
1943
1946
  }
1944
1947
  else {
@@ -1947,8 +1950,8 @@ class Parser {
1947
1950
  const possibleStarToken = this._peekToken();
1948
1951
  if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
1949
1952
  (0, parseNodes_1.extendRange)(importFromNode, possibleStarToken);
1950
- importFromNode.isWildcardImport = true;
1951
- importFromNode.wildcardToken = possibleStarToken;
1953
+ importFromNode.d.isWildcardImport = true;
1954
+ importFromNode.d.wildcardToken = possibleStarToken;
1952
1955
  this._containsWildcardImport = true;
1953
1956
  }
1954
1957
  else {
@@ -1968,12 +1971,12 @@ class Parser {
1968
1971
  this._addSyntaxError(localize_1.LocMessage.expectedImportAlias(), this._peekToken());
1969
1972
  }
1970
1973
  else {
1971
- importFromAsNode.alias = parseNodes_1.NameNode.create(aliasName);
1972
- importFromAsNode.alias.parent = importFromAsNode;
1974
+ importFromAsNode.d.alias = parseNodes_1.NameNode.create(aliasName);
1975
+ importFromAsNode.d.alias.parent = importFromAsNode;
1973
1976
  (0, parseNodes_1.extendRange)(importFromAsNode, aliasName);
1974
1977
  }
1975
1978
  }
1976
- importFromNode.imports.push(importFromAsNode);
1979
+ importFromNode.d.imports.push(importFromAsNode);
1977
1980
  importFromAsNode.parent = importFromNode;
1978
1981
  (0, parseNodes_1.extendRange)(importFromNode, importFromAsNode);
1979
1982
  if (isFutureImport) {
@@ -1986,11 +1989,11 @@ class Parser {
1986
1989
  }
1987
1990
  trailingCommaToken = nextToken;
1988
1991
  }
1989
- if (importFromNode.imports.length === 0) {
1992
+ if (importFromNode.d.imports.length === 0) {
1990
1993
  this._addSyntaxError(localize_1.LocMessage.expectedImportSymbols(), this._peekToken());
1991
1994
  }
1992
1995
  if (inParen) {
1993
- importFromNode.usesParens = true;
1996
+ importFromNode.d.usesParens = true;
1994
1997
  const nextToken = this._peekToken();
1995
1998
  if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
1996
1999
  this._addSyntaxError(localize_1.LocMessage.expectedCloseParen(), openParenToken);
@@ -2005,30 +2008,30 @@ class Parser {
2005
2008
  }
2006
2009
  }
2007
2010
  this._importedModules.push({
2008
- nameNode: importFromNode.module,
2009
- leadingDots: importFromNode.module.leadingDots,
2010
- nameParts: importFromNode.module.nameParts.map((p) => p.value),
2011
- importedSymbols: new Set(importFromNode.imports.map((imp) => imp.name.value)),
2011
+ nameNode: importFromNode.d.module,
2012
+ leadingDots: importFromNode.d.module.d.leadingDots,
2013
+ nameParts: importFromNode.d.module.d.nameParts.map((p) => p.d.value),
2014
+ importedSymbols: new Set(importFromNode.d.imports.map((imp) => imp.d.name.d.value)),
2012
2015
  });
2013
2016
  let isTypingImport = false;
2014
- if (importFromNode.module.nameParts.length === 1) {
2015
- const firstNamePartValue = importFromNode.module.nameParts[0].value;
2017
+ if (importFromNode.d.module.d.nameParts.length === 1) {
2018
+ const firstNamePartValue = importFromNode.d.module.d.nameParts[0].d.value;
2016
2019
  if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
2017
2020
  isTypingImport = true;
2018
2021
  }
2019
2022
  }
2020
2023
  if (isTypingImport) {
2021
2024
  const typingSymbolsOfInterest = ['Literal', 'TypeAlias', 'Annotated'];
2022
- if (importFromNode.isWildcardImport) {
2025
+ if (importFromNode.d.isWildcardImport) {
2023
2026
  typingSymbolsOfInterest.forEach((s) => {
2024
2027
  this._typingSymbolAliases.set(s, s);
2025
2028
  });
2026
2029
  }
2027
2030
  else {
2028
- importFromNode.imports.forEach((imp) => {
2031
+ importFromNode.d.imports.forEach((imp) => {
2029
2032
  var _a;
2030
- if (typingSymbolsOfInterest.some((s) => s === imp.name.value)) {
2031
- this._typingSymbolAliases.set(((_a = imp.alias) === null || _a === void 0 ? void 0 : _a.value) || imp.name.value, imp.name.value);
2033
+ if (typingSymbolsOfInterest.some((s) => s === imp.d.name.d.value)) {
2034
+ this._typingSymbolAliases.set(((_a = imp.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) || imp.d.name.d.value, imp.d.name.d.value);
2032
2035
  }
2033
2036
  });
2034
2037
  }
@@ -2048,26 +2051,26 @@ class Parser {
2048
2051
  if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
2049
2052
  const aliasToken = this._getTokenIfIdentifier();
2050
2053
  if (aliasToken) {
2051
- importAsNode.alias = parseNodes_1.NameNode.create(aliasToken);
2052
- importAsNode.alias.parent = importAsNode;
2053
- (0, parseNodes_1.extendRange)(importAsNode, importAsNode.alias);
2054
+ importAsNode.d.alias = parseNodes_1.NameNode.create(aliasToken);
2055
+ importAsNode.d.alias.parent = importAsNode;
2056
+ (0, parseNodes_1.extendRange)(importAsNode, importAsNode.d.alias);
2054
2057
  }
2055
2058
  else {
2056
2059
  this._addSyntaxError(localize_1.LocMessage.expectedImportAlias(), this._peekToken());
2057
2060
  }
2058
2061
  }
2059
- if (importAsNode.module.leadingDots > 0) {
2060
- this._addSyntaxError(localize_1.LocMessage.relativeImportNotAllowed(), importAsNode.module);
2062
+ if (importAsNode.d.module.d.leadingDots > 0) {
2063
+ this._addSyntaxError(localize_1.LocMessage.relativeImportNotAllowed(), importAsNode.d.module);
2061
2064
  }
2062
- importNode.list.push(importAsNode);
2065
+ importNode.d.list.push(importAsNode);
2063
2066
  importAsNode.parent = importNode;
2064
- const nameParts = importAsNode.module.nameParts.map((p) => p.value);
2065
- if (importAsNode.alias ||
2066
- importAsNode.module.leadingDots > 0 ||
2067
- importAsNode.module.nameParts.length === 0) {
2067
+ const nameParts = importAsNode.d.module.d.nameParts.map((p) => p.d.value);
2068
+ if (importAsNode.d.alias ||
2069
+ importAsNode.d.module.d.leadingDots > 0 ||
2070
+ importAsNode.d.module.d.nameParts.length === 0) {
2068
2071
  this._importedModules.push({
2069
- nameNode: importAsNode.module,
2070
- leadingDots: importAsNode.module.leadingDots,
2072
+ nameNode: importAsNode.d.module,
2073
+ leadingDots: importAsNode.d.module.d.leadingDots,
2071
2074
  nameParts,
2072
2075
  importedSymbols: undefined,
2073
2076
  });
@@ -2075,27 +2078,27 @@ class Parser {
2075
2078
  else {
2076
2079
  // Implicitly import all modules in the multi-part name if we
2077
2080
  // are not assigning the final module to an alias.
2078
- importAsNode.module.nameParts.forEach((_, index) => {
2081
+ importAsNode.d.module.d.nameParts.forEach((_, index) => {
2079
2082
  this._importedModules.push({
2080
- nameNode: importAsNode.module,
2081
- leadingDots: importAsNode.module.leadingDots,
2083
+ nameNode: importAsNode.d.module,
2084
+ leadingDots: importAsNode.d.module.d.leadingDots,
2082
2085
  nameParts: nameParts.slice(0, index + 1),
2083
2086
  importedSymbols: undefined,
2084
2087
  });
2085
2088
  });
2086
2089
  }
2087
- if (modName.nameParts.length === 1) {
2088
- const firstNamePartValue = modName.nameParts[0].value;
2090
+ if (modName.d.nameParts.length === 1) {
2091
+ const firstNamePartValue = modName.d.nameParts[0].d.value;
2089
2092
  if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
2090
- this._typingImportAliases.push(((_a = importAsNode.alias) === null || _a === void 0 ? void 0 : _a.value) || firstNamePartValue);
2093
+ this._typingImportAliases.push(((_a = importAsNode.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) || firstNamePartValue);
2091
2094
  }
2092
2095
  }
2093
2096
  if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
2094
2097
  break;
2095
2098
  }
2096
2099
  }
2097
- if (importNode.list.length > 0) {
2098
- (0, parseNodes_1.extendRange)(importNode, importNode.list[importNode.list.length - 1]);
2100
+ if (importNode.d.list.length > 0) {
2101
+ (0, parseNodes_1.extendRange)(importNode, importNode.d.list[importNode.d.list.length - 1]);
2099
2102
  }
2100
2103
  return importNode;
2101
2104
  }
@@ -2108,10 +2111,10 @@ class Parser {
2108
2111
  const token = (_a = this._getTokenIfType(19 /* TokenType.Ellipsis */)) !== null && _a !== void 0 ? _a : this._getTokenIfType(20 /* TokenType.Dot */);
2109
2112
  if (token) {
2110
2113
  if (token.type === 19 /* TokenType.Ellipsis */) {
2111
- moduleNameNode.leadingDots += 3;
2114
+ moduleNameNode.d.leadingDots += 3;
2112
2115
  }
2113
2116
  else {
2114
- moduleNameNode.leadingDots++;
2117
+ moduleNameNode.d.leadingDots++;
2115
2118
  }
2116
2119
  (0, parseNodes_1.extendRange)(moduleNameNode, token);
2117
2120
  }
@@ -2122,14 +2125,14 @@ class Parser {
2122
2125
  while (true) {
2123
2126
  const identifier = this._getTokenIfIdentifier();
2124
2127
  if (!identifier) {
2125
- if (!allowJustDots || moduleNameNode.leadingDots === 0 || moduleNameNode.nameParts.length > 0) {
2128
+ if (!allowJustDots || moduleNameNode.d.leadingDots === 0 || moduleNameNode.d.nameParts.length > 0) {
2126
2129
  this._addSyntaxError(localize_1.LocMessage.expectedModuleName(), this._peekToken());
2127
- moduleNameNode.hasTrailingDot = true;
2130
+ moduleNameNode.d.hasTrailingDot = true;
2128
2131
  }
2129
2132
  break;
2130
2133
  }
2131
2134
  const namePart = parseNodes_1.NameNode.create(identifier);
2132
- moduleNameNode.nameParts.push(namePart);
2135
+ moduleNameNode.d.nameParts.push(namePart);
2133
2136
  namePart.parent = moduleNameNode;
2134
2137
  (0, parseNodes_1.extendRange)(moduleNameNode, namePart);
2135
2138
  const nextToken = this._peekToken();
@@ -2144,24 +2147,24 @@ class Parser {
2144
2147
  _parseGlobalStatement() {
2145
2148
  const globalToken = this._getKeywordToken(19 /* KeywordType.Global */);
2146
2149
  const globalNode = parseNodes_1.GlobalNode.create(globalToken);
2147
- globalNode.nameList = this._parseNameList();
2148
- if (globalNode.nameList.length > 0) {
2149
- globalNode.nameList.forEach((name) => {
2150
+ globalNode.d.targets = this._parseNameList();
2151
+ if (globalNode.d.targets.length > 0) {
2152
+ globalNode.d.targets.forEach((name) => {
2150
2153
  name.parent = globalNode;
2151
2154
  });
2152
- (0, parseNodes_1.extendRange)(globalNode, globalNode.nameList[globalNode.nameList.length - 1]);
2155
+ (0, parseNodes_1.extendRange)(globalNode, globalNode.d.targets[globalNode.d.targets.length - 1]);
2153
2156
  }
2154
2157
  return globalNode;
2155
2158
  }
2156
2159
  _parseNonlocalStatement() {
2157
2160
  const nonlocalToken = this._getKeywordToken(27 /* KeywordType.Nonlocal */);
2158
2161
  const nonlocalNode = parseNodes_1.NonlocalNode.create(nonlocalToken);
2159
- nonlocalNode.nameList = this._parseNameList();
2160
- if (nonlocalNode.nameList.length > 0) {
2161
- nonlocalNode.nameList.forEach((name) => {
2162
+ nonlocalNode.d.targets = this._parseNameList();
2163
+ if (nonlocalNode.d.targets.length > 0) {
2164
+ nonlocalNode.d.targets.forEach((name) => {
2162
2165
  name.parent = nonlocalNode;
2163
2166
  });
2164
- (0, parseNodes_1.extendRange)(nonlocalNode, nonlocalNode.nameList[nonlocalNode.nameList.length - 1]);
2167
+ (0, parseNodes_1.extendRange)(nonlocalNode, nonlocalNode.d.targets[nonlocalNode.d.targets.length - 1]);
2165
2168
  }
2166
2169
  return nonlocalNode;
2167
2170
  }
@@ -2186,24 +2189,25 @@ class Parser {
2186
2189
  const raiseToken = this._getKeywordToken(31 /* KeywordType.Raise */);
2187
2190
  const raiseNode = parseNodes_1.RaiseNode.create(raiseToken);
2188
2191
  if (!this._isNextTokenNeverExpression()) {
2189
- raiseNode.typeExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
2190
- raiseNode.typeExpression.parent = raiseNode;
2191
- (0, parseNodes_1.extendRange)(raiseNode, raiseNode.typeExpression);
2192
+ raiseNode.d.typeExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
2193
+ raiseNode.d.typeExpression.parent = raiseNode;
2194
+ (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.typeExpression);
2192
2195
  if (this._consumeTokenIfKeyword(18 /* KeywordType.From */)) {
2193
- raiseNode.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
2194
- raiseNode.valueExpression.parent = raiseNode;
2195
- (0, parseNodes_1.extendRange)(raiseNode, raiseNode.valueExpression);
2196
+ raiseNode.d.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
2197
+ raiseNode.d.valueExpression.parent = raiseNode;
2198
+ (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.valueExpression);
2196
2199
  }
2197
2200
  else {
2198
2201
  if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
2199
2202
  // Handle the Python 2.x variant
2200
- raiseNode.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
2201
- raiseNode.valueExpression.parent = raiseNode;
2202
- (0, parseNodes_1.extendRange)(raiseNode, raiseNode.valueExpression);
2203
+ raiseNode.d.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
2204
+ raiseNode.d.valueExpression.parent = raiseNode;
2205
+ (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.valueExpression);
2203
2206
  if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
2204
- raiseNode.tracebackExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
2205
- raiseNode.tracebackExpression.parent = raiseNode;
2206
- (0, parseNodes_1.extendRange)(raiseNode, raiseNode.tracebackExpression);
2207
+ raiseNode.d.tracebackExpression = this._parseTestExpression(
2208
+ /* allowAssignmentExpression */ true);
2209
+ raiseNode.d.tracebackExpression.parent = raiseNode;
2210
+ (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.tracebackExpression);
2207
2211
  }
2208
2212
  }
2209
2213
  }
@@ -2217,8 +2221,8 @@ class Parser {
2217
2221
  const assertNode = parseNodes_1.AssertNode.create(assertToken, expr);
2218
2222
  if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
2219
2223
  const exceptionExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
2220
- assertNode.exceptionExpression = exceptionExpr;
2221
- assertNode.exceptionExpression.parent = assertNode;
2224
+ assertNode.d.exceptionExpr = exceptionExpr;
2225
+ assertNode.d.exceptionExpr.parent = assertNode;
2222
2226
  (0, parseNodes_1.extendRange)(assertNode, exceptionExpr);
2223
2227
  }
2224
2228
  return assertNode;
@@ -2231,12 +2235,12 @@ class Parser {
2231
2235
  this._addSyntaxError(localize_1.LocMessage.expectedDelExpr(), this._peekToken());
2232
2236
  }
2233
2237
  const delNode = parseNodes_1.DelNode.create(delToken);
2234
- delNode.expressions = exprListResult.list;
2235
- if (delNode.expressions.length > 0) {
2236
- delNode.expressions.forEach((expr) => {
2238
+ delNode.d.targets = exprListResult.list;
2239
+ if (delNode.d.targets.length > 0) {
2240
+ delNode.d.targets.forEach((expr) => {
2237
2241
  expr.parent = delNode;
2238
2242
  });
2239
- (0, parseNodes_1.extendRange)(delNode, delNode.expressions[delNode.expressions.length - 1]);
2243
+ (0, parseNodes_1.extendRange)(delNode, delNode.d.targets[delNode.d.targets.length - 1]);
2240
2244
  }
2241
2245
  return delNode;
2242
2246
  }
@@ -2281,7 +2285,7 @@ class Parser {
2281
2285
  break;
2282
2286
  }
2283
2287
  const smallStatement = this._parseSmallStatement();
2284
- statement.statements.push(smallStatement);
2288
+ statement.d.statements.push(smallStatement);
2285
2289
  smallStatement.parent = statement;
2286
2290
  (0, parseNodes_1.extendRange)(statement, smallStatement);
2287
2291
  if (smallStatement.nodeType === 0 /* ParseNodeType.Error */) {
@@ -2370,7 +2374,7 @@ class Parser {
2370
2374
  // the opening parenthesis as the opening token.
2371
2375
  const tupleStartRange = exprListResult.list.length > 0 ? exprListResult.list[0] : this._peekToken(-1);
2372
2376
  const tupleNode = parseNodes_1.TupleNode.create(tupleStartRange, enclosedInParens);
2373
- tupleNode.expressions = exprListResult.list;
2377
+ tupleNode.d.items = exprListResult.list;
2374
2378
  if (exprListResult.list.length > 0) {
2375
2379
  exprListResult.list.forEach((expr) => {
2376
2380
  expr.parent = tupleNode;
@@ -2716,15 +2720,14 @@ class Parser {
2716
2720
  // to refer to the typing types.
2717
2721
  _isTypingAnnotation(typeAnnotation, name) {
2718
2722
  if (typeAnnotation.nodeType === 38 /* ParseNodeType.Name */) {
2719
- const alias = this._typingSymbolAliases.get(typeAnnotation.value);
2723
+ const alias = this._typingSymbolAliases.get(typeAnnotation.d.value);
2720
2724
  if (alias === name) {
2721
2725
  return true;
2722
2726
  }
2723
2727
  }
2724
2728
  else if (typeAnnotation.nodeType === 35 /* ParseNodeType.MemberAccess */) {
2725
- if (typeAnnotation.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
2726
- typeAnnotation.memberName.value === name) {
2727
- const baseName = typeAnnotation.leftExpression.value;
2729
+ if (typeAnnotation.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && typeAnnotation.d.member.d.value === name) {
2730
+ const baseName = typeAnnotation.d.leftExpr.d.value;
2728
2731
  return this._typingImportAliases.some((alias) => alias === baseName);
2729
2732
  }
2730
2733
  }
@@ -2733,6 +2736,7 @@ class Parser {
2733
2736
  // atom_expr: ['await'] atom trailer*
2734
2737
  // trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
2735
2738
  _parseAtomExpression() {
2739
+ var _a, _b, _c;
2736
2740
  let awaitToken;
2737
2741
  if (this._peekKeywordType() === 4 /* KeywordType.Await */) {
2738
2742
  awaitToken = this._getKeywordToken(4 /* KeywordType.Await */);
@@ -2757,9 +2761,9 @@ class Parser {
2757
2761
  const callNode = parseNodes_1.CallNode.create(atomExpression, argListResult.args, argListResult.trailingComma);
2758
2762
  if (argListResult.args.length > 1 || argListResult.trailingComma) {
2759
2763
  argListResult.args.forEach((arg) => {
2760
- if (arg.valueExpression.nodeType === 11 /* ParseNodeType.Comprehension */) {
2761
- if (!arg.valueExpression.isParenthesized) {
2762
- this._addSyntaxError(localize_1.LocMessage.generatorNotParenthesized(), arg.valueExpression);
2764
+ if (arg.d.valueExpr.nodeType === 11 /* ParseNodeType.Comprehension */) {
2765
+ if (!arg.d.valueExpr.d.hasParens) {
2766
+ this._addSyntaxError(localize_1.LocMessage.generatorNotParenthesized(), arg.d.valueExpr);
2763
2767
  }
2764
2768
  }
2765
2769
  });
@@ -2780,11 +2784,15 @@ class Parser {
2780
2784
  isArgListTerminated = true;
2781
2785
  }
2782
2786
  this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
2783
- atomExpression = callNode;
2784
- if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
2785
- atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
2787
+ const maxDepth = (_a = this._maxChildDepthMap.get(atomExpression.id)) !== null && _a !== void 0 ? _a : 0;
2788
+ if (maxDepth >= maxChildNodeDepth) {
2789
+ atomExpression = parseNodes_1.ErrorNode.create(callNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
2786
2790
  this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
2787
2791
  }
2792
+ else {
2793
+ atomExpression = callNode;
2794
+ this._maxChildDepthMap.set(callNode.id, maxDepth + 1);
2795
+ }
2788
2796
  // If the argument list wasn't terminated, break out of the loop
2789
2797
  if (!isArgListTerminated) {
2790
2798
  break;
@@ -2813,11 +2821,15 @@ class Parser {
2813
2821
  // case because it creates problems for the completion provider.
2814
2822
  this._handleExpressionParseError(6 /* ErrorExpressionCategory.MissingIndexCloseBracket */, localize_1.LocMessage.expectedCloseBracket(), startOfTrailerToken, indexNode);
2815
2823
  }
2816
- atomExpression = indexNode;
2817
- if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
2818
- atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
2824
+ const maxDepth = (_b = this._maxChildDepthMap.get(atomExpression.id)) !== null && _b !== void 0 ? _b : 0;
2825
+ if (maxDepth >= maxChildNodeDepth) {
2826
+ atomExpression = parseNodes_1.ErrorNode.create(indexNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
2819
2827
  this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
2820
2828
  }
2829
+ else {
2830
+ atomExpression = indexNode;
2831
+ this._maxChildDepthMap.set(indexNode.id, maxDepth + 1);
2832
+ }
2821
2833
  }
2822
2834
  else if (this._consumeTokenIfType(20 /* TokenType.Dot */)) {
2823
2835
  // Is it a member access?
@@ -2825,11 +2837,16 @@ class Parser {
2825
2837
  if (!memberName) {
2826
2838
  return this._handleExpressionParseError(7 /* ErrorExpressionCategory.MissingMemberAccessName */, localize_1.LocMessage.expectedMemberName(), startOfTrailerToken, atomExpression, [8 /* TokenType.Keyword */]);
2827
2839
  }
2828
- atomExpression = parseNodes_1.MemberAccessNode.create(atomExpression, parseNodes_1.NameNode.create(memberName));
2829
- if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
2830
- atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
2840
+ const memberAccessNode = parseNodes_1.MemberAccessNode.create(atomExpression, parseNodes_1.NameNode.create(memberName));
2841
+ const maxDepth = (_c = this._maxChildDepthMap.get(atomExpression.id)) !== null && _c !== void 0 ? _c : 0;
2842
+ if (maxDepth >= maxChildNodeDepth) {
2843
+ atomExpression = parseNodes_1.ErrorNode.create(memberAccessNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
2831
2844
  this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
2832
2845
  }
2846
+ else {
2847
+ atomExpression = memberAccessNode;
2848
+ this._maxChildDepthMap.set(memberAccessNode.id, maxDepth + 1);
2849
+ }
2833
2850
  }
2834
2851
  else {
2835
2852
  break;
@@ -2866,7 +2883,7 @@ class Parser {
2866
2883
  const nameExpr = valueExpr;
2867
2884
  valueExpr = this._parsePossibleSlice();
2868
2885
  if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
2869
- nameIdentifier = nameExpr.token;
2886
+ nameIdentifier = nameExpr.d.token;
2870
2887
  }
2871
2888
  else {
2872
2889
  this._addSyntaxError(localize_1.LocMessage.expectedParamName(), nameExpr);
@@ -2884,18 +2901,18 @@ class Parser {
2884
2901
  }
2885
2902
  const argNode = parseNodes_1.ArgumentNode.create(firstToken, valueExpr, argType);
2886
2903
  if (nameIdentifier) {
2887
- argNode.name = parseNodes_1.NameNode.create(nameIdentifier);
2888
- argNode.name.parent = argNode;
2904
+ argNode.d.name = parseNodes_1.NameNode.create(nameIdentifier);
2905
+ argNode.d.name.parent = argNode;
2889
2906
  }
2890
- if (argNode.name) {
2907
+ if (argNode.d.name) {
2891
2908
  sawKeywordArg = true;
2892
2909
  }
2893
- else if (sawKeywordArg && argNode.argumentCategory === 0 /* ArgumentCategory.Simple */) {
2910
+ else if (sawKeywordArg && argNode.d.argCategory === 0 /* ArgumentCategory.Simple */) {
2894
2911
  this._addSyntaxError(localize_1.LocMessage.positionArgAfterNamedArg(), argNode);
2895
2912
  }
2896
2913
  argList.push(argNode);
2897
- if (argNode.name) {
2898
- this._addSyntaxError(localize_1.LocMessage.keywordSubscriptIllegal(), argNode.name);
2914
+ if (argNode.d.name) {
2915
+ this._addSyntaxError(localize_1.LocMessage.keywordSubscriptIllegal(), argNode.d.name);
2899
2916
  }
2900
2917
  if (argType !== 0 /* ArgumentCategory.Simple */) {
2901
2918
  const unpackListAllowed = this._parseOptions.isStubFile ||
@@ -2957,17 +2974,17 @@ class Parser {
2957
2974
  return parseNodes_1.ErrorNode.create(this._peekToken(), 3 /* ErrorExpressionCategory.MissingIndexOrSlice */);
2958
2975
  }
2959
2976
  const sliceNode = parseNodes_1.SliceNode.create(firstToken);
2960
- sliceNode.startValue = sliceExpressions[0];
2961
- if (sliceNode.startValue) {
2962
- sliceNode.startValue.parent = sliceNode;
2977
+ sliceNode.d.startValue = sliceExpressions[0];
2978
+ if (sliceNode.d.startValue) {
2979
+ sliceNode.d.startValue.parent = sliceNode;
2963
2980
  }
2964
- sliceNode.endValue = sliceExpressions[1];
2965
- if (sliceNode.endValue) {
2966
- sliceNode.endValue.parent = sliceNode;
2981
+ sliceNode.d.endValue = sliceExpressions[1];
2982
+ if (sliceNode.d.endValue) {
2983
+ sliceNode.d.endValue.parent = sliceNode;
2967
2984
  }
2968
- sliceNode.stepValue = sliceExpressions[2];
2969
- if (sliceNode.stepValue) {
2970
- sliceNode.stepValue.parent = sliceNode;
2985
+ sliceNode.d.stepValue = sliceExpressions[2];
2986
+ if (sliceNode.d.stepValue) {
2987
+ sliceNode.d.stepValue.parent = sliceNode;
2971
2988
  }
2972
2989
  const extension = sliceExpressions[2] || sliceExpressions[1] || sliceExpressions[0];
2973
2990
  if (extension) {
@@ -2989,10 +3006,10 @@ class Parser {
2989
3006
  }
2990
3007
  trailingComma = false;
2991
3008
  const arg = this._parseArgument();
2992
- if (arg.name) {
3009
+ if (arg.d.name) {
2993
3010
  sawKeywordArg = true;
2994
3011
  }
2995
- else if (sawKeywordArg && arg.argumentCategory === 0 /* ArgumentCategory.Simple */) {
3012
+ else if (sawKeywordArg && arg.d.argCategory === 0 /* ArgumentCategory.Simple */) {
2996
3013
  this._addSyntaxError(localize_1.LocMessage.positionArgAfterNamedArg(), arg);
2997
3014
  }
2998
3015
  argList.push(arg);
@@ -3004,7 +3021,8 @@ class Parser {
3004
3021
  return { args: argList, trailingComma };
3005
3022
  }
3006
3023
  // argument: ( test [comp_for] |
3007
- // test '=' test |
3024
+ // name '=' test |
3025
+ // name '=' |
3008
3026
  // '**' test |
3009
3027
  // '*' test )
3010
3028
  _parseArgument() {
@@ -3017,16 +3035,34 @@ class Parser {
3017
3035
  argType = 2 /* ArgumentCategory.UnpackedDictionary */;
3018
3036
  }
3019
3037
  let valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ true);
3020
- let nameIdentifier;
3038
+ let nameNode;
3039
+ let isNameSameAsValue = false;
3040
+ let assignmentToken;
3021
3041
  if (argType === 0 /* ArgumentCategory.Simple */) {
3042
+ const nextToken = this._peekToken();
3022
3043
  if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
3044
+ assignmentToken = nextToken;
3023
3045
  const nameExpr = valueExpr;
3024
- valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
3025
- if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
3026
- nameIdentifier = nameExpr.token;
3046
+ if (nameExpr.nodeType === 38 /* ParseNodeType.Name */ &&
3047
+ (this._peekTokenType() === 12 /* TokenType.Comma */ || this._peekTokenType() === 14 /* TokenType.CloseParenthesis */)) {
3048
+ nameNode = parseNodes_1.NameNode.create(nameExpr.d.token);
3049
+ if (this._getLanguageVersion().isLessThan(pythonVersion_1.pythonVersion3_14)) {
3050
+ this._addSyntaxError(localize_1.LocMessage.keywordArgShortcutIllegal(), assignmentToken);
3051
+ valueExpr = parseNodes_1.ErrorNode.create(assignmentToken, 14 /* ErrorExpressionCategory.MissingKeywordArgValue */);
3052
+ }
3053
+ else {
3054
+ valueExpr = parseNodes_1.NameNode.create(nameExpr.d.token);
3055
+ isNameSameAsValue = true;
3056
+ }
3027
3057
  }
3028
3058
  else {
3029
- this._addSyntaxError(localize_1.LocMessage.expectedParamName(), nameExpr);
3059
+ valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
3060
+ if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
3061
+ nameNode = parseNodes_1.NameNode.create(nameExpr.d.token);
3062
+ }
3063
+ else {
3064
+ this._addSyntaxError(localize_1.LocMessage.expectedParamName(), nameExpr);
3065
+ }
3030
3066
  }
3031
3067
  }
3032
3068
  else {
@@ -3037,9 +3073,13 @@ class Parser {
3037
3073
  }
3038
3074
  }
3039
3075
  const argNode = parseNodes_1.ArgumentNode.create(firstToken, valueExpr, argType);
3040
- if (nameIdentifier) {
3041
- argNode.name = parseNodes_1.NameNode.create(nameIdentifier);
3042
- argNode.name.parent = argNode;
3076
+ if (nameNode) {
3077
+ argNode.d.name = nameNode;
3078
+ argNode.d.isNameSameAsValue = isNameSameAsValue;
3079
+ argNode.d.name.parent = argNode;
3080
+ if (assignmentToken) {
3081
+ (0, parseNodes_1.extendRange)(argNode, assignmentToken);
3082
+ }
3043
3083
  }
3044
3084
  return argNode;
3045
3085
  }
@@ -3080,12 +3120,12 @@ class Parser {
3080
3120
  // to use comparison chaining, which isn't appropriate when the
3081
3121
  // expression is parenthesized. Unary and await expressions
3082
3122
  // are also marked to be able to display them unambiguously.
3083
- possibleTupleNode.parenthesized = true;
3123
+ possibleTupleNode.d.hasParens = true;
3084
3124
  }
3085
3125
  if (possibleTupleNode.nodeType === 48 /* ParseNodeType.StringList */ ||
3086
3126
  possibleTupleNode.nodeType === 11 /* ParseNodeType.Comprehension */ ||
3087
3127
  possibleTupleNode.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
3088
- possibleTupleNode.isParenthesized = true;
3128
+ possibleTupleNode.d.hasParens = true;
3089
3129
  }
3090
3130
  return possibleTupleNode;
3091
3131
  }
@@ -3147,7 +3187,7 @@ class Parser {
3147
3187
  testExpr = this._tryParseLambdaExpression(/* allowConditional */ false) || this._parseOrTest();
3148
3188
  }
3149
3189
  const lambdaNode = parseNodes_1.LambdaNode.create(lambdaToken, testExpr);
3150
- lambdaNode.parameters = argList;
3190
+ lambdaNode.d.params = argList;
3151
3191
  argList.forEach((arg) => {
3152
3192
  arg.parent = lambdaNode;
3153
3193
  });
@@ -3209,7 +3249,7 @@ class Parser {
3209
3249
  });
3210
3250
  (0, parseNodes_1.extendRange)(listAtom, exprListResult.list[exprListResult.list.length - 1]);
3211
3251
  }
3212
- listAtom.entries = exprListResult.list;
3252
+ listAtom.d.items = exprListResult.list;
3213
3253
  return listAtom;
3214
3254
  }
3215
3255
  }
@@ -3265,8 +3305,8 @@ class Parser {
3265
3305
  }
3266
3306
  if (!isWalrusAllowed &&
3267
3307
  keyExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */ &&
3268
- !keyExpression.isParenthesized) {
3269
- this._addSyntaxError(localize_1.LocMessage.walrusNotAllowed(), keyExpression.walrusToken);
3308
+ !keyExpression.d.hasParens) {
3309
+ this._addSyntaxError(localize_1.LocMessage.walrusNotAllowed(), keyExpression.d.walrusToken);
3270
3310
  }
3271
3311
  }
3272
3312
  if (keyExpression && valueExpression) {
@@ -3360,12 +3400,12 @@ class Parser {
3360
3400
  setEntries.forEach((entry) => {
3361
3401
  entry.parent = setAtom;
3362
3402
  });
3363
- setAtom.entries = setEntries;
3403
+ setAtom.d.items = setEntries;
3364
3404
  return setAtom;
3365
3405
  }
3366
3406
  const dictionaryAtom = parseNodes_1.DictionaryNode.create(startBrace);
3367
3407
  if (trailingCommaToken) {
3368
- dictionaryAtom.trailingCommaToken = trailingCommaToken;
3408
+ dictionaryAtom.d.trailingCommaToken = trailingCommaToken;
3369
3409
  (0, parseNodes_1.extendRange)(dictionaryAtom, trailingCommaToken);
3370
3410
  }
3371
3411
  if (closeCurlyBrace) {
@@ -3377,7 +3417,7 @@ class Parser {
3377
3417
  });
3378
3418
  (0, parseNodes_1.extendRange)(dictionaryAtom, dictionaryEntries[dictionaryEntries.length - 1]);
3379
3419
  }
3380
- dictionaryAtom.entries = dictionaryEntries;
3420
+ dictionaryAtom.d.items = dictionaryEntries;
3381
3421
  return dictionaryAtom;
3382
3422
  }
3383
3423
  _parseExpressionListGeneric(parser, terminalCheck = () => this._isNextTokenNeverExpression(), finalEntryCheck = () => false) {
@@ -3493,12 +3533,12 @@ class Parser {
3493
3533
  // same reason that variable type annotations don't support
3494
3534
  // chained assignments. Note that a type comment was used here
3495
3535
  // so it can be later reported as an error by the binder.
3496
- assignmentNode.chainedTypeAnnotationComment = typeAnnotationComment;
3536
+ assignmentNode.d.chainedAnnotationComment = typeAnnotationComment;
3497
3537
  }
3498
3538
  else {
3499
- assignmentNode.typeAnnotationComment = typeAnnotationComment;
3500
- assignmentNode.typeAnnotationComment.parent = assignmentNode;
3501
- (0, parseNodes_1.extendRange)(assignmentNode, assignmentNode.typeAnnotationComment);
3539
+ assignmentNode.d.annotationComment = typeAnnotationComment;
3540
+ assignmentNode.d.annotationComment.parent = assignmentNode;
3541
+ (0, parseNodes_1.extendRange)(assignmentNode, assignmentNode.d.annotationComment);
3502
3542
  }
3503
3543
  }
3504
3544
  assignmentTargets.forEach((target, index) => {
@@ -3653,7 +3693,7 @@ class Parser {
3653
3693
  return;
3654
3694
  }
3655
3695
  const functionAnnotation = parseResults.parseTree;
3656
- functionNode.functionAnnotationComment = functionAnnotation;
3696
+ functionNode.d.funcAnnotationComment = functionAnnotation;
3657
3697
  functionAnnotation.parent = functionNode;
3658
3698
  (0, parseNodes_1.extendRange)(functionNode, functionAnnotation);
3659
3699
  }
@@ -3776,28 +3816,33 @@ class Parser {
3776
3816
  return parseNodes_1.FormatStringNode.create(startToken, endToken, middleTokens, fieldExpressions, formatExpressions);
3777
3817
  }
3778
3818
  _createBinaryOperationNode(leftExpression, rightExpression, operatorToken, operator) {
3819
+ var _a, _b;
3820
+ const binaryNode = parseNodes_1.BinaryOperationNode.create(leftExpression, rightExpression, operatorToken, operator);
3779
3821
  // Determine if we're exceeding the max parse depth. If so, replace
3780
3822
  // the subnode with an error node. Otherwise we risk crashing in the binder
3781
3823
  // or type evaluator.
3782
- if (leftExpression.maxChildDepth !== undefined && leftExpression.maxChildDepth >= maxChildNodeDepth) {
3783
- leftExpression = parseNodes_1.ErrorNode.create(leftExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
3784
- this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), leftExpression);
3824
+ const leftMaxDepth = (_a = this._maxChildDepthMap.get(leftExpression.id)) !== null && _a !== void 0 ? _a : 0;
3825
+ const rightMaxDepth = (_b = this._maxChildDepthMap.get(rightExpression.id)) !== null && _b !== void 0 ? _b : 0;
3826
+ if (leftMaxDepth >= maxChildNodeDepth || rightMaxDepth >= maxChildNodeDepth) {
3827
+ this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), binaryNode);
3828
+ return parseNodes_1.ErrorNode.create(binaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
3785
3829
  }
3786
- if (rightExpression.maxChildDepth !== undefined && rightExpression.maxChildDepth >= maxChildNodeDepth) {
3787
- rightExpression = parseNodes_1.ErrorNode.create(rightExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
3788
- this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), rightExpression);
3789
- }
3790
- return parseNodes_1.BinaryOperationNode.create(leftExpression, rightExpression, operatorToken, operator);
3830
+ this._maxChildDepthMap.set(binaryNode.id, Math.max(leftMaxDepth, rightMaxDepth) + 1);
3831
+ return binaryNode;
3791
3832
  }
3792
3833
  _createUnaryOperationNode(operatorToken, expression, operator) {
3834
+ var _a;
3835
+ const unaryNode = parseNodes_1.UnaryOperationNode.create(operatorToken, expression, operator);
3793
3836
  // Determine if we're exceeding the max parse depth. If so, replace
3794
3837
  // the subnode with an error node. Otherwise we risk crashing in the binder
3795
3838
  // or type evaluator.
3796
- if (expression.maxChildDepth !== undefined && expression.maxChildDepth >= maxChildNodeDepth) {
3797
- expression = parseNodes_1.ErrorNode.create(expression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
3798
- this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), expression);
3839
+ const maxDepth = (_a = this._maxChildDepthMap.get(expression.id)) !== null && _a !== void 0 ? _a : 0;
3840
+ if (maxDepth >= maxChildNodeDepth) {
3841
+ this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), unaryNode);
3842
+ return parseNodes_1.ErrorNode.create(unaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
3799
3843
  }
3800
- return parseNodes_1.UnaryOperationNode.create(operatorToken, expression, operator);
3844
+ this._maxChildDepthMap.set(unaryNode.id, maxDepth + 1);
3845
+ return unaryNode;
3801
3846
  }
3802
3847
  _parseStringList() {
3803
3848
  const stringList = [];
@@ -3818,19 +3863,19 @@ class Parser {
3818
3863
  if (this._isParsingTypeAnnotation) {
3819
3864
  // Don't allow multiple strings because we have no way of reporting
3820
3865
  // parse errors that span strings.
3821
- if (stringNode.strings.length > 1) {
3866
+ if (stringNode.d.strings.length > 1) {
3822
3867
  if (this._isParsingQuotedText) {
3823
3868
  this._addSyntaxError(localize_1.LocMessage.annotationSpansStrings(), stringNode);
3824
3869
  }
3825
3870
  }
3826
- else if (stringNode.strings[0].nodeType === 30 /* ParseNodeType.FormatString */) {
3871
+ else if (stringNode.d.strings[0].nodeType === 30 /* ParseNodeType.FormatString */) {
3827
3872
  if (this._isParsingQuotedText) {
3828
3873
  this._addSyntaxError(localize_1.LocMessage.annotationFormatString(), stringNode);
3829
3874
  }
3830
3875
  }
3831
3876
  else {
3832
- const stringToken = stringNode.strings[0].token;
3833
- const stringValue = StringTokenUtils.getUnescapedString(stringNode.strings[0].token);
3877
+ const stringToken = stringNode.d.strings[0].d.token;
3878
+ const stringValue = StringTokenUtils.getUnescapedString(stringNode.d.strings[0].d.token);
3834
3879
  const unescapedString = stringValue.value;
3835
3880
  const tokenOffset = stringToken.start;
3836
3881
  const prefixLength = stringToken.prefixLength + stringToken.quoteMarkLength;
@@ -3844,7 +3889,7 @@ class Parser {
3844
3889
  else if ((stringToken.flags & (8 /* StringTokenFlags.Raw */ | 32 /* StringTokenFlags.Bytes */ | 64 /* StringTokenFlags.Format */)) ===
3845
3890
  0) {
3846
3891
  const parser = new Parser();
3847
- const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.strings[0].token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
3892
+ const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.d.strings[0].d.token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
3848
3893
  if (parseResults.diagnostics.length === 0 ||
3849
3894
  this._parseOptions.reportErrorsForParsedStringContents) {
3850
3895
  parseResults.diagnostics.forEach((diag) => {
@@ -3852,8 +3897,8 @@ class Parser {
3852
3897
  });
3853
3898
  if (parseResults.parseTree) {
3854
3899
  (0, debug_1.assert)(parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */);
3855
- stringNode.typeAnnotation = parseResults.parseTree;
3856
- stringNode.typeAnnotation.parent = stringNode;
3900
+ stringNode.d.annotation = parseResults.parseTree;
3901
+ stringNode.d.annotation.parent = stringNode;
3857
3902
  }
3858
3903
  }
3859
3904
  }
@@ -3868,13 +3913,13 @@ class Parser {
3868
3913
  if (possibleTupleExpr.nodeType !== 52 /* ParseNodeType.Tuple */) {
3869
3914
  return;
3870
3915
  }
3871
- if (possibleTupleExpr.enclosedInParens) {
3916
+ if (possibleTupleExpr.d.hasParens) {
3872
3917
  return;
3873
3918
  }
3874
3919
  if (this._parseOptions.pythonVersion.isGreaterOrEqualTo(pythonVersion)) {
3875
3920
  return;
3876
3921
  }
3877
- for (const expr of possibleTupleExpr.expressions) {
3922
+ for (const expr of possibleTupleExpr.d.items) {
3878
3923
  if (expr.nodeType === 56 /* ParseNodeType.Unpack */) {
3879
3924
  this._addSyntaxError(localize_1.LocMessage.unpackTuplesIllegal(), expr);
3880
3925
  return;