@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

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 (170) 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 +507 -513
  4. package/dist/analyzer/binder.js.map +1 -1
  5. package/dist/analyzer/checker.js +652 -633
  6. package/dist/analyzer/checker.js.map +1 -1
  7. package/dist/analyzer/codeFlowEngine.d.ts +5 -3
  8. package/dist/analyzer/codeFlowEngine.js +143 -122
  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.d.ts +1 -1
  13. package/dist/analyzer/constraintSolver.js +71 -67
  14. package/dist/analyzer/constraintSolver.js.map +1 -1
  15. package/dist/analyzer/constructorTransform.js +22 -22
  16. package/dist/analyzer/constructorTransform.js.map +1 -1
  17. package/dist/analyzer/constructors.js +85 -77
  18. package/dist/analyzer/constructors.js.map +1 -1
  19. package/dist/analyzer/dataClasses.js +113 -176
  20. package/dist/analyzer/dataClasses.js.map +1 -1
  21. package/dist/analyzer/declaration.d.ts +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 +85 -85
  25. package/dist/analyzer/decorators.js.map +1 -1
  26. package/dist/analyzer/enums.js +71 -57
  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.d.ts +4 -4
  38. package/dist/analyzer/operations.js +70 -70
  39. package/dist/analyzer/operations.js.map +1 -1
  40. package/dist/analyzer/packageTypeVerifier.js +66 -62
  41. package/dist/analyzer/packageTypeVerifier.js.map +1 -1
  42. package/dist/analyzer/parameterUtils.d.ts +4 -4
  43. package/dist/analyzer/parameterUtils.js +28 -46
  44. package/dist/analyzer/parameterUtils.js.map +1 -1
  45. package/dist/analyzer/parseTreeUtils.js +268 -269
  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 +195 -147
  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 +78 -147
  54. package/dist/analyzer/properties.js.map +1 -1
  55. package/dist/analyzer/protocols.js +22 -22
  56. package/dist/analyzer/protocols.js.map +1 -1
  57. package/dist/analyzer/sourceFile.d.ts +3 -2
  58. package/dist/analyzer/sourceFile.js +8 -8
  59. package/dist/analyzer/sourceFile.js.map +1 -1
  60. package/dist/analyzer/sourceMapper.js +20 -19
  61. package/dist/analyzer/sourceMapper.js.map +1 -1
  62. package/dist/analyzer/staticExpressions.js +83 -84
  63. package/dist/analyzer/staticExpressions.js.map +1 -1
  64. package/dist/analyzer/testWalker.js +2 -2
  65. package/dist/analyzer/testWalker.js.map +1 -1
  66. package/dist/analyzer/tracePrinter.js +20 -20
  67. package/dist/analyzer/tracePrinter.js.map +1 -1
  68. package/dist/analyzer/typeDocStringUtils.js +25 -25
  69. package/dist/analyzer/typeDocStringUtils.js.map +1 -1
  70. package/dist/analyzer/typeEvaluator.js +2330 -2367
  71. package/dist/analyzer/typeEvaluator.js.map +1 -1
  72. package/dist/analyzer/typeEvaluatorTypes.d.ts +33 -31
  73. package/dist/analyzer/typeEvaluatorTypes.js +48 -41
  74. package/dist/analyzer/typeEvaluatorTypes.js.map +1 -1
  75. package/dist/analyzer/typeGuards.js +221 -217
  76. package/dist/analyzer/typeGuards.js.map +1 -1
  77. package/dist/analyzer/typePrinter.js +118 -115
  78. package/dist/analyzer/typePrinter.js.map +1 -1
  79. package/dist/analyzer/typeStubWriter.js +104 -103
  80. package/dist/analyzer/typeStubWriter.js.map +1 -1
  81. package/dist/analyzer/typeUtils.d.ts +26 -9
  82. package/dist/analyzer/typeUtils.js +460 -404
  83. package/dist/analyzer/typeUtils.js.map +1 -1
  84. package/dist/analyzer/typeVarContext.js +8 -8
  85. package/dist/analyzer/typeVarContext.js.map +1 -1
  86. package/dist/analyzer/typeWalker.js +13 -10
  87. package/dist/analyzer/typeWalker.js.map +1 -1
  88. package/dist/analyzer/typedDicts.js +96 -198
  89. package/dist/analyzer/typedDicts.js.map +1 -1
  90. package/dist/analyzer/types.d.ts +147 -103
  91. package/dist/analyzer/types.js +668 -493
  92. package/dist/analyzer/types.js.map +1 -1
  93. package/dist/commands/dumpFileDebugInfoCommand.js +33 -33
  94. package/dist/commands/dumpFileDebugInfoCommand.js.map +1 -1
  95. package/dist/common/diagnostic.d.ts +14 -0
  96. package/dist/common/diagnostic.js +41 -1
  97. package/dist/common/diagnostic.js.map +1 -1
  98. package/dist/common/diagnosticSink.d.ts +4 -0
  99. package/dist/common/diagnosticSink.js +21 -1
  100. package/dist/common/diagnosticSink.js.map +1 -1
  101. package/dist/common/fileSystem.d.ts +1 -0
  102. package/dist/common/fileSystem.js.map +1 -1
  103. package/dist/common/fullAccessHost.js +6 -4
  104. package/dist/common/fullAccessHost.js.map +1 -1
  105. package/dist/common/realFileSystem.d.ts +1 -0
  106. package/dist/common/realFileSystem.js +4 -0
  107. package/dist/common/realFileSystem.js.map +1 -1
  108. package/dist/common/textEditTracker.js +14 -14
  109. package/dist/common/textEditTracker.js.map +1 -1
  110. package/dist/languageService/autoImporter.js +10 -10
  111. package/dist/languageService/autoImporter.js.map +1 -1
  112. package/dist/languageService/callHierarchyProvider.js +23 -23
  113. package/dist/languageService/callHierarchyProvider.js.map +1 -1
  114. package/dist/languageService/completionProvider.d.ts +1 -1
  115. package/dist/languageService/completionProvider.js +156 -154
  116. package/dist/languageService/completionProvider.js.map +1 -1
  117. package/dist/languageService/definitionProvider.d.ts +1 -1
  118. package/dist/languageService/definitionProvider.js +3 -1
  119. package/dist/languageService/definitionProvider.js.map +1 -1
  120. package/dist/languageService/documentSymbolCollector.js +19 -19
  121. package/dist/languageService/documentSymbolCollector.js.map +1 -1
  122. package/dist/languageService/hoverProvider.js +25 -24
  123. package/dist/languageService/hoverProvider.js.map +1 -1
  124. package/dist/languageService/importSorter.js +8 -8
  125. package/dist/languageService/importSorter.js.map +1 -1
  126. package/dist/languageService/referencesProvider.js +8 -8
  127. package/dist/languageService/referencesProvider.js.map +1 -1
  128. package/dist/languageService/signatureHelpProvider.d.ts +1 -1
  129. package/dist/languageService/signatureHelpProvider.js +6 -6
  130. package/dist/languageService/signatureHelpProvider.js.map +1 -1
  131. package/dist/languageService/symbolIndexer.js +3 -3
  132. package/dist/languageService/symbolIndexer.js.map +1 -1
  133. package/dist/languageService/tooltipUtils.js +13 -13
  134. package/dist/languageService/tooltipUtils.js.map +1 -1
  135. package/dist/localization/localize.d.ts +3 -0
  136. package/dist/localization/localize.js +1 -0
  137. package/dist/localization/localize.js.map +1 -1
  138. package/dist/localization/package.nls.en-us.json +2 -1
  139. package/dist/parser/parseNodes.d.ts +468 -401
  140. package/dist/parser/parseNodes.js +626 -355
  141. package/dist/parser/parseNodes.js.map +1 -1
  142. package/dist/parser/parser.d.ts +1 -0
  143. package/dist/parser/parser.js +322 -297
  144. package/dist/parser/parser.js.map +1 -1
  145. package/dist/pyright.js +265 -5
  146. package/dist/pyright.js.map +1 -1
  147. package/dist/tests/classDeclaration.test.js +14 -14
  148. package/dist/tests/classDeclaration.test.js.map +1 -1
  149. package/dist/tests/fourslash/hover.init.fourslash.js +1 -1
  150. package/dist/tests/fourslash/hover.init.fourslash.js.map +1 -1
  151. package/dist/tests/harness/vfs/filesystem.d.ts +3 -2
  152. package/dist/tests/harness/vfs/filesystem.js +6 -2
  153. package/dist/tests/harness/vfs/filesystem.js.map +1 -1
  154. package/dist/tests/importResolver.test.js +4 -3
  155. package/dist/tests/importResolver.test.js.map +1 -1
  156. package/dist/tests/parseTreeUtils.test.js +5 -5
  157. package/dist/tests/parseTreeUtils.test.js.map +1 -1
  158. package/dist/tests/parser.test.js +8 -8
  159. package/dist/tests/parser.test.js.map +1 -1
  160. package/dist/tests/sourceMapperUtils.test.js +7 -7
  161. package/dist/tests/sourceMapperUtils.test.js.map +1 -1
  162. package/dist/tests/typeEvaluator2.test.js +2 -2
  163. package/dist/tests/typeEvaluator3.test.js +10 -5
  164. package/dist/tests/typeEvaluator3.test.js.map +1 -1
  165. package/dist/tests/typeEvaluator4.test.js +1 -1
  166. package/dist/tests/typeEvaluator7.test.js +2 -2
  167. package/dist/tests/typeEvaluator7.test.js.map +1 -1
  168. package/dist/tests/typePrinter.test.js +14 -39
  169. package/dist/tests/typePrinter.test.js.map +1 -1
  170. package/package.json +1 -1
@@ -114,8 +114,8 @@ function findNodeByOffset(node, offset) {
114
114
  if (containingChild) {
115
115
  // For augmented assignments, prefer the dest expression, which is a clone
116
116
  // of the left expression but is used to hold the type of the operation result.
117
- if (node.nodeType === 5 /* ParseNodeType.AugmentedAssignment */ && containingChild === node.leftExpression) {
118
- return node.destExpression;
117
+ if (node.nodeType === 5 /* ParseNodeType.AugmentedAssignment */ && containingChild === node.d.leftExpr) {
118
+ return node.d.destExpr;
119
119
  }
120
120
  return containingChild;
121
121
  }
@@ -138,7 +138,7 @@ function getClassFullName(classNode, moduleName, className) {
138
138
  while (curNode) {
139
139
  curNode = getEnclosingClass(curNode);
140
140
  if (curNode) {
141
- nameParts.push(curNode.name.value);
141
+ nameParts.push(curNode.d.name.d.value);
142
142
  }
143
143
  }
144
144
  nameParts.push(moduleName);
@@ -155,74 +155,74 @@ function getTypeSourceId(node) {
155
155
  exports.getTypeSourceId = getTypeSourceId;
156
156
  function printArgument(node, flags) {
157
157
  let argStr = '';
158
- if (node.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
158
+ if (node.d.argCategory === 1 /* ArgumentCategory.UnpackedList */) {
159
159
  argStr = '*';
160
160
  }
161
- else if (node.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
161
+ else if (node.d.argCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
162
162
  argStr = '**';
163
163
  }
164
- if (node.name) {
165
- argStr += node.name.value + '=';
164
+ if (node.d.name) {
165
+ argStr += node.d.name.d.value + '=';
166
166
  }
167
- argStr += printExpression(node.valueExpression, flags);
167
+ argStr += printExpression(node.d.valueExpr, flags);
168
168
  return argStr;
169
169
  }
170
170
  exports.printArgument = printArgument;
171
171
  function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
172
172
  switch (node.nodeType) {
173
173
  case 38 /* ParseNodeType.Name */: {
174
- return node.value;
174
+ return node.d.value;
175
175
  }
176
176
  case 35 /* ParseNodeType.MemberAccess */: {
177
- return printExpression(node.leftExpression, flags) + '.' + node.memberName.value;
177
+ return printExpression(node.d.leftExpr, flags) + '.' + node.d.member.d.value;
178
178
  }
179
179
  case 9 /* ParseNodeType.Call */: {
180
- let lhs = printExpression(node.leftExpression, flags);
180
+ let lhs = printExpression(node.d.leftExpr, flags);
181
181
  // Some left-hand expressions must be parenthesized.
182
- if (node.leftExpression.nodeType !== 35 /* ParseNodeType.MemberAccess */ &&
183
- node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ &&
184
- node.leftExpression.nodeType !== 27 /* ParseNodeType.Index */ &&
185
- node.leftExpression.nodeType !== 9 /* ParseNodeType.Call */) {
182
+ if (node.d.leftExpr.nodeType !== 35 /* ParseNodeType.MemberAccess */ &&
183
+ node.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */ &&
184
+ node.d.leftExpr.nodeType !== 27 /* ParseNodeType.Index */ &&
185
+ node.d.leftExpr.nodeType !== 9 /* ParseNodeType.Call */) {
186
186
  lhs = `(${lhs})`;
187
187
  }
188
- return lhs + '(' + node.arguments.map((arg) => printArgument(arg, flags)).join(', ') + ')';
188
+ return lhs + '(' + node.d.args.map((arg) => printArgument(arg, flags)).join(', ') + ')';
189
189
  }
190
190
  case 27 /* ParseNodeType.Index */: {
191
- return (printExpression(node.baseExpression, flags) +
191
+ return (printExpression(node.d.leftExpr, flags) +
192
192
  '[' +
193
- node.items.map((item) => printArgument(item, flags)).join(', ') +
194
- (node.trailingComma ? ',' : '') +
193
+ node.d.items.map((item) => printArgument(item, flags)).join(', ') +
194
+ (node.d.trailingComma ? ',' : '') +
195
195
  ']');
196
196
  }
197
197
  case 55 /* ParseNodeType.UnaryOperation */: {
198
- const exprStr = printOperator(node.operator) + printExpression(node.expression, flags);
199
- return node.parenthesized ? `(${exprStr})` : exprStr;
198
+ const exprStr = printOperator(node.d.operator) + printExpression(node.d.expr, flags);
199
+ return node.d.hasParens ? `(${exprStr})` : exprStr;
200
200
  }
201
201
  case 7 /* ParseNodeType.BinaryOperation */: {
202
- const exprStr = printExpression(node.leftExpression, flags) +
202
+ const exprStr = printExpression(node.d.leftExpr, flags) +
203
203
  ' ' +
204
- printOperator(node.operator) +
204
+ printOperator(node.d.operator) +
205
205
  ' ' +
206
- printExpression(node.rightExpression, flags);
207
- return node.parenthesized ? `(${exprStr})` : exprStr;
206
+ printExpression(node.d.rightExpr, flags);
207
+ return node.d.hasParens ? `(${exprStr})` : exprStr;
208
208
  }
209
209
  case 40 /* ParseNodeType.Number */: {
210
- let value = node.value.toString();
210
+ let value = node.d.value.toString();
211
211
  // If it's stored as a bigint, strip off the "n".
212
212
  if (value.endsWith('n')) {
213
213
  value = value.substring(0, value.length - 1);
214
214
  }
215
- if (node.isImaginary) {
215
+ if (node.d.isImaginary) {
216
216
  value += 'j';
217
217
  }
218
218
  return value;
219
219
  }
220
220
  case 48 /* ParseNodeType.StringList */: {
221
- if (flags & 1 /* PrintExpressionFlags.ForwardDeclarations */ && node.typeAnnotation) {
222
- return printExpression(node.typeAnnotation, flags);
221
+ if (flags & 1 /* PrintExpressionFlags.ForwardDeclarations */ && node.d.annotation) {
222
+ return printExpression(node.d.annotation, flags);
223
223
  }
224
224
  else {
225
- return node.strings
225
+ return node.d.strings
226
226
  .map((str) => {
227
227
  return printExpression(str, flags);
228
228
  })
@@ -231,25 +231,25 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
231
231
  }
232
232
  case 49 /* ParseNodeType.String */: {
233
233
  let exprString = '';
234
- if (node.token.flags & 8 /* StringTokenFlags.Raw */) {
234
+ if (node.d.token.flags & 8 /* StringTokenFlags.Raw */) {
235
235
  exprString += 'r';
236
236
  }
237
- if (node.token.flags & 16 /* StringTokenFlags.Unicode */) {
237
+ if (node.d.token.flags & 16 /* StringTokenFlags.Unicode */) {
238
238
  exprString += 'u';
239
239
  }
240
- if (node.token.flags & 32 /* StringTokenFlags.Bytes */) {
240
+ if (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) {
241
241
  exprString += 'b';
242
242
  }
243
- if (node.token.flags & 64 /* StringTokenFlags.Format */) {
243
+ if (node.d.token.flags & 64 /* StringTokenFlags.Format */) {
244
244
  exprString += 'f';
245
245
  }
246
- let escapedString = node.token.escapedValue;
246
+ let escapedString = node.d.token.escapedValue;
247
247
  if ((flags & 2 /* PrintExpressionFlags.DoNotLimitStringLength */) === 0) {
248
248
  const maxStringLength = 32;
249
249
  escapedString = escapedString.slice(0, maxStringLength);
250
250
  }
251
- if (node.token.flags & 4 /* StringTokenFlags.Triplicate */) {
252
- if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
251
+ if (node.d.token.flags & 4 /* StringTokenFlags.Triplicate */) {
252
+ if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
253
253
  exprString += `'''${escapedString}'''`;
254
254
  }
255
255
  else {
@@ -257,7 +257,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
257
257
  }
258
258
  }
259
259
  else {
260
- if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
260
+ if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
261
261
  exprString += `'${escapedString}'`;
262
262
  }
263
263
  else {
@@ -269,7 +269,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
269
269
  case 30 /* ParseNodeType.FormatString */: {
270
270
  let exprString = 'f';
271
271
  let escapedString = '';
272
- const itemsToPrint = [...node.middleTokens, ...node.fieldExpressions].sort((a, b) => a.start - b.start);
272
+ const itemsToPrint = [...node.d.middleTokens, ...node.d.fieldExprs].sort((a, b) => a.start - b.start);
273
273
  while (itemsToPrint.length > 0) {
274
274
  const itemToPrint = itemsToPrint.shift();
275
275
  if ('nodeType' in itemToPrint) {
@@ -279,8 +279,8 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
279
279
  escapedString += itemToPrint.escapedValue;
280
280
  }
281
281
  }
282
- if (node.token.flags & 4 /* StringTokenFlags.Triplicate */) {
283
- if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
282
+ if (node.d.token.flags & 4 /* StringTokenFlags.Triplicate */) {
283
+ if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
284
284
  exprString += `'''${escapedString}'''`;
285
285
  }
286
286
  else {
@@ -288,7 +288,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
288
288
  }
289
289
  }
290
290
  else {
291
- if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
291
+ if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
292
292
  exprString += `'${escapedString}'`;
293
293
  }
294
294
  else {
@@ -298,43 +298,43 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
298
298
  return exprString;
299
299
  }
300
300
  case 3 /* ParseNodeType.Assignment */: {
301
- return printExpression(node.leftExpression, flags) + ' = ' + printExpression(node.rightExpression, flags);
301
+ return printExpression(node.d.leftExpr, flags) + ' = ' + printExpression(node.d.rightExpr, flags);
302
302
  }
303
303
  case 4 /* ParseNodeType.AssignmentExpression */: {
304
- return printExpression(node.name, flags) + ' := ' + printExpression(node.rightExpression, flags);
304
+ return printExpression(node.d.name, flags) + ' := ' + printExpression(node.d.rightExpr, flags);
305
305
  }
306
306
  case 54 /* ParseNodeType.TypeAnnotation */: {
307
- return printExpression(node.valueExpression, flags) + ': ' + printExpression(node.typeAnnotation, flags);
307
+ return printExpression(node.d.valueExpr, flags) + ': ' + printExpression(node.d.annotation, flags);
308
308
  }
309
309
  case 5 /* ParseNodeType.AugmentedAssignment */: {
310
- return (printExpression(node.leftExpression, flags) +
310
+ return (printExpression(node.d.leftExpr, flags) +
311
311
  ' ' +
312
- printOperator(node.operator) +
312
+ printOperator(node.d.operator) +
313
313
  ' ' +
314
- printExpression(node.rightExpression, flags));
314
+ printExpression(node.d.rightExpr, flags));
315
315
  }
316
316
  case 6 /* ParseNodeType.Await */: {
317
- const exprStr = 'await ' + printExpression(node.expression, flags);
318
- return node.parenthesized ? `(${exprStr})` : exprStr;
317
+ const exprStr = 'await ' + printExpression(node.d.expr, flags);
318
+ return node.d.hasParens ? `(${exprStr})` : exprStr;
319
319
  }
320
320
  case 51 /* ParseNodeType.Ternary */: {
321
- return (printExpression(node.ifExpression, flags) +
321
+ return (printExpression(node.d.ifExpr, flags) +
322
322
  ' if ' +
323
- printExpression(node.testExpression, flags) +
323
+ printExpression(node.d.testExpr, flags) +
324
324
  ' else ' +
325
- printExpression(node.elseExpression, flags));
325
+ printExpression(node.d.elseExpr, flags));
326
326
  }
327
327
  case 34 /* ParseNodeType.List */: {
328
- const expressions = node.entries.map((expr) => {
328
+ const expressions = node.d.items.map((expr) => {
329
329
  return printExpression(expr, flags);
330
330
  });
331
331
  return `[${expressions.join(', ')}]`;
332
332
  }
333
333
  case 56 /* ParseNodeType.Unpack */: {
334
- return '*' + printExpression(node.expression, flags);
334
+ return '*' + printExpression(node.d.expr, flags);
335
335
  }
336
336
  case 52 /* ParseNodeType.Tuple */: {
337
- const expressions = node.expressions.map((expr) => {
337
+ const expressions = node.d.items.map((expr) => {
338
338
  return printExpression(expr, flags);
339
339
  });
340
340
  if (expressions.length === 1) {
@@ -343,57 +343,57 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
343
343
  return `(${expressions.join(', ')})`;
344
344
  }
345
345
  case 60 /* ParseNodeType.Yield */: {
346
- if (node.expression) {
347
- return 'yield ' + printExpression(node.expression, flags);
346
+ if (node.d.expr) {
347
+ return 'yield ' + printExpression(node.d.expr, flags);
348
348
  }
349
349
  else {
350
350
  return 'yield';
351
351
  }
352
352
  }
353
353
  case 61 /* ParseNodeType.YieldFrom */: {
354
- return 'yield from ' + printExpression(node.expression, flags);
354
+ return 'yield from ' + printExpression(node.d.expr, flags);
355
355
  }
356
356
  case 21 /* ParseNodeType.Ellipsis */: {
357
357
  return '...';
358
358
  }
359
359
  case 11 /* ParseNodeType.Comprehension */: {
360
360
  let listStr = '<ListExpression>';
361
- if ((0, parseNodes_1.isExpressionNode)(node.expression)) {
362
- listStr = printExpression(node.expression, flags);
361
+ if ((0, parseNodes_1.isExpressionNode)(node.d.expr)) {
362
+ listStr = printExpression(node.d.expr, flags);
363
363
  }
364
- else if (node.expression.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
365
- const keyStr = printExpression(node.expression.keyExpression, flags);
366
- const valueStr = printExpression(node.expression.valueExpression, flags);
364
+ else if (node.d.expr.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
365
+ const keyStr = printExpression(node.d.expr.d.keyExpr, flags);
366
+ const valueStr = printExpression(node.d.expr.d.valueExpr, flags);
367
367
  listStr = `${keyStr}: ${valueStr}`;
368
368
  }
369
369
  listStr =
370
370
  listStr +
371
371
  ' ' +
372
- node.forIfNodes
372
+ node.d.forIfNodes
373
373
  .map((expr) => {
374
374
  if (expr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
375
- return (`${expr.isAsync ? 'async ' : ''}for ` +
376
- printExpression(expr.targetExpression, flags) +
377
- ` in ${printExpression(expr.iterableExpression, flags)}`);
375
+ return (`${expr.d.isAsync ? 'async ' : ''}for ` +
376
+ printExpression(expr.d.targetExpr, flags) +
377
+ ` in ${printExpression(expr.d.iterableExpr, flags)}`);
378
378
  }
379
379
  else {
380
- return `if ${printExpression(expr.testExpression, flags)}`;
380
+ return `if ${printExpression(expr.d.testExpr, flags)}`;
381
381
  }
382
382
  })
383
383
  .join(' ');
384
- return node.isParenthesized ? `(${listStr})` : listStr;
384
+ return node.d.hasParens ? `(${listStr})` : listStr;
385
385
  }
386
386
  case 46 /* ParseNodeType.Slice */: {
387
387
  let result = '';
388
- if (node.startValue || node.endValue || node.stepValue) {
389
- if (node.startValue) {
390
- result += printExpression(node.startValue, flags);
388
+ if (node.d.startValue || node.d.endValue || node.d.stepValue) {
389
+ if (node.d.startValue) {
390
+ result += printExpression(node.d.startValue, flags);
391
391
  }
392
- if (node.endValue) {
393
- result += ': ' + printExpression(node.endValue, flags);
392
+ if (node.d.endValue) {
393
+ result += ': ' + printExpression(node.d.endValue, flags);
394
394
  }
395
- if (node.stepValue) {
396
- result += ': ' + printExpression(node.stepValue, flags);
395
+ if (node.d.stepValue) {
396
+ result += ': ' + printExpression(node.d.stepValue, flags);
397
397
  }
398
398
  }
399
399
  else {
@@ -403,53 +403,52 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
403
403
  }
404
404
  case 33 /* ParseNodeType.Lambda */: {
405
405
  return ('lambda ' +
406
- node.parameters
406
+ node.d.params
407
407
  .map((param) => {
408
408
  let paramStr = '';
409
- if (param.category === 1 /* ParameterCategory.ArgsList */) {
409
+ if (param.d.category === 1 /* ParameterCategory.ArgsList */) {
410
410
  paramStr += '*';
411
411
  }
412
- else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
412
+ else if (param.d.category === 2 /* ParameterCategory.KwargsDict */) {
413
413
  paramStr += '**';
414
414
  }
415
- if (param.name) {
416
- paramStr += param.name.value;
415
+ if (param.d.name) {
416
+ paramStr += param.d.name.d.value;
417
417
  }
418
- else if (param.category === 0 /* ParameterCategory.Simple */) {
418
+ else if (param.d.category === 0 /* ParameterCategory.Simple */) {
419
419
  paramStr += '/';
420
420
  }
421
- if (param.defaultValue) {
422
- paramStr += ' = ' + printExpression(param.defaultValue, flags);
421
+ if (param.d.defaultValue) {
422
+ paramStr += ' = ' + printExpression(param.d.defaultValue, flags);
423
423
  }
424
424
  return paramStr;
425
425
  })
426
426
  .join(', ') +
427
427
  ': ' +
428
- printExpression(node.expression, flags));
428
+ printExpression(node.d.expr, flags));
429
429
  }
430
430
  case 14 /* ParseNodeType.Constant */: {
431
- if (node.constType === 33 /* KeywordType.True */) {
431
+ if (node.d.constType === 33 /* KeywordType.True */) {
432
432
  return 'True';
433
433
  }
434
- else if (node.constType === 15 /* KeywordType.False */) {
434
+ else if (node.d.constType === 15 /* KeywordType.False */) {
435
435
  return 'False';
436
436
  }
437
- else if (node.constType === 9 /* KeywordType.Debug */) {
437
+ else if (node.d.constType === 9 /* KeywordType.Debug */) {
438
438
  return '__debug__';
439
439
  }
440
- else if (node.constType === 26 /* KeywordType.None */) {
440
+ else if (node.d.constType === 26 /* KeywordType.None */) {
441
441
  return 'None';
442
442
  }
443
443
  break;
444
444
  }
445
445
  case 18 /* ParseNodeType.Dictionary */: {
446
- const dictContents = `${node.entries.map((entry) => {
446
+ const dictContents = `${node.d.items.map((entry) => {
447
447
  if (entry.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
448
- return (`${printExpression(entry.keyExpression, flags)}: ` +
449
- `${printExpression(entry.valueExpression, flags)}`);
448
+ return (`${printExpression(entry.d.keyExpr, flags)}: ` + `${printExpression(entry.d.valueExpr, flags)}`);
450
449
  }
451
450
  else if (entry.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
452
- return `**${printExpression(entry.expandExpression, flags)}`;
451
+ return `**${printExpression(entry.d.expr, flags)}`;
453
452
  }
454
453
  else {
455
454
  return printExpression(entry, flags);
@@ -461,7 +460,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
461
460
  return '{}';
462
461
  }
463
462
  case 45 /* ParseNodeType.Set */: {
464
- return node.entries.map((entry) => printExpression(entry, flags)).join(', ');
463
+ return node.d.items.map((entry) => printExpression(entry, flags)).join(', ');
465
464
  }
466
465
  case 0 /* ParseNodeType.Error */: {
467
466
  return '<Parse Error>';
@@ -528,13 +527,13 @@ exports.printOperator = printOperator;
528
527
  // name in the LHS of a call expression, returns the call node.
529
528
  function getCallForName(node) {
530
529
  var _a, _b, _c;
531
- if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */ && node.parent.leftExpression === node) {
530
+ if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */ && node.parent.d.leftExpr === node) {
532
531
  return node.parent;
533
532
  }
534
533
  if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
535
- node.parent.memberName === node &&
534
+ node.parent.d.member === node &&
536
535
  ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 9 /* ParseNodeType.Call */ &&
537
- node.parent.parent.leftExpression === node.parent) {
536
+ node.parent.parent.d.leftExpr === node.parent) {
538
537
  return node.parent.parent;
539
538
  }
540
539
  return undefined;
@@ -542,13 +541,13 @@ function getCallForName(node) {
542
541
  exports.getCallForName = getCallForName;
543
542
  function getDecoratorForName(node) {
544
543
  var _a, _b, _c;
545
- if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 16 /* ParseNodeType.Decorator */ && node.parent.expression === node) {
544
+ if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 16 /* ParseNodeType.Decorator */ && node.parent.d.expr === node) {
546
545
  return node.parent;
547
546
  }
548
547
  if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
549
- node.parent.memberName === node &&
548
+ node.parent.d.member === node &&
550
549
  ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 16 /* ParseNodeType.Decorator */ &&
551
- node.parent.parent.expression === node.parent) {
550
+ node.parent.parent.d.expr === node.parent) {
552
551
  return node.parent.parent;
553
552
  }
554
553
  return undefined;
@@ -621,7 +620,7 @@ function getEnclosingFunction(node) {
621
620
  while (curNode) {
622
621
  if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
623
622
  // Don't treat a decorator as being "enclosed" in the function.
624
- if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
623
+ if (!curNode.d.decorators.some((decorator) => decorator === prevNode)) {
625
624
  return curNode;
626
625
  }
627
626
  }
@@ -740,11 +739,11 @@ function getEvaluationScopeNode(node) {
740
739
  let isParamDefaultNode = false;
741
740
  while (curNode) {
742
741
  if (curNode.nodeType === 41 /* ParseNodeType.Parameter */) {
743
- if (prevNode === curNode.name) {
742
+ if (prevNode === curNode.d.name) {
744
743
  // Note that we passed through a parameter name node.
745
744
  isParamNameNode = true;
746
745
  }
747
- else if (prevNode === curNode.defaultValue) {
746
+ else if (prevNode === curNode.d.defaultValue) {
748
747
  // Note that we passed through a parameter default value node.
749
748
  isParamDefaultNode = true;
750
749
  }
@@ -761,10 +760,10 @@ function getEvaluationScopeNode(node) {
761
760
  break;
762
761
  }
763
762
  // Decorators are always evaluated outside of the function scope.
764
- if (curNode.decorators.some((decorator) => decorator === prevNode)) {
763
+ if (curNode.d.decorators.some((decorator) => decorator === prevNode)) {
765
764
  break;
766
765
  }
767
- if (curNode.parameters.some((param) => param === prevNode)) {
766
+ if (curNode.d.params.some((param) => param === prevNode)) {
768
767
  // Default argument expressions are evaluated outside of the function scope.
769
768
  if (isParamDefaultNode) {
770
769
  break;
@@ -775,7 +774,7 @@ function getEvaluationScopeNode(node) {
775
774
  }
776
775
  }
777
776
  }
778
- if (prevNode === curNode.suite) {
777
+ if (prevNode === curNode.d.suite) {
779
778
  if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
780
779
  return { node: curNode };
781
780
  }
@@ -783,8 +782,8 @@ function getEvaluationScopeNode(node) {
783
782
  // All other nodes in the function are evaluated in the context
784
783
  // of the type parameter scope if it's present. Otherwise,
785
784
  // they are evaluated within the function's parent scope.
786
- if (curNode.typeParameters) {
787
- const scopeNode = curNode.typeParameters;
785
+ if (curNode.d.typeParams) {
786
+ const scopeNode = curNode.d.typeParams;
788
787
  if ((0, analyzerNodeInfo_1.getScope)(scopeNode) !== undefined) {
789
788
  return { node: scopeNode, useProxyScope: true };
790
789
  }
@@ -792,14 +791,14 @@ function getEvaluationScopeNode(node) {
792
791
  break;
793
792
  }
794
793
  case 33 /* ParseNodeType.Lambda */: {
795
- if (curNode.parameters.some((param) => param === prevNode)) {
794
+ if (curNode.d.params.some((param) => param === prevNode)) {
796
795
  if (isParamNameNode) {
797
796
  if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
798
797
  return { node: curNode };
799
798
  }
800
799
  }
801
800
  }
802
- else if (!prevNode || prevNode === curNode.expression) {
801
+ else if (!prevNode || prevNode === curNode.d.expr) {
803
802
  if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
804
803
  return { node: curNode };
805
804
  }
@@ -811,10 +810,10 @@ function getEvaluationScopeNode(node) {
811
810
  break;
812
811
  }
813
812
  // Decorators are always evaluated outside of the class scope.
814
- if (curNode.decorators.some((decorator) => decorator === prevNode)) {
813
+ if (curNode.d.decorators.some((decorator) => decorator === prevNode)) {
815
814
  break;
816
815
  }
817
- if (prevNode === curNode.suite) {
816
+ if (prevNode === curNode.d.suite) {
818
817
  if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
819
818
  return { node: curNode };
820
819
  }
@@ -822,8 +821,8 @@ function getEvaluationScopeNode(node) {
822
821
  // All other nodes in the class are evaluated in the context
823
822
  // of the type parameter scope if it's present. Otherwise,
824
823
  // they are evaluated within the class' parent scope.
825
- if (curNode.typeParameters) {
826
- const scopeNode = curNode.typeParameters;
824
+ if (curNode.d.typeParams) {
825
+ const scopeNode = curNode.d.typeParams;
827
826
  if ((0, analyzerNodeInfo_1.getScope)(scopeNode) !== undefined) {
828
827
  return { node: scopeNode, useProxyScope: true };
829
828
  }
@@ -834,9 +833,9 @@ function getEvaluationScopeNode(node) {
834
833
  if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
835
834
  // The iterable expression of the first subnode of a list comprehension
836
835
  // is evaluated within the scope of its parent.
837
- const isFirstIterableExpr = prevNode === curNode.forIfNodes[0] &&
838
- curNode.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */ &&
839
- curNode.forIfNodes[0].iterableExpression === prevPrevNode;
836
+ const isFirstIterableExpr = prevNode === curNode.d.forIfNodes[0] &&
837
+ curNode.d.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */ &&
838
+ curNode.d.forIfNodes[0].d.iterableExpr === prevPrevNode;
840
839
  if (!isFirstIterableExpr) {
841
840
  return { node: curNode };
842
841
  }
@@ -844,8 +843,8 @@ function getEvaluationScopeNode(node) {
844
843
  break;
845
844
  }
846
845
  case 77 /* ParseNodeType.TypeAlias */: {
847
- if (prevNode === curNode.expression && curNode.typeParameters) {
848
- const scopeNode = curNode.typeParameters;
846
+ if (prevNode === curNode.d.expr && curNode.d.typeParams) {
847
+ const scopeNode = curNode.d.typeParams;
849
848
  if ((0, analyzerNodeInfo_1.getScope)(scopeNode) !== undefined) {
850
849
  return { node: scopeNode };
851
850
  }
@@ -875,13 +874,13 @@ function getTypeVarScopeNode(node) {
875
874
  while (curNode) {
876
875
  switch (curNode.nodeType) {
877
876
  case 31 /* ParseNodeType.Function */: {
878
- if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
877
+ if (!curNode.d.decorators.some((decorator) => decorator === prevNode)) {
879
878
  return curNode;
880
879
  }
881
880
  break;
882
881
  }
883
882
  case 10 /* ParseNodeType.Class */: {
884
- if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
883
+ if (!curNode.d.decorators.some((decorator) => decorator === prevNode)) {
885
884
  return curNode;
886
885
  }
887
886
  break;
@@ -917,7 +916,7 @@ function getTypeAnnotationNode(node) {
917
916
  let curNode = node.parent;
918
917
  while (curNode) {
919
918
  if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
920
- if (curNode.typeAnnotation === prevNode) {
919
+ if (curNode.d.annotation === prevNode) {
921
920
  return curNode;
922
921
  }
923
922
  break;
@@ -932,8 +931,8 @@ exports.getTypeAnnotationNode = getTypeAnnotationNode;
932
931
  // left-to-right order. There is one exception, however, when an unpacked
933
932
  // iterable is used after a keyword argument.
934
933
  function getArgumentsByRuntimeOrder(node) {
935
- const positionalArgs = node.arguments.filter((arg) => !arg.name && arg.argumentCategory !== 2 /* ArgumentCategory.UnpackedDictionary */);
936
- const keywordArgs = node.arguments.filter((arg) => !!arg.name || arg.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */);
934
+ const positionalArgs = node.d.args.filter((arg) => !arg.d.name && arg.d.argCategory !== 2 /* ArgumentCategory.UnpackedDictionary */);
935
+ const keywordArgs = node.d.args.filter((arg) => !!arg.d.name || arg.d.argCategory === 2 /* ArgumentCategory.UnpackedDictionary */);
937
936
  return positionalArgs.concat(keywordArgs);
938
937
  }
939
938
  exports.getArgumentsByRuntimeOrder = getArgumentsByRuntimeOrder;
@@ -948,7 +947,7 @@ function isFinalAllowedForAssignmentTarget(targetNode) {
948
947
  // Member access expressions like "self.x" are permitted only
949
948
  // within __init__ methods.
950
949
  if (targetNode.nodeType === 35 /* ParseNodeType.MemberAccess */) {
951
- if (targetNode.leftExpression.nodeType !== 38 /* ParseNodeType.Name */) {
950
+ if (targetNode.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */) {
952
951
  return false;
953
952
  }
954
953
  const classNode = getEnclosingClass(targetNode);
@@ -959,7 +958,7 @@ function isFinalAllowedForAssignmentTarget(targetNode) {
959
958
  if (!methodNode) {
960
959
  return false;
961
960
  }
962
- if (methodNode.name.value !== '__init__') {
961
+ if (methodNode.d.name.d.value !== '__init__') {
963
962
  return false;
964
963
  }
965
964
  return true;
@@ -1012,31 +1011,31 @@ function getParentAnnotationNode(node) {
1012
1011
  let prevNode;
1013
1012
  while (curNode) {
1014
1013
  if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
1015
- if (prevNode === curNode.returnTypeAnnotation) {
1014
+ if (prevNode === curNode.d.returnAnnotation) {
1016
1015
  return prevNode;
1017
1016
  }
1018
1017
  return undefined;
1019
1018
  }
1020
1019
  if (curNode.nodeType === 41 /* ParseNodeType.Parameter */) {
1021
- if (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment) {
1020
+ if (prevNode === curNode.d.annotation || prevNode === curNode.d.annotationComment) {
1022
1021
  return prevNode;
1023
1022
  }
1024
1023
  return undefined;
1025
1024
  }
1026
1025
  if (curNode.nodeType === 3 /* ParseNodeType.Assignment */) {
1027
- if (prevNode === curNode.typeAnnotationComment) {
1026
+ if (prevNode === curNode.d.annotationComment) {
1028
1027
  return prevNode;
1029
1028
  }
1030
1029
  return undefined;
1031
1030
  }
1032
1031
  if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
1033
- if (prevNode === curNode.typeAnnotation) {
1032
+ if (prevNode === curNode.d.annotation) {
1034
1033
  return prevNode;
1035
1034
  }
1036
1035
  return undefined;
1037
1036
  }
1038
1037
  if (curNode.nodeType === 62 /* ParseNodeType.FunctionAnnotation */) {
1039
- if (prevNode === curNode.returnTypeAnnotation || curNode.paramTypeAnnotations.some((p) => p === prevNode)) {
1038
+ if (prevNode === curNode.d.returnAnnotation || curNode.d.paramAnnotations.some((p) => p === prevNode)) {
1040
1039
  (0, debug_1.assert)(!prevNode || (0, parseNodes_1.isExpressionNode)(prevNode));
1041
1040
  return prevNode;
1042
1041
  }
@@ -1054,9 +1053,9 @@ function isNodeContainedWithinNodeType(node, containerType) {
1054
1053
  exports.isNodeContainedWithinNodeType = isNodeContainedWithinNodeType;
1055
1054
  function isSuiteEmpty(node) {
1056
1055
  let sawEllipsis = false;
1057
- for (const statement of node.statements) {
1056
+ for (const statement of node.d.statements) {
1058
1057
  if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
1059
- for (const substatement of statement.statements) {
1058
+ for (const substatement of statement.d.statements) {
1060
1059
  if (substatement.nodeType === 21 /* ParseNodeType.Ellipsis */) {
1061
1060
  // Allow an ellipsis
1062
1061
  sawEllipsis = true;
@@ -1092,60 +1091,60 @@ exports.containsAwaitNode = containsAwaitNode;
1092
1091
  function isMatchingExpression(reference, expression) {
1093
1092
  if (reference.nodeType === 38 /* ParseNodeType.Name */) {
1094
1093
  if (expression.nodeType === 38 /* ParseNodeType.Name */) {
1095
- return reference.value === expression.value;
1094
+ return reference.d.value === expression.d.value;
1096
1095
  }
1097
1096
  else if (expression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
1098
- return reference.value === expression.name.value;
1097
+ return reference.d.value === expression.d.name.d.value;
1099
1098
  }
1100
1099
  return false;
1101
1100
  }
1102
1101
  else if (reference.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
1103
1102
  expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
1104
- return (isMatchingExpression(reference.leftExpression, expression.leftExpression) &&
1105
- reference.memberName.value === expression.memberName.value);
1103
+ return (isMatchingExpression(reference.d.leftExpr, expression.d.leftExpr) &&
1104
+ reference.d.member.d.value === expression.d.member.d.value);
1106
1105
  }
1107
1106
  else if (reference.nodeType === 27 /* ParseNodeType.Index */ && expression.nodeType === 27 /* ParseNodeType.Index */) {
1108
- if (!isMatchingExpression(reference.baseExpression, expression.baseExpression)) {
1107
+ if (!isMatchingExpression(reference.d.leftExpr, expression.d.leftExpr)) {
1109
1108
  return false;
1110
1109
  }
1111
- if (expression.items.length !== 1 ||
1112
- expression.trailingComma ||
1113
- expression.items[0].name ||
1114
- expression.items[0].argumentCategory !== 0 /* ArgumentCategory.Simple */) {
1110
+ if (expression.d.items.length !== 1 ||
1111
+ expression.d.trailingComma ||
1112
+ expression.d.items[0].d.name ||
1113
+ expression.d.items[0].d.argCategory !== 0 /* ArgumentCategory.Simple */) {
1115
1114
  return false;
1116
1115
  }
1117
- const expr = reference.items[0].valueExpression;
1116
+ const expr = reference.d.items[0].d.valueExpr;
1118
1117
  if (expr.nodeType === 40 /* ParseNodeType.Number */) {
1119
- const subscriptNode = expression.items[0].valueExpression;
1118
+ const subscriptNode = expression.d.items[0].d.valueExpr;
1120
1119
  if (subscriptNode.nodeType !== 40 /* ParseNodeType.Number */ ||
1121
- subscriptNode.isImaginary ||
1122
- !subscriptNode.isInteger) {
1120
+ subscriptNode.d.isImaginary ||
1121
+ !subscriptNode.d.isInteger) {
1123
1122
  return false;
1124
1123
  }
1125
- return expr.value === subscriptNode.value;
1124
+ return expr.d.value === subscriptNode.d.value;
1126
1125
  }
1127
1126
  if (expr.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
1128
- expr.operator === 33 /* OperatorType.Subtract */ &&
1129
- expr.expression.nodeType === 40 /* ParseNodeType.Number */) {
1130
- const subscriptNode = expression.items[0].valueExpression;
1127
+ expr.d.operator === 33 /* OperatorType.Subtract */ &&
1128
+ expr.d.expr.nodeType === 40 /* ParseNodeType.Number */) {
1129
+ const subscriptNode = expression.d.items[0].d.valueExpr;
1131
1130
  if (subscriptNode.nodeType !== 55 /* ParseNodeType.UnaryOperation */ ||
1132
- subscriptNode.operator !== 33 /* OperatorType.Subtract */ ||
1133
- subscriptNode.expression.nodeType !== 40 /* ParseNodeType.Number */ ||
1134
- subscriptNode.expression.isImaginary ||
1135
- !subscriptNode.expression.isInteger) {
1131
+ subscriptNode.d.operator !== 33 /* OperatorType.Subtract */ ||
1132
+ subscriptNode.d.expr.nodeType !== 40 /* ParseNodeType.Number */ ||
1133
+ subscriptNode.d.expr.d.isImaginary ||
1134
+ !subscriptNode.d.expr.d.isInteger) {
1136
1135
  return false;
1137
1136
  }
1138
- return expr.expression.value === subscriptNode.expression.value;
1137
+ return expr.d.expr.d.value === subscriptNode.d.expr.d.value;
1139
1138
  }
1140
1139
  if (expr.nodeType === 48 /* ParseNodeType.StringList */) {
1141
1140
  const referenceStringListNode = expr;
1142
- const subscriptNode = expression.items[0].valueExpression;
1143
- if (referenceStringListNode.strings.length === 1 &&
1144
- referenceStringListNode.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
1141
+ const subscriptNode = expression.d.items[0].d.valueExpr;
1142
+ if (referenceStringListNode.d.strings.length === 1 &&
1143
+ referenceStringListNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
1145
1144
  subscriptNode.nodeType === 48 /* ParseNodeType.StringList */ &&
1146
- subscriptNode.strings.length === 1 &&
1147
- subscriptNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
1148
- return referenceStringListNode.strings[0].value === subscriptNode.strings[0].value;
1145
+ subscriptNode.d.strings.length === 1 &&
1146
+ subscriptNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
1147
+ return referenceStringListNode.d.strings[0].d.value === subscriptNode.d.strings[0].d.value;
1149
1148
  }
1150
1149
  }
1151
1150
  return false;
@@ -1155,12 +1154,12 @@ function isMatchingExpression(reference, expression) {
1155
1154
  exports.isMatchingExpression = isMatchingExpression;
1156
1155
  function isPartialMatchingExpression(reference, expression) {
1157
1156
  if (reference.nodeType === 35 /* ParseNodeType.MemberAccess */) {
1158
- return (isMatchingExpression(reference.leftExpression, expression) ||
1159
- isPartialMatchingExpression(reference.leftExpression, expression));
1157
+ return (isMatchingExpression(reference.d.leftExpr, expression) ||
1158
+ isPartialMatchingExpression(reference.d.leftExpr, expression));
1160
1159
  }
1161
1160
  else if (reference.nodeType === 27 /* ParseNodeType.Index */) {
1162
- return (isMatchingExpression(reference.baseExpression, expression) ||
1163
- isPartialMatchingExpression(reference.baseExpression, expression));
1161
+ return (isMatchingExpression(reference.d.leftExpr, expression) ||
1162
+ isPartialMatchingExpression(reference.d.leftExpr, expression));
1164
1163
  }
1165
1164
  return false;
1166
1165
  }
@@ -1169,7 +1168,7 @@ function isWithinDefaultParamInitializer(node) {
1169
1168
  let curNode = node;
1170
1169
  let prevNode;
1171
1170
  while (curNode) {
1172
- if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ && prevNode === curNode.defaultValue) {
1171
+ if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ && prevNode === curNode.d.defaultValue) {
1173
1172
  return true;
1174
1173
  }
1175
1174
  if (curNode.nodeType === 33 /* ParseNodeType.Lambda */ ||
@@ -1190,26 +1189,26 @@ function isWithinTypeAnnotation(node, requireQuotedAnnotation) {
1190
1189
  let isQuoted = false;
1191
1190
  while (curNode) {
1192
1191
  if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ &&
1193
- (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment)) {
1192
+ (prevNode === curNode.d.annotation || prevNode === curNode.d.annotationComment)) {
1194
1193
  return isQuoted || !requireQuotedAnnotation;
1195
1194
  }
1196
- if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.returnTypeAnnotation) {
1195
+ if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.d.returnAnnotation) {
1197
1196
  return isQuoted || !requireQuotedAnnotation;
1198
1197
  }
1199
- if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
1198
+ if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.d.funcAnnotationComment) {
1200
1199
  // Type comments are always considered forward declarations even though
1201
1200
  // they're not "quoted".
1202
1201
  return true;
1203
1202
  }
1204
- if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */ && prevNode === curNode.typeAnnotation) {
1203
+ if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */ && prevNode === curNode.d.annotation) {
1205
1204
  return isQuoted || !requireQuotedAnnotation;
1206
1205
  }
1207
- if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.typeAnnotationComment) {
1206
+ if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.d.annotationComment) {
1208
1207
  // Type comments are always considered forward declarations even though
1209
1208
  // they're not "quoted".
1210
1209
  return true;
1211
1210
  }
1212
- if (curNode.nodeType === 48 /* ParseNodeType.StringList */ && prevNode === curNode.typeAnnotation) {
1211
+ if (curNode.nodeType === 48 /* ParseNodeType.StringList */ && prevNode === curNode.d.annotation) {
1213
1212
  isQuoted = true;
1214
1213
  }
1215
1214
  if (curNode.nodeType === 33 /* ParseNodeType.Lambda */ ||
@@ -1228,12 +1227,12 @@ function isWithinAnnotationComment(node) {
1228
1227
  let curNode = node;
1229
1228
  let prevNode;
1230
1229
  while (curNode) {
1231
- if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
1230
+ if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.d.funcAnnotationComment) {
1232
1231
  // Type comments are always considered forward declarations even though
1233
1232
  // they're not "quoted".
1234
1233
  return true;
1235
1234
  }
1236
- if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.typeAnnotationComment) {
1235
+ if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.d.annotationComment) {
1237
1236
  // Type comments are always considered forward declarations even though
1238
1237
  // they're not "quoted".
1239
1238
  return true;
@@ -1273,7 +1272,7 @@ function isWithinAssertExpression(node) {
1273
1272
  while (curNode) {
1274
1273
  switch (curNode.nodeType) {
1275
1274
  case 2 /* ParseNodeType.Assert */: {
1276
- return curNode.testExpression === prevNode;
1275
+ return curNode.d.testExpr === prevNode;
1277
1276
  }
1278
1277
  }
1279
1278
  prevNode = curNode;
@@ -1294,21 +1293,22 @@ function getDocString(statements) {
1294
1293
  return undefined;
1295
1294
  }
1296
1295
  // It's up to the user to convert normalize/convert this as needed.
1297
- const strings = statements[0].statements[0].strings;
1296
+ const strings = statements[0].d.statements[0].d.strings;
1298
1297
  if (strings.length === 1) {
1299
- return strings[0].value;
1298
+ return strings[0].d.value;
1300
1299
  }
1301
- return strings.map((s) => s.value).join('');
1300
+ return strings.map((s) => s.d.value).join('');
1302
1301
  }
1303
1302
  exports.getDocString = getDocString;
1304
1303
  function isDocString(statementList) {
1305
1304
  // If the first statement in the suite isn't a StringNode,
1306
1305
  // assume there is no docString.
1307
- if (statementList.statements.length === 0 || statementList.statements[0].nodeType !== 48 /* ParseNodeType.StringList */) {
1306
+ if (statementList.d.statements.length === 0 ||
1307
+ statementList.d.statements[0].nodeType !== 48 /* ParseNodeType.StringList */) {
1308
1308
  return false;
1309
1309
  }
1310
1310
  // A docstring can consist of multiple joined strings in a single expression.
1311
- const strings = statementList.statements[0].strings;
1311
+ const strings = statementList.d.statements[0].d.strings;
1312
1312
  if (strings.length === 0) {
1313
1313
  return false;
1314
1314
  }
@@ -1330,44 +1330,44 @@ function isAssignmentToDefaultsFollowingNamedTuple(callNode) {
1330
1330
  if (callNode.nodeType !== 9 /* ParseNodeType.Call */ ||
1331
1331
  !callNode.parent ||
1332
1332
  callNode.parent.nodeType !== 3 /* ParseNodeType.Assignment */ ||
1333
- callNode.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
1333
+ callNode.parent.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */ ||
1334
1334
  !callNode.parent.parent ||
1335
1335
  callNode.parent.parent.nodeType !== 47 /* ParseNodeType.StatementList */) {
1336
1336
  return false;
1337
1337
  }
1338
- const namedTupleAssignedName = callNode.parent.leftExpression.value;
1338
+ const namedTupleAssignedName = callNode.parent.d.leftExpr.d.value;
1339
1339
  const statementList = callNode.parent.parent;
1340
- if (statementList.statements[0] !== callNode.parent ||
1340
+ if (statementList.d.statements[0] !== callNode.parent ||
1341
1341
  !statementList.parent ||
1342
1342
  !(statementList.parent.nodeType === 36 /* ParseNodeType.Module */ ||
1343
1343
  statementList.parent.nodeType === 50 /* ParseNodeType.Suite */)) {
1344
1344
  return false;
1345
1345
  }
1346
1346
  const moduleOrSuite = statementList.parent;
1347
- let statementIndex = moduleOrSuite.statements.findIndex((s) => s === statementList);
1347
+ let statementIndex = moduleOrSuite.d.statements.findIndex((s) => s === statementList);
1348
1348
  if (statementIndex < 0) {
1349
1349
  return false;
1350
1350
  }
1351
1351
  statementIndex++;
1352
- while (statementIndex < moduleOrSuite.statements.length) {
1353
- const nextStatement = moduleOrSuite.statements[statementIndex];
1352
+ while (statementIndex < moduleOrSuite.d.statements.length) {
1353
+ const nextStatement = moduleOrSuite.d.statements[statementIndex];
1354
1354
  if (nextStatement.nodeType !== 47 /* ParseNodeType.StatementList */) {
1355
1355
  break;
1356
1356
  }
1357
- if (((_a = nextStatement.statements[0]) === null || _a === void 0 ? void 0 : _a.nodeType) === 48 /* ParseNodeType.StringList */) {
1357
+ if (((_a = nextStatement.d.statements[0]) === null || _a === void 0 ? void 0 : _a.nodeType) === 48 /* ParseNodeType.StringList */) {
1358
1358
  // Skip over comments
1359
1359
  statementIndex++;
1360
1360
  continue;
1361
1361
  }
1362
- if (((_b = nextStatement.statements[0]) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */) {
1363
- const assignNode = nextStatement.statements[0];
1364
- if (assignNode.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
1365
- assignNode.leftExpression.memberName.value === '__defaults__') {
1366
- const defaultTarget = assignNode.leftExpression.leftExpression;
1362
+ if (((_b = nextStatement.d.statements[0]) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */) {
1363
+ const assignNode = nextStatement.d.statements[0];
1364
+ if (assignNode.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
1365
+ assignNode.d.leftExpr.d.member.d.value === '__defaults__') {
1366
+ const defaultTarget = assignNode.d.leftExpr.d.leftExpr;
1367
1367
  if (defaultTarget.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
1368
- defaultTarget.memberName.value === '__new__' &&
1369
- defaultTarget.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
1370
- defaultTarget.leftExpression.value === namedTupleAssignedName) {
1368
+ defaultTarget.d.member.d.value === '__new__' &&
1369
+ defaultTarget.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
1370
+ defaultTarget.d.leftExpr.d.value === namedTupleAssignedName) {
1371
1371
  return true;
1372
1372
  }
1373
1373
  }
@@ -1389,11 +1389,11 @@ class NameNodeWalker extends parseTreeWalker_1.ParseTreeWalker {
1389
1389
  return true;
1390
1390
  }
1391
1391
  visitIndex(node) {
1392
- this.walk(node.baseExpression);
1392
+ this.walk(node.d.leftExpr);
1393
1393
  const prevSubscriptIndex = this._subscriptIndex;
1394
1394
  const prevBaseExpression = this._baseExpression;
1395
- this._baseExpression = node.baseExpression;
1396
- node.items.forEach((item, index) => {
1395
+ this._baseExpression = node.d.leftExpr;
1396
+ node.d.items.forEach((item, index) => {
1397
1397
  this._subscriptIndex = index;
1398
1398
  this.walk(item);
1399
1399
  });
@@ -1442,7 +1442,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
1442
1442
  }
1443
1443
  curNode = curNode.parent;
1444
1444
  }
1445
- if (!callNode || !callNode.arguments) {
1445
+ if (!callNode || !callNode.d.args) {
1446
1446
  return undefined;
1447
1447
  }
1448
1448
  const endPosition = textRange_1.TextRange.getEnd(callNode);
@@ -1456,7 +1456,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
1456
1456
  let addedActive = false;
1457
1457
  let activeIndex = -1;
1458
1458
  let activeOrFake = false;
1459
- callNode.arguments.forEach((arg, index) => {
1459
+ callNode.d.args.forEach((arg, index) => {
1460
1460
  if (addedActive) {
1461
1461
  return;
1462
1462
  }
@@ -1491,7 +1491,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
1491
1491
  }
1492
1492
  });
1493
1493
  if (!addedActive) {
1494
- activeIndex = callNode.arguments.length + 1;
1494
+ activeIndex = callNode.d.args.length + 1;
1495
1495
  }
1496
1496
  return {
1497
1497
  callNode,
@@ -1499,15 +1499,15 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
1499
1499
  activeOrFake,
1500
1500
  };
1501
1501
  function isOffsetInsideCallArgs(tokens, node, offset) {
1502
- const argumentStart = node.leftExpression.length > 0 ? textRange_1.TextRange.getEnd(node.leftExpression) - 1 : node.leftExpression.start;
1502
+ const argumentStart = node.d.leftExpr.length > 0 ? textRange_1.TextRange.getEnd(node.d.leftExpr) - 1 : node.d.leftExpr.start;
1503
1503
  // Handle obvious case first.
1504
1504
  const callEndOffset = textRange_1.TextRange.getEnd(node);
1505
1505
  if (offset < argumentStart || callEndOffset < offset) {
1506
1506
  return false;
1507
1507
  }
1508
- if (node.arguments.length > 0) {
1509
- const start = node.arguments[0].start;
1510
- const end = textRange_1.TextRange.getEnd(node.arguments[node.arguments.length - 1]);
1508
+ if (node.d.args.length > 0) {
1509
+ const start = node.d.args[0].start;
1510
+ const end = textRange_1.TextRange.getEnd(node.d.args[node.d.args.length - 1]);
1511
1511
  if (start <= offset && offset < end) {
1512
1512
  return true;
1513
1513
  }
@@ -1786,44 +1786,44 @@ function isWriteAccess(node) {
1786
1786
  while (curNode) {
1787
1787
  switch (curNode.nodeType) {
1788
1788
  case 3 /* ParseNodeType.Assignment */: {
1789
- return prevNode === curNode.leftExpression;
1789
+ return prevNode === curNode.d.leftExpr;
1790
1790
  }
1791
1791
  case 5 /* ParseNodeType.AugmentedAssignment */: {
1792
- return prevNode === curNode.leftExpression;
1792
+ return prevNode === curNode.d.leftExpr;
1793
1793
  }
1794
1794
  case 4 /* ParseNodeType.AssignmentExpression */: {
1795
- return prevNode === curNode.name;
1795
+ return prevNode === curNode.d.name;
1796
1796
  }
1797
1797
  case 17 /* ParseNodeType.Del */: {
1798
1798
  return true;
1799
1799
  }
1800
1800
  case 29 /* ParseNodeType.For */: {
1801
- return prevNode === curNode.targetExpression;
1801
+ return prevNode === curNode.d.targetExpr;
1802
1802
  }
1803
1803
  case 24 /* ParseNodeType.ImportAs */: {
1804
- return (prevNode === curNode.alias ||
1805
- (curNode.module.nameParts.length > 0 && prevNode === curNode.module.nameParts[0]));
1804
+ return (prevNode === curNode.d.alias ||
1805
+ (curNode.d.module.d.nameParts.length > 0 && prevNode === curNode.d.module.d.nameParts[0]));
1806
1806
  }
1807
1807
  case 26 /* ParseNodeType.ImportFromAs */: {
1808
- return prevNode === curNode.alias || (!curNode.alias && prevNode === curNode.name);
1808
+ return prevNode === curNode.d.alias || (!curNode.d.alias && prevNode === curNode.d.name);
1809
1809
  }
1810
1810
  case 35 /* ParseNodeType.MemberAccess */: {
1811
- if (prevNode !== curNode.memberName) {
1811
+ if (prevNode !== curNode.d.member) {
1812
1812
  return false;
1813
1813
  }
1814
1814
  break;
1815
1815
  }
1816
1816
  case 28 /* ParseNodeType.Except */: {
1817
- return prevNode === curNode.name;
1817
+ return prevNode === curNode.d.name;
1818
1818
  }
1819
1819
  case 58 /* ParseNodeType.With */: {
1820
- return curNode.withItems.some((item) => item === prevNode);
1820
+ return curNode.d.withItems.some((item) => item === prevNode);
1821
1821
  }
1822
1822
  case 12 /* ParseNodeType.ComprehensionFor */: {
1823
- return prevNode === curNode.targetExpression;
1823
+ return prevNode === curNode.d.targetExpr;
1824
1824
  }
1825
1825
  case 54 /* ParseNodeType.TypeAnnotation */: {
1826
- if (prevNode === curNode.typeAnnotation) {
1826
+ if (prevNode === curNode.d.annotation) {
1827
1827
  return false;
1828
1828
  }
1829
1829
  break;
@@ -1855,12 +1855,12 @@ function getFileInfoFromNode(node) {
1855
1855
  exports.getFileInfoFromNode = getFileInfoFromNode;
1856
1856
  function isFunctionSuiteEmpty(node) {
1857
1857
  let isEmpty = true;
1858
- node.suite.statements.forEach((statement) => {
1858
+ node.d.suite.d.statements.forEach((statement) => {
1859
1859
  if (statement.nodeType === 0 /* ParseNodeType.Error */) {
1860
1860
  return;
1861
1861
  }
1862
1862
  else if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
1863
- statement.statements.forEach((subStatement) => {
1863
+ statement.d.statements.forEach((subStatement) => {
1864
1864
  // Allow docstrings, ellipsis, and pass statements.
1865
1865
  if (subStatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
1866
1866
  subStatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
@@ -1877,22 +1877,22 @@ function isFunctionSuiteEmpty(node) {
1877
1877
  }
1878
1878
  exports.isFunctionSuiteEmpty = isFunctionSuiteEmpty;
1879
1879
  function getTypeAnnotationForParameter(node, paramIndex) {
1880
- if (paramIndex >= node.parameters.length) {
1880
+ if (paramIndex >= node.d.params.length) {
1881
1881
  return undefined;
1882
1882
  }
1883
- const param = node.parameters[paramIndex];
1884
- if (param.typeAnnotation) {
1885
- return param.typeAnnotation;
1883
+ const param = node.d.params[paramIndex];
1884
+ if (param.d.annotation) {
1885
+ return param.d.annotation;
1886
1886
  }
1887
- else if (param.typeAnnotationComment) {
1888
- return param.typeAnnotationComment;
1887
+ else if (param.d.annotationComment) {
1888
+ return param.d.annotationComment;
1889
1889
  }
1890
- if (!node.functionAnnotationComment || node.functionAnnotationComment.isParamListEllipsis) {
1890
+ if (!node.d.funcAnnotationComment || node.d.funcAnnotationComment.d.isEllipsis) {
1891
1891
  return undefined;
1892
1892
  }
1893
1893
  let firstCommentAnnotationIndex = 0;
1894
- const paramAnnotations = node.functionAnnotationComment.paramTypeAnnotations;
1895
- if (paramAnnotations.length < node.parameters.length) {
1894
+ const paramAnnotations = node.d.funcAnnotationComment.d.paramAnnotations;
1895
+ if (paramAnnotations.length < node.d.params.length) {
1896
1896
  firstCommentAnnotationIndex = 1;
1897
1897
  }
1898
1898
  const adjIndex = paramIndex - firstCommentAnnotationIndex;
@@ -1909,7 +1909,7 @@ function isImportModuleName(node) {
1909
1909
  exports.isImportModuleName = isImportModuleName;
1910
1910
  function isImportAlias(node) {
1911
1911
  var _a;
1912
- return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 24 /* ParseNodeType.ImportAs */ && node.parent.alias === node;
1912
+ return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 24 /* ParseNodeType.ImportAs */ && node.parent.d.alias === node;
1913
1913
  }
1914
1914
  exports.isImportAlias = isImportAlias;
1915
1915
  function isFromImportModuleName(node) {
@@ -1919,12 +1919,12 @@ function isFromImportModuleName(node) {
1919
1919
  exports.isFromImportModuleName = isFromImportModuleName;
1920
1920
  function isFromImportName(node) {
1921
1921
  var _a;
1922
- return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.name === node;
1922
+ return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.d.name === node;
1923
1923
  }
1924
1924
  exports.isFromImportName = isFromImportName;
1925
1925
  function isFromImportAlias(node) {
1926
1926
  var _a;
1927
- return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.alias === node;
1927
+ return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.d.alias === node;
1928
1928
  }
1929
1929
  exports.isFromImportAlias = isFromImportAlias;
1930
1930
  function isLastNameOfModuleName(node) {
@@ -1933,10 +1933,10 @@ function isLastNameOfModuleName(node) {
1933
1933
  return false;
1934
1934
  }
1935
1935
  const module = node.parent;
1936
- if (module.nameParts.length === 0) {
1936
+ if (module.d.nameParts.length === 0) {
1937
1937
  return false;
1938
1938
  }
1939
- return module.nameParts[module.nameParts.length - 1] === node;
1939
+ return module.d.nameParts[module.d.nameParts.length - 1] === node;
1940
1940
  }
1941
1941
  exports.isLastNameOfModuleName = isLastNameOfModuleName;
1942
1942
  function* getAncestorsIncludingSelf(node) {
@@ -1971,7 +1971,7 @@ function getDottedNameWithGivenNodeAsLastName(node) {
1971
1971
  if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
1972
1972
  return node;
1973
1973
  }
1974
- if (node.parent.leftExpression === node) {
1974
+ if (node.parent.d.leftExpr === node) {
1975
1975
  return node;
1976
1976
  }
1977
1977
  return node.parent;
@@ -1989,14 +1989,14 @@ function getDecoratorName(decorator) {
1989
1989
  function getExpressionName(node) {
1990
1990
  var _a;
1991
1991
  if (node.nodeType === 38 /* ParseNodeType.Name */ || node.nodeType === 35 /* ParseNodeType.MemberAccess */) {
1992
- return (_a = getDottedName(node)) === null || _a === void 0 ? void 0 : _a.map((n) => n.value).join('.');
1992
+ return (_a = getDottedName(node)) === null || _a === void 0 ? void 0 : _a.map((n) => n.d.value).join('.');
1993
1993
  }
1994
1994
  if (node.nodeType === 9 /* ParseNodeType.Call */) {
1995
- return getExpressionName(node.leftExpression);
1995
+ return getExpressionName(node.d.leftExpr);
1996
1996
  }
1997
1997
  return undefined;
1998
1998
  }
1999
- return getExpressionName(decorator.expression);
1999
+ return getExpressionName(decorator.d.expr);
2000
2000
  }
2001
2001
  exports.getDecoratorName = getDecoratorName;
2002
2002
  function getDottedName(node) {
@@ -2016,10 +2016,10 @@ function getDottedName(node) {
2016
2016
  names.push(node);
2017
2017
  return true;
2018
2018
  }
2019
- names.push(node.memberName);
2020
- if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ ||
2021
- node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
2022
- return _getDottedName(node.leftExpression, names);
2019
+ names.push(node.d.member);
2020
+ if (node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ ||
2021
+ node.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */) {
2022
+ return _getDottedName(node.d.leftExpr, names);
2023
2023
  }
2024
2024
  return false;
2025
2025
  }
@@ -2030,9 +2030,8 @@ function getFirstNameOfDottedName(node) {
2030
2030
  if (node.nodeType === 38 /* ParseNodeType.Name */) {
2031
2031
  return node;
2032
2032
  }
2033
- if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ ||
2034
- node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
2035
- return getFirstNameOfDottedName(node.leftExpression);
2033
+ if (node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ || node.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */) {
2034
+ return getFirstNameOfDottedName(node.d.leftExpr);
2036
2035
  }
2037
2036
  return undefined;
2038
2037
  }
@@ -2043,7 +2042,7 @@ function isFirstNameOfDottedName(node) {
2043
2042
  if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
2044
2043
  return true;
2045
2044
  }
2046
- if (node.parent.leftExpression === node) {
2045
+ if (node.parent.d.leftExpr === node) {
2047
2046
  return true;
2048
2047
  }
2049
2048
  return false;
@@ -2055,18 +2054,18 @@ function isLastNameOfDottedName(node) {
2055
2054
  if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
2056
2055
  return true;
2057
2056
  }
2058
- if (node.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ &&
2059
- node.parent.leftExpression.nodeType !== 35 /* ParseNodeType.MemberAccess */) {
2057
+ if (node.parent.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */ &&
2058
+ node.parent.d.leftExpr.nodeType !== 35 /* ParseNodeType.MemberAccess */) {
2060
2059
  return false;
2061
2060
  }
2062
- if (node.parent.leftExpression === node) {
2061
+ if (node.parent.d.leftExpr === node) {
2063
2062
  return false;
2064
2063
  }
2065
2064
  return ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 35 /* ParseNodeType.MemberAccess */;
2066
2065
  }
2067
2066
  exports.isLastNameOfDottedName = isLastNameOfDottedName;
2068
2067
  function getStringNodeValueRange(node) {
2069
- return getStringValueRange(node.token);
2068
+ return getStringValueRange(node.d.token);
2070
2069
  }
2071
2070
  exports.getStringNodeValueRange = getStringNodeValueRange;
2072
2071
  function getStringValueRange(token) {
@@ -2111,8 +2110,8 @@ function isBlankLine(tokenizerOutput, text, line) {
2111
2110
  }
2112
2111
  exports.isBlankLine = isBlankLine;
2113
2112
  function isUnannotatedFunction(node) {
2114
- return (node.returnTypeAnnotation === undefined &&
2115
- node.parameters.every((param) => param.typeAnnotation === undefined && param.typeAnnotationComment === undefined));
2113
+ return (node.d.returnAnnotation === undefined &&
2114
+ node.d.params.every((param) => param.d.annotation === undefined && param.d.annotationComment === undefined));
2116
2115
  }
2117
2116
  exports.isUnannotatedFunction = isUnannotatedFunction;
2118
2117
  // Verifies that an import of the form "from __future__ import x"
@@ -2122,11 +2121,11 @@ function isValidLocationForFutureImport(node) {
2122
2121
  const module = getModuleNode(node);
2123
2122
  (0, debug_1.assert)(module);
2124
2123
  let sawDocString = false;
2125
- for (const statement of module.statements) {
2124
+ for (const statement of module.d.statements) {
2126
2125
  if (statement.nodeType !== 47 /* ParseNodeType.StatementList */) {
2127
2126
  return false;
2128
2127
  }
2129
- for (const simpleStatement of statement.statements) {
2128
+ for (const simpleStatement of statement.d.statements) {
2130
2129
  if (simpleStatement === node) {
2131
2130
  return true;
2132
2131
  }
@@ -2137,9 +2136,9 @@ function isValidLocationForFutureImport(node) {
2137
2136
  sawDocString = true;
2138
2137
  }
2139
2138
  else if (simpleStatement.nodeType === 25 /* ParseNodeType.ImportFrom */) {
2140
- if (simpleStatement.module.leadingDots !== 0 ||
2141
- simpleStatement.module.nameParts.length !== 1 ||
2142
- simpleStatement.module.nameParts[0].value !== '__future__') {
2139
+ if (simpleStatement.d.module.d.leadingDots !== 0 ||
2140
+ simpleStatement.d.module.d.nameParts.length !== 1 ||
2141
+ simpleStatement.d.module.d.nameParts[0].d.value !== '__future__') {
2143
2142
  return false;
2144
2143
  }
2145
2144
  }
@@ -2277,11 +2276,11 @@ function getVariableDocStringNode(node) {
2277
2276
  (suiteOrModule.nodeType !== 36 /* ParseNodeType.Module */ && suiteOrModule.nodeType !== 50 /* ParseNodeType.Suite */)) {
2278
2277
  return undefined;
2279
2278
  }
2280
- const assignmentIndex = suiteOrModule.statements.findIndex((node) => node === parentNode);
2281
- if (assignmentIndex < 0 || assignmentIndex === suiteOrModule.statements.length - 1) {
2279
+ const assignmentIndex = suiteOrModule.d.statements.findIndex((node) => node === parentNode);
2280
+ if (assignmentIndex < 0 || assignmentIndex === suiteOrModule.d.statements.length - 1) {
2282
2281
  return undefined;
2283
2282
  }
2284
- const nextStatement = suiteOrModule.statements[assignmentIndex + 1];
2283
+ const nextStatement = suiteOrModule.d.statements[assignmentIndex + 1];
2285
2284
  if (nextStatement.nodeType !== 47 /* ParseNodeType.StatementList */ || !isDocString(nextStatement)) {
2286
2285
  return undefined;
2287
2286
  }
@@ -2299,7 +2298,7 @@ function getVariableDocStringNode(node) {
2299
2298
  else {
2300
2299
  const func = getEnclosingFunction(parentNode);
2301
2300
  // If we're within an __init__ method, the attribute docstring is valid.
2302
- if (func && func.name.value === '__init__' && getEnclosingClass(func, /* stopAtFunction */ true)) {
2301
+ if (func && func.d.name.d.value === '__init__' && getEnclosingClass(func, /* stopAtFunction */ true)) {
2303
2302
  isValidContext = true;
2304
2303
  }
2305
2304
  }
@@ -2307,7 +2306,7 @@ function getVariableDocStringNode(node) {
2307
2306
  return undefined;
2308
2307
  }
2309
2308
  // A docstring can consist of multiple joined strings in a single expression.
2310
- return nextStatement.statements[0];
2309
+ return nextStatement.d.statements[0];
2311
2310
  }
2312
2311
  exports.getVariableDocStringNode = getVariableDocStringNode;
2313
2312
  // Creates an ID that identifies this parse node in a way that will
@@ -2316,10 +2315,10 @@ exports.getVariableDocStringNode = getVariableDocStringNode;
2316
2315
  function getScopeIdForNode(node) {
2317
2316
  let name = '';
2318
2317
  if (node.nodeType === 10 /* ParseNodeType.Class */) {
2319
- name = node.name.value;
2318
+ name = node.d.name.d.value;
2320
2319
  }
2321
2320
  else if (node.nodeType === 31 /* ParseNodeType.Function */) {
2322
- name = node.name.value;
2321
+ name = node.d.name.d.value;
2323
2322
  }
2324
2323
  const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
2325
2324
  return `${fileInfo.fileUri.key}.${node.start.toString()}-${name}`;
@@ -2342,7 +2341,7 @@ function getTypeVarScopesForNode(node) {
2342
2341
  }
2343
2342
  exports.getTypeVarScopesForNode = getTypeVarScopesForNode;
2344
2343
  function checkDecorator(node, value) {
2345
- return node.expression.nodeType === 38 /* ParseNodeType.Name */ && node.expression.value === value;
2344
+ return node.d.expr.nodeType === 38 /* ParseNodeType.Name */ && node.d.expr.d.value === value;
2346
2345
  }
2347
2346
  exports.checkDecorator = checkDecorator;
2348
2347
  function isSimpleDefault(node) {
@@ -2352,13 +2351,13 @@ function isSimpleDefault(node) {
2352
2351
  case 35 /* ParseNodeType.MemberAccess */:
2353
2352
  return true;
2354
2353
  case 49 /* ParseNodeType.String */:
2355
- return (node.token.flags & 64 /* StringTokenFlags.Format */) === 0;
2354
+ return (node.d.token.flags & 64 /* StringTokenFlags.Format */) === 0;
2356
2355
  case 48 /* ParseNodeType.StringList */:
2357
- return node.strings.every(isSimpleDefault);
2356
+ return node.d.strings.every(isSimpleDefault);
2358
2357
  case 55 /* ParseNodeType.UnaryOperation */:
2359
- return isSimpleDefault(node.expression);
2358
+ return isSimpleDefault(node.d.expr);
2360
2359
  case 7 /* ParseNodeType.BinaryOperation */:
2361
- return isSimpleDefault(node.leftExpression) && isSimpleDefault(node.rightExpression);
2360
+ return isSimpleDefault(node.d.leftExpr) && isSimpleDefault(node.d.rightExpr);
2362
2361
  default:
2363
2362
  return false;
2364
2363
  }