@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
@@ -95,178 +95,192 @@ export declare const enum ErrorExpressionCategory {
95
95
  MissingPattern = 11,
96
96
  MissingPatternSubject = 12,
97
97
  MissingDictValue = 13,
98
- MaxDepthExceeded = 14
98
+ MissingKeywordArgValue = 14,
99
+ MaxDepthExceeded = 15
99
100
  }
100
- export interface MutableTextRange {
101
- start: number;
102
- length: number;
103
- }
104
- export interface ParseNodeBase extends MutableTextRange {
105
- readonly nodeType: ParseNodeType;
101
+ export interface ParseNodeBase<T extends ParseNodeType> {
102
+ readonly nodeType: T;
106
103
  readonly start: number;
107
104
  readonly length: number;
108
105
  id: number;
109
- parent?: ParseNode | undefined;
110
- maxChildDepth?: number;
106
+ parent: ParseNode | undefined;
107
+ a: object | undefined;
108
+ d: object;
111
109
  }
112
110
  export declare function getNextNodeId(): number;
113
- export declare function extendRange(node: ParseNodeBase, newRange: TextRange): void;
111
+ export declare function extendRange(node: ParseNodeBase<any>, newRange: TextRange): void;
114
112
  export type ParseNodeArray = (ParseNode | undefined)[];
115
- export interface ModuleNode extends ParseNodeBase {
116
- readonly nodeType: ParseNodeType.Module;
117
- statements: StatementNode[];
113
+ export interface ModuleNode extends ParseNodeBase<ParseNodeType.Module> {
114
+ d: {
115
+ statements: StatementNode[];
116
+ };
118
117
  }
119
118
  export declare namespace ModuleNode {
120
119
  function create(range: TextRange): ModuleNode;
121
120
  }
122
- export interface SuiteNode extends ParseNodeBase {
123
- readonly nodeType: ParseNodeType.Suite;
124
- statements: StatementNode[];
125
- typeComment?: StringToken;
121
+ export interface SuiteNode extends ParseNodeBase<ParseNodeType.Suite> {
122
+ d: {
123
+ statements: StatementNode[];
124
+ typeComment: StringToken | undefined;
125
+ };
126
126
  }
127
127
  export declare namespace SuiteNode {
128
128
  function create(range: TextRange): SuiteNode;
129
129
  }
130
- export interface IfNode extends ParseNodeBase {
131
- readonly nodeType: ParseNodeType.If;
132
- testExpression: ExpressionNode;
133
- ifSuite: SuiteNode;
134
- elseSuite?: SuiteNode | IfNode | undefined;
130
+ export interface IfNode extends ParseNodeBase<ParseNodeType.If> {
131
+ d: {
132
+ testExpr: ExpressionNode;
133
+ ifSuite: SuiteNode;
134
+ elseSuite: SuiteNode | IfNode | undefined;
135
+ };
135
136
  }
136
137
  export declare namespace IfNode {
137
- function create(ifOrElifToken: Token, testExpression: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
138
+ function create(ifOrElifToken: Token, testExpr: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
138
139
  }
139
- export interface WhileNode extends ParseNodeBase {
140
- readonly nodeType: ParseNodeType.While;
141
- testExpression: ExpressionNode;
142
- whileSuite: SuiteNode;
143
- elseSuite?: SuiteNode | undefined;
140
+ export interface WhileNode extends ParseNodeBase<ParseNodeType.While> {
141
+ d: {
142
+ testExpr: ExpressionNode;
143
+ whileSuite: SuiteNode;
144
+ elseSuite?: SuiteNode | undefined;
145
+ };
144
146
  }
145
147
  export declare namespace WhileNode {
146
- function create(whileToken: Token, testExpression: ExpressionNode, whileSuite: SuiteNode): WhileNode;
147
- }
148
- export interface ForNode extends ParseNodeBase {
149
- readonly nodeType: ParseNodeType.For;
150
- isAsync?: boolean;
151
- asyncToken?: Token;
152
- targetExpression: ExpressionNode;
153
- iterableExpression: ExpressionNode;
154
- forSuite: SuiteNode;
155
- elseSuite?: SuiteNode | undefined;
156
- typeComment?: StringToken;
148
+ function create(whileToken: Token, testExpr: ExpressionNode, whileSuite: SuiteNode): WhileNode;
149
+ }
150
+ export interface ForNode extends ParseNodeBase<ParseNodeType.For> {
151
+ d: {
152
+ isAsync?: boolean;
153
+ asyncToken?: Token;
154
+ targetExpr: ExpressionNode;
155
+ iterableExpr: ExpressionNode;
156
+ forSuite: SuiteNode;
157
+ elseSuite?: SuiteNode | undefined;
158
+ typeComment?: StringToken;
159
+ };
157
160
  }
158
161
  export declare namespace ForNode {
159
- function create(forToken: Token, targetExpression: ExpressionNode, iterableExpression: ExpressionNode, forSuite: SuiteNode): ForNode;
162
+ function create(forToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode, forSuite: SuiteNode): ForNode;
160
163
  }
161
164
  export type ComprehensionForIfNode = ComprehensionForNode | ComprehensionIfNode;
162
- export interface ComprehensionForNode extends ParseNodeBase {
163
- readonly nodeType: ParseNodeType.ComprehensionFor;
164
- isAsync?: boolean;
165
- asyncToken?: Token;
166
- targetExpression: ExpressionNode;
167
- iterableExpression: ExpressionNode;
165
+ export interface ComprehensionForNode extends ParseNodeBase<ParseNodeType.ComprehensionFor> {
166
+ d: {
167
+ isAsync?: boolean;
168
+ asyncToken?: Token;
169
+ targetExpr: ExpressionNode;
170
+ iterableExpr: ExpressionNode;
171
+ };
168
172
  }
169
173
  export declare namespace ComprehensionForNode {
170
- function create(startToken: Token, targetExpression: ExpressionNode, iterableExpression: ExpressionNode): ComprehensionForNode;
174
+ function create(startToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode): ComprehensionForNode;
171
175
  }
172
- export interface ComprehensionIfNode extends ParseNodeBase {
173
- readonly nodeType: ParseNodeType.ComprehensionIf;
174
- testExpression: ExpressionNode;
176
+ export interface ComprehensionIfNode extends ParseNodeBase<ParseNodeType.ComprehensionIf> {
177
+ d: {
178
+ testExpr: ExpressionNode;
179
+ };
175
180
  }
176
181
  export declare namespace ComprehensionIfNode {
177
- function create(ifToken: Token, testExpression: ExpressionNode): ComprehensionIfNode;
182
+ function create(ifToken: Token, testExpr: ExpressionNode): ComprehensionIfNode;
178
183
  }
179
- export interface TryNode extends ParseNodeBase {
180
- readonly nodeType: ParseNodeType.Try;
181
- trySuite: SuiteNode;
182
- exceptClauses: ExceptNode[];
183
- elseSuite?: SuiteNode | undefined;
184
- finallySuite?: SuiteNode | undefined;
184
+ export interface TryNode extends ParseNodeBase<ParseNodeType.Try> {
185
+ d: {
186
+ trySuite: SuiteNode;
187
+ exceptClauses: ExceptNode[];
188
+ elseSuite?: SuiteNode | undefined;
189
+ finallySuite?: SuiteNode | undefined;
190
+ };
185
191
  }
186
192
  export declare namespace TryNode {
187
193
  function create(tryToken: Token, trySuite: SuiteNode): TryNode;
188
194
  }
189
- export interface ExceptNode extends ParseNodeBase {
190
- readonly nodeType: ParseNodeType.Except;
191
- typeExpression?: ExpressionNode | undefined;
192
- name?: NameNode | undefined;
193
- exceptSuite: SuiteNode;
194
- isExceptGroup: boolean;
195
+ export interface ExceptNode extends ParseNodeBase<ParseNodeType.Except> {
196
+ d: {
197
+ typeExpr?: ExpressionNode | undefined;
198
+ name?: NameNode | undefined;
199
+ exceptSuite: SuiteNode;
200
+ isExceptGroup: boolean;
201
+ };
195
202
  }
196
203
  export declare namespace ExceptNode {
197
204
  function create(exceptToken: Token, exceptSuite: SuiteNode, isExceptGroup: boolean): ExceptNode;
198
205
  }
199
- export interface FunctionNode extends ParseNodeBase {
200
- readonly nodeType: ParseNodeType.Function;
201
- decorators: DecoratorNode[];
202
- isAsync?: boolean;
203
- name: NameNode;
204
- typeParameters?: TypeParameterListNode;
205
- parameters: ParameterNode[];
206
- returnTypeAnnotation?: ExpressionNode | undefined;
207
- functionAnnotationComment?: FunctionAnnotationNode | undefined;
208
- suite: SuiteNode;
206
+ export interface FunctionNode extends ParseNodeBase<ParseNodeType.Function> {
207
+ d: {
208
+ decorators: DecoratorNode[];
209
+ isAsync: boolean;
210
+ name: NameNode;
211
+ typeParams: TypeParameterListNode | undefined;
212
+ params: ParameterNode[];
213
+ returnAnnotation: ExpressionNode | undefined;
214
+ funcAnnotationComment: FunctionAnnotationNode | undefined;
215
+ suite: SuiteNode;
216
+ };
209
217
  }
210
218
  export declare namespace FunctionNode {
211
- function create(defToken: Token, name: NameNode, suite: SuiteNode, typeParameters?: TypeParameterListNode): FunctionNode;
219
+ function create(defToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): FunctionNode;
212
220
  }
213
221
  export declare const enum ParameterCategory {
214
222
  Simple = 0,
215
223
  ArgsList = 1,
216
224
  KwargsDict = 2
217
225
  }
218
- export interface ParameterNode extends ParseNodeBase {
219
- readonly nodeType: ParseNodeType.Parameter;
220
- category: ParameterCategory;
221
- name?: NameNode | undefined;
222
- typeAnnotation?: ExpressionNode | undefined;
223
- typeAnnotationComment?: ExpressionNode | undefined;
224
- defaultValue?: ExpressionNode | undefined;
226
+ export interface ParameterNode extends ParseNodeBase<ParseNodeType.Parameter> {
227
+ d: {
228
+ category: ParameterCategory;
229
+ name: NameNode | undefined;
230
+ annotation: ExpressionNode | undefined;
231
+ annotationComment: ExpressionNode | undefined;
232
+ defaultValue: ExpressionNode | undefined;
233
+ };
225
234
  }
226
235
  export declare namespace ParameterNode {
227
236
  function create(startToken: Token, paramCategory: ParameterCategory): ParameterNode;
228
237
  }
229
- export interface ClassNode extends ParseNodeBase {
230
- readonly nodeType: ParseNodeType.Class;
231
- decorators: DecoratorNode[];
232
- name: NameNode;
233
- typeParameters?: TypeParameterListNode;
234
- arguments: ArgumentNode[];
235
- suite: SuiteNode;
238
+ export interface ClassNode extends ParseNodeBase<ParseNodeType.Class> {
239
+ d: {
240
+ decorators: DecoratorNode[];
241
+ name: NameNode;
242
+ typeParams: TypeParameterListNode | undefined;
243
+ arguments: ArgumentNode[];
244
+ suite: SuiteNode;
245
+ };
236
246
  }
237
247
  export declare namespace ClassNode {
238
- function create(classToken: Token, name: NameNode, suite: SuiteNode, typeParameters?: TypeParameterListNode): ClassNode;
248
+ function create(classToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): ClassNode;
239
249
  function createDummyForDecorators(decorators: DecoratorNode[]): ClassNode;
240
250
  }
241
- export interface WithNode extends ParseNodeBase {
242
- readonly nodeType: ParseNodeType.With;
243
- isAsync?: boolean;
244
- asyncToken?: Token;
245
- withItems: WithItemNode[];
246
- suite: SuiteNode;
247
- typeComment?: StringToken;
251
+ export interface WithNode extends ParseNodeBase<ParseNodeType.With> {
252
+ d: {
253
+ isAsync?: boolean;
254
+ asyncToken?: Token;
255
+ withItems: WithItemNode[];
256
+ suite: SuiteNode;
257
+ typeComment?: StringToken;
258
+ };
248
259
  }
249
260
  export declare namespace WithNode {
250
261
  function create(withToken: Token, suite: SuiteNode): WithNode;
251
262
  }
252
- export interface WithItemNode extends ParseNodeBase {
253
- readonly nodeType: ParseNodeType.WithItem;
254
- expression: ExpressionNode;
255
- target?: ExpressionNode | undefined;
263
+ export interface WithItemNode extends ParseNodeBase<ParseNodeType.WithItem> {
264
+ d: {
265
+ expr: ExpressionNode;
266
+ target?: ExpressionNode | undefined;
267
+ };
256
268
  }
257
269
  export declare namespace WithItemNode {
258
- function create(expression: ExpressionNode): WithItemNode;
270
+ function create(expr: ExpressionNode): WithItemNode;
259
271
  }
260
- export interface DecoratorNode extends ParseNodeBase {
261
- readonly nodeType: ParseNodeType.Decorator;
262
- expression: ExpressionNode;
272
+ export interface DecoratorNode extends ParseNodeBase<ParseNodeType.Decorator> {
273
+ d: {
274
+ expr: ExpressionNode;
275
+ };
263
276
  }
264
277
  export declare namespace DecoratorNode {
265
- function create(atToken: Token, expression: ExpressionNode): DecoratorNode;
278
+ function create(atToken: Token, expr: ExpressionNode): DecoratorNode;
266
279
  }
267
- export interface StatementListNode extends ParseNodeBase {
268
- readonly nodeType: ParseNodeType.StatementList;
269
- statements: ParseNode[];
280
+ export interface StatementListNode extends ParseNodeBase<ParseNodeType.StatementList> {
281
+ d: {
282
+ statements: ParseNode[];
283
+ };
270
284
  }
271
285
  export declare namespace StatementListNode {
272
286
  function create(atToken: Token): StatementListNode;
@@ -275,306 +289,339 @@ export type StatementNode = IfNode | WhileNode | ForNode | TryNode | FunctionNod
275
289
  export type SmallStatementNode = ExpressionNode | DelNode | PassNode | ImportNode | GlobalNode | NonlocalNode | AssertNode;
276
290
  export type ExpressionNode = ErrorNode | UnaryOperationNode | BinaryOperationNode | AssignmentNode | TypeAnnotationNode | AssignmentExpressionNode | AugmentedAssignmentNode | AwaitNode | TernaryNode | UnpackNode | TupleNode | CallNode | ComprehensionNode | IndexNode | SliceNode | YieldNode | YieldFromNode | MemberAccessNode | LambdaNode | NameNode | ConstantNode | EllipsisNode | NumberNode | StringNode | FormatStringNode | StringListNode | DictionaryNode | ListNode | SetNode;
277
291
  export declare function isExpressionNode(node: ParseNode): node is ExpressionNode;
278
- export interface ErrorNode extends ParseNodeBase {
279
- readonly nodeType: ParseNodeType.Error;
280
- readonly category: ErrorExpressionCategory;
281
- readonly child?: ExpressionNode | undefined;
282
- readonly decorators?: DecoratorNode[] | undefined;
292
+ export interface ErrorNode extends ParseNodeBase<ParseNodeType.Error> {
293
+ d: {
294
+ readonly category: ErrorExpressionCategory;
295
+ readonly child: ExpressionNode | undefined;
296
+ readonly decorators?: DecoratorNode[] | undefined;
297
+ };
283
298
  }
284
299
  export declare namespace ErrorNode {
285
300
  function create(initialRange: TextRange, category: ErrorExpressionCategory, child?: ExpressionNode, decorators?: DecoratorNode[]): ErrorNode;
286
301
  }
287
- export interface UnaryOperationNode extends ParseNodeBase {
288
- readonly nodeType: ParseNodeType.UnaryOperation;
289
- expression: ExpressionNode;
290
- operatorToken: Token;
291
- operator: OperatorType;
292
- parenthesized?: boolean;
302
+ export interface UnaryOperationNode extends ParseNodeBase<ParseNodeType.UnaryOperation> {
303
+ d: {
304
+ expr: ExpressionNode;
305
+ operatorToken: Token;
306
+ operator: OperatorType;
307
+ hasParens: boolean;
308
+ };
293
309
  }
294
310
  export declare namespace UnaryOperationNode {
295
- function create(operatorToken: Token, expression: ExpressionNode, operator: OperatorType): UnaryOperationNode;
311
+ function create(operatorToken: Token, expr: ExpressionNode, operator: OperatorType): UnaryOperationNode;
296
312
  }
297
- export interface BinaryOperationNode extends ParseNodeBase {
298
- readonly nodeType: ParseNodeType.BinaryOperation;
299
- leftExpression: ExpressionNode;
300
- operatorToken: Token;
301
- operator: OperatorType;
302
- rightExpression: ExpressionNode;
303
- parenthesized?: boolean;
313
+ export interface BinaryOperationNode extends ParseNodeBase<ParseNodeType.BinaryOperation> {
314
+ d: {
315
+ leftExpr: ExpressionNode;
316
+ operatorToken: Token;
317
+ operator: OperatorType;
318
+ rightExpr: ExpressionNode;
319
+ hasParens: boolean;
320
+ };
304
321
  }
305
322
  export declare namespace BinaryOperationNode {
306
- function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
323
+ function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
307
324
  }
308
- export interface AssignmentExpressionNode extends ParseNodeBase {
309
- readonly nodeType: ParseNodeType.AssignmentExpression;
310
- name: NameNode;
311
- walrusToken: Token;
312
- rightExpression: ExpressionNode;
313
- isParenthesized: boolean;
325
+ export interface AssignmentExpressionNode extends ParseNodeBase<ParseNodeType.AssignmentExpression> {
326
+ d: {
327
+ name: NameNode;
328
+ walrusToken: Token;
329
+ rightExpr: ExpressionNode;
330
+ hasParens: boolean;
331
+ };
314
332
  }
315
333
  export declare namespace AssignmentExpressionNode {
316
- function create(name: NameNode, walrusToken: Token, rightExpression: ExpressionNode): AssignmentExpressionNode;
334
+ function create(name: NameNode, walrusToken: Token, rightExpr: ExpressionNode): AssignmentExpressionNode;
317
335
  }
318
- export interface AssignmentNode extends ParseNodeBase {
319
- readonly nodeType: ParseNodeType.Assignment;
320
- leftExpression: ExpressionNode;
321
- rightExpression: ExpressionNode;
322
- typeAnnotationComment?: ExpressionNode | undefined;
323
- chainedTypeAnnotationComment?: ExpressionNode | undefined;
336
+ export interface AssignmentNode extends ParseNodeBase<ParseNodeType.Assignment> {
337
+ d: {
338
+ leftExpr: ExpressionNode;
339
+ rightExpr: ExpressionNode;
340
+ annotationComment?: ExpressionNode | undefined;
341
+ chainedAnnotationComment?: ExpressionNode | undefined;
342
+ };
324
343
  }
325
344
  export declare namespace AssignmentNode {
326
- function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode): AssignmentNode;
345
+ function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode): AssignmentNode;
327
346
  }
328
- export declare enum TypeParameterCategory {
347
+ export declare enum TypeParameterKind {
329
348
  TypeVar = 0,
330
349
  TypeVarTuple = 1,
331
350
  ParamSpec = 2
332
351
  }
333
- export interface TypeParameterNode extends ParseNodeBase {
334
- readonly nodeType: ParseNodeType.TypeParameter;
335
- name: NameNode;
336
- typeParamCategory: TypeParameterCategory;
337
- boundExpression?: ExpressionNode;
338
- defaultExpression?: ExpressionNode;
352
+ export interface TypeParameterNode extends ParseNodeBase<ParseNodeType.TypeParameter> {
353
+ d: {
354
+ name: NameNode;
355
+ typeParamKind: TypeParameterKind;
356
+ boundExpr?: ExpressionNode;
357
+ defaultExpr?: ExpressionNode;
358
+ };
339
359
  }
340
360
  export declare namespace TypeParameterNode {
341
- function create(name: NameNode, typeParamCategory: TypeParameterCategory, boundExpression?: ExpressionNode, defaultExpression?: ExpressionNode): TypeParameterNode;
361
+ function create(name: NameNode, typeParamKind: TypeParameterKind, boundExpr?: ExpressionNode, defaultExpr?: ExpressionNode): TypeParameterNode;
342
362
  }
343
- export interface TypeParameterListNode extends ParseNodeBase {
344
- readonly nodeType: ParseNodeType.TypeParameterList;
345
- parameters: TypeParameterNode[];
363
+ export interface TypeParameterListNode extends ParseNodeBase<ParseNodeType.TypeParameterList> {
364
+ d: {
365
+ params: TypeParameterNode[];
366
+ };
346
367
  }
347
368
  export declare namespace TypeParameterListNode {
348
- function create(startToken: Token, endToken: Token, parameters: TypeParameterNode[]): TypeParameterListNode;
369
+ function create(startToken: Token, endToken: Token, params: TypeParameterNode[]): TypeParameterListNode;
349
370
  }
350
- export interface TypeAliasNode extends ParseNodeBase {
351
- readonly nodeType: ParseNodeType.TypeAlias;
352
- name: NameNode;
353
- typeParameters?: TypeParameterListNode;
354
- expression: ExpressionNode;
371
+ export interface TypeAliasNode extends ParseNodeBase<ParseNodeType.TypeAlias> {
372
+ d: {
373
+ name: NameNode;
374
+ typeParams?: TypeParameterListNode;
375
+ expr: ExpressionNode;
376
+ };
355
377
  }
356
378
  export declare namespace TypeAliasNode {
357
- function create(typeToken: KeywordToken, name: NameNode, expression: ExpressionNode, typeParameters?: TypeParameterListNode): TypeAliasNode;
379
+ function create(typeToken: KeywordToken, name: NameNode, expr: ExpressionNode, typeParams?: TypeParameterListNode): TypeAliasNode;
358
380
  }
359
- export interface TypeAnnotationNode extends ParseNodeBase {
360
- readonly nodeType: ParseNodeType.TypeAnnotation;
361
- valueExpression: ExpressionNode;
362
- typeAnnotation: ExpressionNode;
381
+ export interface TypeAnnotationNode extends ParseNodeBase<ParseNodeType.TypeAnnotation> {
382
+ d: {
383
+ valueExpr: ExpressionNode;
384
+ annotation: ExpressionNode;
385
+ };
363
386
  }
364
387
  export declare namespace TypeAnnotationNode {
365
- function create(valueExpression: ExpressionNode, typeAnnotation: ExpressionNode): TypeAnnotationNode;
388
+ function create(valueExpr: ExpressionNode, annotation: ExpressionNode): TypeAnnotationNode;
366
389
  }
367
- export interface FunctionAnnotationNode extends ParseNodeBase {
368
- readonly nodeType: ParseNodeType.FunctionAnnotation;
369
- isParamListEllipsis: boolean;
370
- paramTypeAnnotations: ExpressionNode[];
371
- returnTypeAnnotation: ExpressionNode;
390
+ export interface FunctionAnnotationNode extends ParseNodeBase<ParseNodeType.FunctionAnnotation> {
391
+ d: {
392
+ isEllipsis: boolean;
393
+ paramAnnotations: ExpressionNode[];
394
+ returnAnnotation: ExpressionNode;
395
+ };
372
396
  }
373
397
  export declare namespace FunctionAnnotationNode {
374
- function create(openParenToken: Token, isParamListEllipsis: boolean, paramTypeAnnotations: ExpressionNode[], returnTypeAnnotation: ExpressionNode): FunctionAnnotationNode;
398
+ function create(openParenToken: Token, isEllipsis: boolean, paramAnnotations: ExpressionNode[], returnAnnotation: ExpressionNode): FunctionAnnotationNode;
375
399
  }
376
- export interface AugmentedAssignmentNode extends ParseNodeBase {
377
- readonly nodeType: ParseNodeType.AugmentedAssignment;
378
- leftExpression: ExpressionNode;
379
- operator: OperatorType;
380
- rightExpression: ExpressionNode;
381
- destExpression: ExpressionNode;
400
+ export interface AugmentedAssignmentNode extends ParseNodeBase<ParseNodeType.AugmentedAssignment> {
401
+ d: {
402
+ leftExpr: ExpressionNode;
403
+ operator: OperatorType;
404
+ rightExpr: ExpressionNode;
405
+ destExpr: ExpressionNode;
406
+ };
382
407
  }
383
408
  export declare namespace AugmentedAssignmentNode {
384
- function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode, operator: OperatorType, destExpression: ExpressionNode): AugmentedAssignmentNode;
409
+ function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operator: OperatorType, destExpr: ExpressionNode): AugmentedAssignmentNode;
385
410
  }
386
- export interface AwaitNode extends ParseNodeBase {
387
- readonly nodeType: ParseNodeType.Await;
388
- expression: ExpressionNode;
389
- parenthesized?: boolean;
411
+ export interface AwaitNode extends ParseNodeBase<ParseNodeType.Await> {
412
+ d: {
413
+ expr: ExpressionNode;
414
+ hasParens?: boolean;
415
+ };
390
416
  }
391
417
  export declare namespace AwaitNode {
392
- function create(awaitToken: Token, expression: ExpressionNode): AwaitNode;
418
+ function create(awaitToken: Token, expr: ExpressionNode): AwaitNode;
393
419
  }
394
- export interface TernaryNode extends ParseNodeBase {
395
- readonly nodeType: ParseNodeType.Ternary;
396
- ifExpression: ExpressionNode;
397
- testExpression: ExpressionNode;
398
- elseExpression: ExpressionNode;
420
+ export interface TernaryNode extends ParseNodeBase<ParseNodeType.Ternary> {
421
+ d: {
422
+ ifExpr: ExpressionNode;
423
+ testExpr: ExpressionNode;
424
+ elseExpr: ExpressionNode;
425
+ };
399
426
  }
400
427
  export declare namespace TernaryNode {
401
- function create(ifExpression: ExpressionNode, testExpression: ExpressionNode, elseExpression: ExpressionNode): TernaryNode;
428
+ function create(ifExpr: ExpressionNode, testExpr: ExpressionNode, elseExpr: ExpressionNode): TernaryNode;
402
429
  }
403
- export interface UnpackNode extends ParseNodeBase {
404
- readonly nodeType: ParseNodeType.Unpack;
405
- expression: ExpressionNode;
406
- starToken: Token;
430
+ export interface UnpackNode extends ParseNodeBase<ParseNodeType.Unpack> {
431
+ d: {
432
+ expr: ExpressionNode;
433
+ starToken: Token;
434
+ };
407
435
  }
408
436
  export declare namespace UnpackNode {
409
- function create(starToken: Token, expression: ExpressionNode): UnpackNode;
437
+ function create(starToken: Token, expr: ExpressionNode): UnpackNode;
410
438
  }
411
- export interface TupleNode extends ParseNodeBase {
412
- readonly nodeType: ParseNodeType.Tuple;
413
- expressions: ExpressionNode[];
414
- enclosedInParens: boolean;
439
+ export interface TupleNode extends ParseNodeBase<ParseNodeType.Tuple> {
440
+ d: {
441
+ items: ExpressionNode[];
442
+ hasParens: boolean;
443
+ };
415
444
  }
416
445
  export declare namespace TupleNode {
417
- function create(range: TextRange, enclosedInParens: boolean): TupleNode;
446
+ function create(range: TextRange, hasParens: boolean): TupleNode;
418
447
  }
419
- export interface CallNode extends ParseNodeBase {
420
- readonly nodeType: ParseNodeType.Call;
421
- leftExpression: ExpressionNode;
422
- arguments: ArgumentNode[];
423
- trailingComma: boolean;
448
+ export interface CallNode extends ParseNodeBase<ParseNodeType.Call> {
449
+ d: {
450
+ leftExpr: ExpressionNode;
451
+ args: ArgumentNode[];
452
+ trailingComma: boolean;
453
+ };
424
454
  }
425
455
  export declare namespace CallNode {
426
- function create(leftExpression: ExpressionNode, argList: ArgumentNode[], trailingComma: boolean): CallNode;
456
+ function create(leftExpr: ExpressionNode, args: ArgumentNode[], trailingComma: boolean): CallNode;
427
457
  }
428
- export interface ComprehensionNode extends ParseNodeBase {
429
- readonly nodeType: ParseNodeType.Comprehension;
430
- expression: ParseNode;
431
- forIfNodes: ComprehensionForIfNode[];
432
- isGenerator: boolean;
433
- isParenthesized?: boolean;
458
+ export interface ComprehensionNode extends ParseNodeBase<ParseNodeType.Comprehension> {
459
+ d: {
460
+ expr: ParseNode;
461
+ forIfNodes: ComprehensionForIfNode[];
462
+ isGenerator: boolean;
463
+ hasParens?: boolean;
464
+ };
434
465
  }
435
466
  export declare namespace ComprehensionNode {
436
- function create(expression: ParseNode, isGenerator: boolean): ComprehensionNode;
467
+ function create(expr: ParseNode, isGenerator: boolean): ComprehensionNode;
437
468
  }
438
- export interface IndexNode extends ParseNodeBase {
439
- readonly nodeType: ParseNodeType.Index;
440
- baseExpression: ExpressionNode;
441
- items: ArgumentNode[];
442
- trailingComma: boolean;
469
+ export interface IndexNode extends ParseNodeBase<ParseNodeType.Index> {
470
+ d: {
471
+ leftExpr: ExpressionNode;
472
+ items: ArgumentNode[];
473
+ trailingComma: boolean;
474
+ };
443
475
  }
444
476
  export declare namespace IndexNode {
445
- function create(baseExpression: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
477
+ function create(leftExpr: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
446
478
  }
447
- export interface SliceNode extends ParseNodeBase {
448
- readonly nodeType: ParseNodeType.Slice;
449
- startValue?: ExpressionNode | undefined;
450
- endValue?: ExpressionNode | undefined;
451
- stepValue?: ExpressionNode | undefined;
479
+ export interface SliceNode extends ParseNodeBase<ParseNodeType.Slice> {
480
+ d: {
481
+ startValue?: ExpressionNode | undefined;
482
+ endValue?: ExpressionNode | undefined;
483
+ stepValue?: ExpressionNode | undefined;
484
+ };
452
485
  }
453
486
  export declare namespace SliceNode {
454
487
  function create(range: TextRange): SliceNode;
455
488
  }
456
- export interface YieldNode extends ParseNodeBase {
457
- readonly nodeType: ParseNodeType.Yield;
458
- expression?: ExpressionNode | undefined;
489
+ export interface YieldNode extends ParseNodeBase<ParseNodeType.Yield> {
490
+ d: {
491
+ expr?: ExpressionNode | undefined;
492
+ };
459
493
  }
460
494
  export declare namespace YieldNode {
461
- function create(yieldToken: Token, expression?: ExpressionNode): YieldNode;
495
+ function create(yieldToken: Token, expr?: ExpressionNode): YieldNode;
462
496
  }
463
- export interface YieldFromNode extends ParseNodeBase {
464
- readonly nodeType: ParseNodeType.YieldFrom;
465
- expression: ExpressionNode;
497
+ export interface YieldFromNode extends ParseNodeBase<ParseNodeType.YieldFrom> {
498
+ d: {
499
+ expr: ExpressionNode;
500
+ };
466
501
  }
467
502
  export declare namespace YieldFromNode {
468
- function create(yieldToken: Token, expression: ExpressionNode): YieldFromNode;
503
+ function create(yieldToken: Token, expr: ExpressionNode): YieldFromNode;
469
504
  }
470
- export interface MemberAccessNode extends ParseNodeBase {
471
- readonly nodeType: ParseNodeType.MemberAccess;
472
- leftExpression: ExpressionNode;
473
- memberName: NameNode;
505
+ export interface MemberAccessNode extends ParseNodeBase<ParseNodeType.MemberAccess> {
506
+ d: {
507
+ leftExpr: ExpressionNode;
508
+ member: NameNode;
509
+ };
474
510
  }
475
511
  export declare namespace MemberAccessNode {
476
- function create(leftExpression: ExpressionNode, memberName: NameNode): MemberAccessNode;
512
+ function create(leftExpr: ExpressionNode, member: NameNode): MemberAccessNode;
477
513
  }
478
- export interface LambdaNode extends ParseNodeBase {
479
- readonly nodeType: ParseNodeType.Lambda;
480
- parameters: ParameterNode[];
481
- expression: ExpressionNode;
514
+ export interface LambdaNode extends ParseNodeBase<ParseNodeType.Lambda> {
515
+ d: {
516
+ params: ParameterNode[];
517
+ expr: ExpressionNode;
518
+ };
482
519
  }
483
520
  export declare namespace LambdaNode {
484
- function create(lambdaToken: Token, expression: ExpressionNode): LambdaNode;
521
+ function create(lambdaToken: Token, expr: ExpressionNode): LambdaNode;
485
522
  }
486
- export interface NameNode extends ParseNodeBase {
487
- readonly nodeType: ParseNodeType.Name;
488
- token: IdentifierToken;
489
- value: string;
523
+ export interface NameNode extends ParseNodeBase<ParseNodeType.Name> {
524
+ d: {
525
+ token: IdentifierToken;
526
+ value: string;
527
+ };
490
528
  }
491
529
  export declare namespace NameNode {
492
530
  function create(nameToken: IdentifierToken): NameNode;
493
531
  }
494
- export interface ConstantNode extends ParseNodeBase {
495
- readonly nodeType: ParseNodeType.Constant;
496
- constType: KeywordType;
532
+ export interface ConstantNode extends ParseNodeBase<ParseNodeType.Constant> {
533
+ d: {
534
+ constType: KeywordType;
535
+ };
497
536
  }
498
537
  export declare namespace ConstantNode {
499
538
  function create(token: KeywordToken): ConstantNode;
500
539
  }
501
- export interface EllipsisNode extends ParseNodeBase {
502
- readonly nodeType: ParseNodeType.Ellipsis;
540
+ export interface EllipsisNode extends ParseNodeBase<ParseNodeType.Ellipsis> {
503
541
  }
504
542
  export declare namespace EllipsisNode {
505
543
  function create(range: TextRange): EllipsisNode;
506
544
  }
507
- export interface NumberNode extends ParseNodeBase {
508
- readonly nodeType: ParseNodeType.Number;
509
- value: number | bigint;
510
- isInteger: boolean;
511
- isImaginary: boolean;
545
+ export interface NumberNode extends ParseNodeBase<ParseNodeType.Number> {
546
+ d: {
547
+ value: number | bigint;
548
+ isInteger: boolean;
549
+ isImaginary: boolean;
550
+ };
512
551
  }
513
552
  export declare namespace NumberNode {
514
553
  function create(token: NumberToken): NumberNode;
515
554
  }
516
- export interface StringNode extends ParseNodeBase {
517
- readonly nodeType: ParseNodeType.String;
518
- token: StringToken;
519
- value: string;
555
+ export interface StringNode extends ParseNodeBase<ParseNodeType.String> {
556
+ d: {
557
+ token: StringToken;
558
+ value: string;
559
+ };
520
560
  }
521
561
  export declare namespace StringNode {
522
- function create(token: StringToken, unescapedValue: string): StringNode;
562
+ function create(token: StringToken, value: string): StringNode;
523
563
  }
524
- export interface FormatStringNode extends ParseNodeBase {
525
- readonly nodeType: ParseNodeType.FormatString;
526
- token: FStringStartToken;
527
- middleTokens: FStringMiddleToken[];
528
- fieldExpressions: ExpressionNode[];
529
- formatExpressions: ExpressionNode[];
530
- value: '';
564
+ export interface FormatStringNode extends ParseNodeBase<ParseNodeType.FormatString> {
565
+ d: {
566
+ token: FStringStartToken;
567
+ middleTokens: FStringMiddleToken[];
568
+ fieldExprs: ExpressionNode[];
569
+ formatExprs: ExpressionNode[];
570
+ value: '';
571
+ };
531
572
  }
532
573
  export declare namespace FormatStringNode {
533
- function create(startToken: FStringStartToken, endToken: FStringEndToken | undefined, middleTokens: FStringMiddleToken[], fieldExpressions: ExpressionNode[], formatExpressions: ExpressionNode[]): FormatStringNode;
574
+ function create(startToken: FStringStartToken, endToken: FStringEndToken | undefined, middleTokens: FStringMiddleToken[], fieldExprs: ExpressionNode[], formatExprs: ExpressionNode[]): FormatStringNode;
534
575
  }
535
- export interface StringListNode extends ParseNodeBase {
536
- readonly nodeType: ParseNodeType.StringList;
537
- strings: (StringNode | FormatStringNode)[];
538
- typeAnnotation?: ExpressionNode;
539
- isParenthesized?: boolean;
576
+ export interface StringListNode extends ParseNodeBase<ParseNodeType.StringList> {
577
+ d: {
578
+ strings: (StringNode | FormatStringNode)[];
579
+ annotation: ExpressionNode | undefined;
580
+ hasParens: boolean;
581
+ };
540
582
  }
541
583
  export declare namespace StringListNode {
542
584
  function create(strings: (StringNode | FormatStringNode)[]): StringListNode;
543
585
  }
544
- export interface DictionaryNode extends ParseNodeBase {
545
- readonly nodeType: ParseNodeType.Dictionary;
546
- entries: DictionaryEntryNode[];
547
- trailingCommaToken?: Token;
586
+ export interface DictionaryNode extends ParseNodeBase<ParseNodeType.Dictionary> {
587
+ d: {
588
+ items: DictionaryEntryNode[];
589
+ trailingCommaToken: Token | undefined;
590
+ };
548
591
  }
549
592
  export declare namespace DictionaryNode {
550
593
  function create(range: TextRange): DictionaryNode;
551
594
  }
552
- export interface DictionaryKeyEntryNode extends ParseNodeBase {
553
- readonly nodeType: ParseNodeType.DictionaryKeyEntry;
554
- keyExpression: ExpressionNode;
555
- valueExpression: ExpressionNode;
595
+ export interface DictionaryKeyEntryNode extends ParseNodeBase<ParseNodeType.DictionaryKeyEntry> {
596
+ d: {
597
+ keyExpr: ExpressionNode;
598
+ valueExpr: ExpressionNode;
599
+ };
556
600
  }
557
601
  export declare namespace DictionaryKeyEntryNode {
558
- function create(keyExpression: ExpressionNode, valueExpression: ExpressionNode): DictionaryKeyEntryNode;
602
+ function create(keyExpr: ExpressionNode, valueExpr: ExpressionNode): DictionaryKeyEntryNode;
559
603
  }
560
- export interface DictionaryExpandEntryNode extends ParseNodeBase {
561
- readonly nodeType: ParseNodeType.DictionaryExpandEntry;
562
- expandExpression: ExpressionNode;
604
+ export interface DictionaryExpandEntryNode extends ParseNodeBase<ParseNodeType.DictionaryExpandEntry> {
605
+ d: {
606
+ expr: ExpressionNode;
607
+ };
563
608
  }
564
609
  export declare namespace DictionaryExpandEntryNode {
565
- function create(expandExpression: ExpressionNode): DictionaryExpandEntryNode;
610
+ function create(expr: ExpressionNode): DictionaryExpandEntryNode;
566
611
  }
567
612
  export type DictionaryEntryNode = DictionaryKeyEntryNode | DictionaryExpandEntryNode | ComprehensionNode;
568
- export interface SetNode extends ParseNodeBase {
569
- readonly nodeType: ParseNodeType.Set;
570
- entries: ExpressionNode[];
613
+ export interface SetNode extends ParseNodeBase<ParseNodeType.Set> {
614
+ d: {
615
+ items: ExpressionNode[];
616
+ };
571
617
  }
572
618
  export declare namespace SetNode {
573
619
  function create(range: TextRange): SetNode;
574
620
  }
575
- export interface ListNode extends ParseNodeBase {
576
- readonly nodeType: ParseNodeType.List;
577
- entries: ExpressionNode[];
621
+ export interface ListNode extends ParseNodeBase<ParseNodeType.List> {
622
+ d: {
623
+ items: ExpressionNode[];
624
+ };
578
625
  }
579
626
  export declare namespace ListNode {
580
627
  function create(range: TextRange): ListNode;
@@ -584,217 +631,239 @@ export declare const enum ArgumentCategory {
584
631
  UnpackedList = 1,
585
632
  UnpackedDictionary = 2
586
633
  }
587
- export interface ArgumentNode extends ParseNodeBase {
588
- readonly nodeType: ParseNodeType.Argument;
589
- argumentCategory: ArgumentCategory;
590
- name?: NameNode | undefined;
591
- valueExpression: ExpressionNode;
634
+ export interface ArgumentNode extends ParseNodeBase<ParseNodeType.Argument> {
635
+ d: {
636
+ argCategory: ArgumentCategory;
637
+ name: NameNode | undefined;
638
+ valueExpr: ExpressionNode;
639
+ isNameSameAsValue: boolean;
640
+ };
592
641
  }
593
642
  export declare namespace ArgumentNode {
594
- function create(startToken: Token | undefined, valueExpression: ExpressionNode, argCategory: ArgumentCategory): ArgumentNode;
643
+ function create(startToken: Token | undefined, valueExpr: ExpressionNode, argCategory: ArgumentCategory): ArgumentNode;
595
644
  }
596
- export interface DelNode extends ParseNodeBase {
597
- readonly nodeType: ParseNodeType.Del;
598
- expressions: ExpressionNode[];
645
+ export interface DelNode extends ParseNodeBase<ParseNodeType.Del> {
646
+ d: {
647
+ targets: ExpressionNode[];
648
+ };
599
649
  }
600
650
  export declare namespace DelNode {
601
651
  function create(delToken: Token): DelNode;
602
652
  }
603
- export interface PassNode extends ParseNodeBase {
604
- readonly nodeType: ParseNodeType.Pass;
653
+ export interface PassNode extends ParseNodeBase<ParseNodeType.Pass> {
605
654
  }
606
655
  export declare namespace PassNode {
607
656
  function create(passToken: TextRange): PassNode;
608
657
  }
609
- export interface ImportNode extends ParseNodeBase {
610
- readonly nodeType: ParseNodeType.Import;
611
- list: ImportAsNode[];
658
+ export interface ImportNode extends ParseNodeBase<ParseNodeType.Import> {
659
+ d: {
660
+ list: ImportAsNode[];
661
+ };
612
662
  }
613
663
  export declare namespace ImportNode {
614
- function create(passToken: TextRange): ImportNode;
664
+ function create(importToken: TextRange): ImportNode;
615
665
  }
616
- export interface ModuleNameNode extends ParseNodeBase {
617
- readonly nodeType: ParseNodeType.ModuleName;
618
- leadingDots: number;
619
- nameParts: NameNode[];
620
- hasTrailingDot?: boolean;
666
+ export interface ModuleNameNode extends ParseNodeBase<ParseNodeType.ModuleName> {
667
+ d: {
668
+ leadingDots: number;
669
+ nameParts: NameNode[];
670
+ hasTrailingDot?: boolean;
671
+ };
621
672
  }
622
673
  export declare namespace ModuleNameNode {
623
674
  function create(range: TextRange): ModuleNameNode;
624
675
  }
625
- export interface ImportAsNode extends ParseNodeBase {
626
- readonly nodeType: ParseNodeType.ImportAs;
627
- module: ModuleNameNode;
628
- alias?: NameNode | undefined;
676
+ export interface ImportAsNode extends ParseNodeBase<ParseNodeType.ImportAs> {
677
+ d: {
678
+ module: ModuleNameNode;
679
+ alias?: NameNode | undefined;
680
+ };
629
681
  }
630
682
  export declare namespace ImportAsNode {
631
683
  function create(module: ModuleNameNode): ImportAsNode;
632
684
  }
633
- export interface ImportFromNode extends ParseNodeBase {
634
- readonly nodeType: ParseNodeType.ImportFrom;
635
- module: ModuleNameNode;
636
- imports: ImportFromAsNode[];
637
- isWildcardImport: boolean;
638
- usesParens: boolean;
639
- wildcardToken?: Token;
640
- missingImportKeyword?: boolean;
685
+ export interface ImportFromNode extends ParseNodeBase<ParseNodeType.ImportFrom> {
686
+ d: {
687
+ module: ModuleNameNode;
688
+ imports: ImportFromAsNode[];
689
+ isWildcardImport: boolean;
690
+ usesParens: boolean;
691
+ wildcardToken?: Token;
692
+ missingImport?: boolean;
693
+ };
641
694
  }
642
695
  export declare namespace ImportFromNode {
643
696
  function create(fromToken: Token, module: ModuleNameNode): ImportFromNode;
644
697
  }
645
- export interface ImportFromAsNode extends ParseNodeBase {
646
- readonly nodeType: ParseNodeType.ImportFromAs;
647
- name: NameNode;
648
- alias?: NameNode | undefined;
698
+ export interface ImportFromAsNode extends ParseNodeBase<ParseNodeType.ImportFromAs> {
699
+ d: {
700
+ name: NameNode;
701
+ alias?: NameNode | undefined;
702
+ };
649
703
  }
650
704
  export declare namespace ImportFromAsNode {
651
705
  function create(name: NameNode): ImportFromAsNode;
652
706
  }
653
- export interface GlobalNode extends ParseNodeBase {
654
- readonly nodeType: ParseNodeType.Global;
655
- nameList: NameNode[];
707
+ export interface GlobalNode extends ParseNodeBase<ParseNodeType.Global> {
708
+ d: {
709
+ targets: NameNode[];
710
+ };
656
711
  }
657
712
  export declare namespace GlobalNode {
658
713
  function create(range: TextRange): GlobalNode;
659
714
  }
660
- export interface NonlocalNode extends ParseNodeBase {
661
- readonly nodeType: ParseNodeType.Nonlocal;
662
- nameList: NameNode[];
715
+ export interface NonlocalNode extends ParseNodeBase<ParseNodeType.Nonlocal> {
716
+ d: {
717
+ targets: NameNode[];
718
+ };
663
719
  }
664
720
  export declare namespace NonlocalNode {
665
721
  function create(range: TextRange): NonlocalNode;
666
722
  }
667
- export interface AssertNode extends ParseNodeBase {
668
- readonly nodeType: ParseNodeType.Assert;
669
- testExpression: ExpressionNode;
670
- exceptionExpression?: ExpressionNode | undefined;
723
+ export interface AssertNode extends ParseNodeBase<ParseNodeType.Assert> {
724
+ d: {
725
+ testExpr: ExpressionNode;
726
+ exceptionExpr?: ExpressionNode | undefined;
727
+ };
671
728
  }
672
729
  export declare namespace AssertNode {
673
- function create(assertToken: Token, testExpression: ExpressionNode): AssertNode;
730
+ function create(assertToken: Token, testExpr: ExpressionNode): AssertNode;
674
731
  }
675
- export interface BreakNode extends ParseNodeBase {
676
- readonly nodeType: ParseNodeType.Break;
732
+ export interface BreakNode extends ParseNodeBase<ParseNodeType.Break> {
677
733
  }
678
734
  export declare namespace BreakNode {
679
735
  function create(range: TextRange): BreakNode;
680
736
  }
681
- export interface ContinueNode extends ParseNodeBase {
682
- readonly nodeType: ParseNodeType.Continue;
737
+ export interface ContinueNode extends ParseNodeBase<ParseNodeType.Continue> {
683
738
  }
684
739
  export declare namespace ContinueNode {
685
740
  function create(range: TextRange): ContinueNode;
686
741
  }
687
- export interface ReturnNode extends ParseNodeBase {
688
- readonly nodeType: ParseNodeType.Return;
689
- returnExpression?: ExpressionNode | undefined;
742
+ export interface ReturnNode extends ParseNodeBase<ParseNodeType.Return> {
743
+ d: {
744
+ expr?: ExpressionNode | undefined;
745
+ };
690
746
  }
691
747
  export declare namespace ReturnNode {
692
748
  function create(range: TextRange): ReturnNode;
693
749
  }
694
- export interface RaiseNode extends ParseNodeBase {
695
- readonly nodeType: ParseNodeType.Raise;
696
- typeExpression?: ExpressionNode | undefined;
697
- valueExpression?: ExpressionNode | undefined;
698
- tracebackExpression?: ExpressionNode | undefined;
750
+ export interface RaiseNode extends ParseNodeBase<ParseNodeType.Raise> {
751
+ d: {
752
+ typeExpression?: ExpressionNode | undefined;
753
+ valueExpression?: ExpressionNode | undefined;
754
+ tracebackExpression?: ExpressionNode | undefined;
755
+ };
699
756
  }
700
757
  export declare namespace RaiseNode {
701
758
  function create(range: TextRange): RaiseNode;
702
759
  }
703
- export interface MatchNode extends ParseNodeBase {
704
- readonly nodeType: ParseNodeType.Match;
705
- subjectExpression: ExpressionNode;
706
- cases: CaseNode[];
760
+ export interface MatchNode extends ParseNodeBase<ParseNodeType.Match> {
761
+ d: {
762
+ expr: ExpressionNode;
763
+ cases: CaseNode[];
764
+ };
707
765
  }
708
766
  export declare namespace MatchNode {
709
- function create(matchToken: TextRange, subjectExpression: ExpressionNode): MatchNode;
767
+ function create(matchToken: TextRange, expr: ExpressionNode): MatchNode;
710
768
  }
711
- export interface CaseNode extends ParseNodeBase {
712
- readonly nodeType: ParseNodeType.Case;
713
- pattern: PatternAtomNode;
714
- isIrrefutable: boolean;
715
- guardExpression?: ExpressionNode | undefined;
716
- suite: SuiteNode;
769
+ export interface CaseNode extends ParseNodeBase<ParseNodeType.Case> {
770
+ d: {
771
+ pattern: PatternAtomNode;
772
+ isIrrefutable: boolean;
773
+ guardExpr?: ExpressionNode | undefined;
774
+ suite: SuiteNode;
775
+ };
717
776
  }
718
777
  export declare namespace CaseNode {
719
- function create(caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpression: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
778
+ function create(caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpr: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
720
779
  }
721
- export interface PatternSequenceNode extends ParseNodeBase {
722
- readonly nodeType: ParseNodeType.PatternSequence;
723
- entries: PatternAsNode[];
724
- starEntryIndex: number | undefined;
780
+ export interface PatternSequenceNode extends ParseNodeBase<ParseNodeType.PatternSequence> {
781
+ d: {
782
+ entries: PatternAsNode[];
783
+ starEntryIndex: number | undefined;
784
+ };
725
785
  }
726
786
  export declare namespace PatternSequenceNode {
727
787
  function create(firstToken: TextRange, entries: PatternAsNode[]): PatternSequenceNode;
728
788
  }
729
- export interface PatternAsNode extends ParseNodeBase {
730
- readonly nodeType: ParseNodeType.PatternAs;
731
- orPatterns: PatternAtomNode[];
732
- target?: NameNode | undefined;
789
+ export interface PatternAsNode extends ParseNodeBase<ParseNodeType.PatternAs> {
790
+ d: {
791
+ orPatterns: PatternAtomNode[];
792
+ target?: NameNode | undefined;
793
+ };
733
794
  }
734
795
  export declare namespace PatternAsNode {
735
796
  function create(orPatterns: PatternAtomNode[], target?: NameNode): PatternAsNode;
736
797
  }
737
- export interface PatternLiteralNode extends ParseNodeBase {
738
- readonly nodeType: ParseNodeType.PatternLiteral;
739
- expression: ExpressionNode;
798
+ export interface PatternLiteralNode extends ParseNodeBase<ParseNodeType.PatternLiteral> {
799
+ d: {
800
+ expr: ExpressionNode;
801
+ };
740
802
  }
741
803
  export declare namespace PatternLiteralNode {
742
- function create(expression: ExpressionNode): PatternLiteralNode;
804
+ function create(expr: ExpressionNode): PatternLiteralNode;
743
805
  }
744
- export interface PatternClassNode extends ParseNodeBase {
745
- readonly nodeType: ParseNodeType.PatternClass;
746
- className: NameNode | MemberAccessNode;
747
- arguments: PatternClassArgumentNode[];
806
+ export interface PatternClassNode extends ParseNodeBase<ParseNodeType.PatternClass> {
807
+ d: {
808
+ className: NameNode | MemberAccessNode;
809
+ args: PatternClassArgumentNode[];
810
+ };
748
811
  }
749
812
  export declare namespace PatternClassNode {
750
813
  function create(className: NameNode | MemberAccessNode, args: PatternClassArgumentNode[]): PatternClassNode;
751
814
  }
752
- export interface PatternClassArgumentNode extends ParseNodeBase {
753
- readonly nodeType: ParseNodeType.PatternClassArgument;
754
- name?: NameNode | undefined;
755
- pattern: PatternAsNode;
815
+ export interface PatternClassArgumentNode extends ParseNodeBase<ParseNodeType.PatternClassArgument> {
816
+ d: {
817
+ name?: NameNode | undefined;
818
+ pattern: PatternAsNode;
819
+ };
756
820
  }
757
821
  export declare namespace PatternClassArgumentNode {
758
822
  function create(pattern: PatternAsNode, name?: NameNode): PatternClassArgumentNode;
759
823
  }
760
- export interface PatternCaptureNode extends ParseNodeBase {
761
- readonly nodeType: ParseNodeType.PatternCapture;
762
- target: NameNode;
763
- isStar: boolean;
764
- isWildcard: boolean;
824
+ export interface PatternCaptureNode extends ParseNodeBase<ParseNodeType.PatternCapture> {
825
+ d: {
826
+ target: NameNode;
827
+ isStar: boolean;
828
+ isWildcard: boolean;
829
+ };
765
830
  }
766
831
  export declare namespace PatternCaptureNode {
767
832
  function create(target: NameNode, starToken?: TextRange): PatternCaptureNode;
768
833
  }
769
- export interface PatternMappingNode extends ParseNodeBase {
770
- readonly nodeType: ParseNodeType.PatternMapping;
771
- entries: PatternMappingEntryNode[];
834
+ export interface PatternMappingNode extends ParseNodeBase<ParseNodeType.PatternMapping> {
835
+ d: {
836
+ entries: PatternMappingEntryNode[];
837
+ };
772
838
  }
773
839
  export declare namespace PatternMappingNode {
774
840
  function create(startToken: TextRange, entries: PatternMappingEntryNode[]): PatternMappingNode;
775
841
  }
776
842
  export type PatternMappingEntryNode = PatternMappingKeyEntryNode | PatternMappingExpandEntryNode;
777
- export interface PatternMappingKeyEntryNode extends ParseNodeBase {
778
- readonly nodeType: ParseNodeType.PatternMappingKeyEntry;
779
- keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode;
780
- valuePattern: PatternAsNode | ErrorNode;
843
+ export interface PatternMappingKeyEntryNode extends ParseNodeBase<ParseNodeType.PatternMappingKeyEntry> {
844
+ d: {
845
+ keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode;
846
+ valuePattern: PatternAsNode | ErrorNode;
847
+ };
781
848
  }
782
849
  export declare namespace PatternMappingKeyEntryNode {
783
850
  function create(keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode, valuePattern: PatternAsNode | ErrorNode): PatternMappingKeyEntryNode;
784
851
  }
785
- export interface PatternMappingExpandEntryNode extends ParseNodeBase {
786
- readonly nodeType: ParseNodeType.PatternMappingExpandEntry;
787
- target: NameNode;
852
+ export interface PatternMappingExpandEntryNode extends ParseNodeBase<ParseNodeType.PatternMappingExpandEntry> {
853
+ d: {
854
+ target: NameNode;
855
+ };
788
856
  }
789
857
  export declare namespace PatternMappingExpandEntryNode {
790
858
  function create(starStarToken: TextRange, target: NameNode): PatternMappingExpandEntryNode;
791
859
  }
792
- export interface PatternValueNode extends ParseNodeBase {
793
- readonly nodeType: ParseNodeType.PatternValue;
794
- expression: MemberAccessNode;
860
+ export interface PatternValueNode extends ParseNodeBase<ParseNodeType.PatternValue> {
861
+ d: {
862
+ expr: MemberAccessNode;
863
+ };
795
864
  }
796
865
  export declare namespace PatternValueNode {
797
- function create(expression: MemberAccessNode): PatternValueNode;
866
+ function create(expr: MemberAccessNode): PatternValueNode;
798
867
  }
799
868
  export type PatternAtomNode = PatternSequenceNode | PatternLiteralNode | PatternClassNode | PatternAsNode | PatternCaptureNode | PatternMappingNode | PatternValueNode | ErrorNode;
800
869
  export type ParseNode = ErrorNode | ArgumentNode | AssertNode | AssignmentExpressionNode | AssignmentNode | AugmentedAssignmentNode | AwaitNode | BinaryOperationNode | BreakNode | CallNode | CaseNode | ClassNode | ComprehensionNode | ComprehensionForNode | ComprehensionIfNode | ConstantNode | ContinueNode | DecoratorNode | DelNode | DictionaryNode | DictionaryExpandEntryNode | DictionaryKeyEntryNode | EllipsisNode | IfNode | ImportNode | ImportAsNode | ImportFromNode | ImportFromAsNode | IndexNode | ExceptNode | ForNode | FormatStringNode | FunctionNode | FunctionAnnotationNode | GlobalNode | LambdaNode | ListNode | MatchNode | MemberAccessNode | ModuleNameNode | ModuleNode | NameNode | NonlocalNode | NumberNode | ParameterNode | PassNode | PatternAsNode | PatternClassNode | PatternClassArgumentNode | PatternCaptureNode | PatternLiteralNode | PatternMappingExpandEntryNode | PatternMappingKeyEntryNode | PatternMappingNode | PatternSequenceNode | PatternValueNode | RaiseNode | ReturnNode | SetNode | SliceNode | StatementListNode | StringListNode | StringNode | SuiteNode | TernaryNode | TupleNode | TryNode | TypeAliasNode | TypeAnnotationNode | TypeParameterNode | TypeParameterListNode | UnaryOperationNode | UnpackNode | WhileNode | WithNode | WithItemNode | YieldNode | YieldFromNode;