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