@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.
- package/dist/analyzer/analyzerNodeInfo.js +74 -46
- package/dist/analyzer/analyzerNodeInfo.js.map +1 -1
- package/dist/analyzer/binder.js +506 -512
- package/dist/analyzer/binder.js.map +1 -1
- package/dist/analyzer/checker.js +649 -634
- package/dist/analyzer/checker.js.map +1 -1
- package/dist/analyzer/codeFlowEngine.d.ts +5 -3
- package/dist/analyzer/codeFlowEngine.js +87 -101
- package/dist/analyzer/codeFlowEngine.js.map +1 -1
- package/dist/analyzer/codeFlowTypes.js +30 -28
- package/dist/analyzer/codeFlowTypes.js.map +1 -1
- package/dist/analyzer/constraintSolver.js +68 -64
- package/dist/analyzer/constraintSolver.js.map +1 -1
- package/dist/analyzer/constructorTransform.js +22 -22
- package/dist/analyzer/constructorTransform.js.map +1 -1
- package/dist/analyzer/constructors.js +51 -48
- package/dist/analyzer/constructors.js.map +1 -1
- package/dist/analyzer/dataClasses.js +109 -175
- package/dist/analyzer/dataClasses.js.map +1 -1
- package/dist/analyzer/declarationUtils.js +14 -15
- package/dist/analyzer/declarationUtils.js.map +1 -1
- package/dist/analyzer/decorators.js +77 -77
- package/dist/analyzer/decorators.js.map +1 -1
- package/dist/analyzer/enums.js +70 -56
- package/dist/analyzer/enums.js.map +1 -1
- package/dist/analyzer/functionTransform.js +8 -18
- package/dist/analyzer/functionTransform.js.map +1 -1
- package/dist/analyzer/importResolver.d.ts +2 -1
- package/dist/analyzer/importResolver.js +40 -29
- package/dist/analyzer/importResolver.js.map +1 -1
- package/dist/analyzer/importStatementUtils.js +27 -27
- package/dist/analyzer/importStatementUtils.js.map +1 -1
- package/dist/analyzer/namedTuples.js +33 -59
- package/dist/analyzer/namedTuples.js.map +1 -1
- package/dist/analyzer/operations.js +66 -66
- package/dist/analyzer/operations.js.map +1 -1
- package/dist/analyzer/packageTypeVerifier.js +66 -62
- package/dist/analyzer/packageTypeVerifier.js.map +1 -1
- package/dist/analyzer/parameterUtils.d.ts +4 -4
- package/dist/analyzer/parameterUtils.js +28 -46
- package/dist/analyzer/parameterUtils.js.map +1 -1
- package/dist/analyzer/parseTreeUtils.js +268 -269
- package/dist/analyzer/parseTreeUtils.js.map +1 -1
- package/dist/analyzer/parseTreeWalker.js +76 -76
- package/dist/analyzer/parseTreeWalker.js.map +1 -1
- package/dist/analyzer/patternMatching.js +176 -143
- package/dist/analyzer/patternMatching.js.map +1 -1
- package/dist/analyzer/program.js +1 -1
- package/dist/analyzer/program.js.map +1 -1
- package/dist/analyzer/properties.js +78 -147
- package/dist/analyzer/properties.js.map +1 -1
- package/dist/analyzer/protocols.js +21 -21
- package/dist/analyzer/protocols.js.map +1 -1
- package/dist/analyzer/sourceFile.js +3 -3
- package/dist/analyzer/sourceFile.js.map +1 -1
- package/dist/analyzer/sourceMapper.js +20 -19
- package/dist/analyzer/sourceMapper.js.map +1 -1
- package/dist/analyzer/staticExpressions.js +83 -84
- package/dist/analyzer/staticExpressions.js.map +1 -1
- package/dist/analyzer/testWalker.js +2 -2
- package/dist/analyzer/testWalker.js.map +1 -1
- package/dist/analyzer/tracePrinter.js +20 -20
- package/dist/analyzer/tracePrinter.js.map +1 -1
- package/dist/analyzer/typeDocStringUtils.js +25 -25
- package/dist/analyzer/typeDocStringUtils.js.map +1 -1
- package/dist/analyzer/typeEvaluator.js +1884 -1937
- package/dist/analyzer/typeEvaluator.js.map +1 -1
- package/dist/analyzer/typeEvaluatorTypes.d.ts +6 -5
- package/dist/analyzer/typeEvaluatorTypes.js +4 -1
- package/dist/analyzer/typeEvaluatorTypes.js.map +1 -1
- package/dist/analyzer/typeGuards.js +211 -211
- package/dist/analyzer/typeGuards.js.map +1 -1
- package/dist/analyzer/typePrinter.js +118 -115
- package/dist/analyzer/typePrinter.js.map +1 -1
- package/dist/analyzer/typeStubWriter.js +104 -103
- package/dist/analyzer/typeStubWriter.js.map +1 -1
- package/dist/analyzer/typeUtils.d.ts +14 -3
- package/dist/analyzer/typeUtils.js +432 -402
- package/dist/analyzer/typeUtils.js.map +1 -1
- package/dist/analyzer/typeVarContext.js +8 -8
- package/dist/analyzer/typeVarContext.js.map +1 -1
- package/dist/analyzer/typeWalker.js +13 -10
- package/dist/analyzer/typeWalker.js.map +1 -1
- package/dist/analyzer/typedDicts.js +96 -198
- package/dist/analyzer/typedDicts.js.map +1 -1
- package/dist/analyzer/types.d.ts +144 -102
- package/dist/analyzer/types.js +662 -494
- package/dist/analyzer/types.js.map +1 -1
- package/dist/commands/dumpFileDebugInfoCommand.js +33 -33
- package/dist/commands/dumpFileDebugInfoCommand.js.map +1 -1
- package/dist/common/fileSystem.d.ts +1 -0
- package/dist/common/fileSystem.js.map +1 -1
- package/dist/common/fullAccessHost.js +6 -4
- package/dist/common/fullAccessHost.js.map +1 -1
- package/dist/common/realFileSystem.d.ts +1 -0
- package/dist/common/realFileSystem.js +4 -0
- package/dist/common/realFileSystem.js.map +1 -1
- package/dist/common/textEditTracker.js +14 -14
- package/dist/common/textEditTracker.js.map +1 -1
- package/dist/languageService/autoImporter.js +10 -10
- package/dist/languageService/autoImporter.js.map +1 -1
- package/dist/languageService/callHierarchyProvider.js +23 -23
- package/dist/languageService/callHierarchyProvider.js.map +1 -1
- package/dist/languageService/completionProvider.js +153 -151
- package/dist/languageService/completionProvider.js.map +1 -1
- package/dist/languageService/definitionProvider.d.ts +1 -1
- package/dist/languageService/definitionProvider.js +3 -1
- package/dist/languageService/definitionProvider.js.map +1 -1
- package/dist/languageService/documentSymbolCollector.js +19 -19
- package/dist/languageService/documentSymbolCollector.js.map +1 -1
- package/dist/languageService/hoverProvider.js +25 -24
- package/dist/languageService/hoverProvider.js.map +1 -1
- package/dist/languageService/importSorter.js +8 -8
- package/dist/languageService/importSorter.js.map +1 -1
- package/dist/languageService/referencesProvider.js +8 -8
- package/dist/languageService/referencesProvider.js.map +1 -1
- package/dist/languageService/signatureHelpProvider.d.ts +1 -1
- package/dist/languageService/signatureHelpProvider.js +6 -6
- package/dist/languageService/signatureHelpProvider.js.map +1 -1
- package/dist/languageService/symbolIndexer.js +3 -3
- package/dist/languageService/symbolIndexer.js.map +1 -1
- package/dist/languageService/tooltipUtils.js +13 -13
- package/dist/languageService/tooltipUtils.js.map +1 -1
- package/dist/parser/parseNodes.d.ts +468 -401
- package/dist/parser/parseNodes.js +626 -355
- package/dist/parser/parseNodes.js.map +1 -1
- package/dist/parser/parser.d.ts +1 -0
- package/dist/parser/parser.js +316 -294
- package/dist/parser/parser.js.map +1 -1
- package/dist/tests/classDeclaration.test.js +14 -14
- package/dist/tests/classDeclaration.test.js.map +1 -1
- package/dist/tests/harness/vfs/filesystem.d.ts +3 -2
- package/dist/tests/harness/vfs/filesystem.js +6 -2
- package/dist/tests/harness/vfs/filesystem.js.map +1 -1
- package/dist/tests/importResolver.test.js +4 -3
- package/dist/tests/importResolver.test.js.map +1 -1
- package/dist/tests/parseTreeUtils.test.js +5 -5
- package/dist/tests/parseTreeUtils.test.js.map +1 -1
- package/dist/tests/parser.test.js +8 -8
- package/dist/tests/parser.test.js.map +1 -1
- package/dist/tests/sourceMapperUtils.test.js +7 -7
- package/dist/tests/sourceMapperUtils.test.js.map +1 -1
- package/dist/tests/typeEvaluator3.test.js +8 -3
- package/dist/tests/typeEvaluator3.test.js.map +1 -1
- package/dist/tests/typePrinter.test.js +14 -39
- package/dist/tests/typePrinter.test.js.map +1 -1
- 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
|
101
|
-
|
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
|
110
|
-
|
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
|
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
|
-
|
117
|
-
|
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
|
-
|
124
|
-
|
125
|
-
|
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
|
-
|
132
|
-
|
133
|
-
|
134
|
-
|
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,
|
137
|
+
function create(ifOrElifToken: Token, testExpr: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
|
138
138
|
}
|
139
|
-
export interface WhileNode extends ParseNodeBase {
|
140
|
-
|
141
|
-
|
142
|
-
|
143
|
-
|
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,
|
147
|
-
}
|
148
|
-
export interface ForNode extends ParseNodeBase {
|
149
|
-
|
150
|
-
|
151
|
-
|
152
|
-
|
153
|
-
|
154
|
-
|
155
|
-
|
156
|
-
|
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,
|
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
|
-
|
164
|
-
|
165
|
-
|
166
|
-
|
167
|
-
|
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,
|
173
|
+
function create(startToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode): ComprehensionForNode;
|
171
174
|
}
|
172
|
-
export interface ComprehensionIfNode extends ParseNodeBase {
|
173
|
-
|
174
|
-
|
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,
|
181
|
+
function create(ifToken: Token, testExpr: ExpressionNode): ComprehensionIfNode;
|
178
182
|
}
|
179
|
-
export interface TryNode extends ParseNodeBase {
|
180
|
-
|
181
|
-
|
182
|
-
|
183
|
-
|
184
|
-
|
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
|
-
|
191
|
-
|
192
|
-
|
193
|
-
|
194
|
-
|
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
|
-
|
201
|
-
|
202
|
-
|
203
|
-
|
204
|
-
|
205
|
-
|
206
|
-
|
207
|
-
|
208
|
-
|
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,
|
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
|
-
|
220
|
-
|
221
|
-
|
222
|
-
|
223
|
-
|
224
|
-
|
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
|
-
|
231
|
-
|
232
|
-
|
233
|
-
|
234
|
-
|
235
|
-
|
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,
|
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
|
-
|
243
|
-
|
244
|
-
|
245
|
-
|
246
|
-
|
247
|
-
|
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
|
-
|
254
|
-
|
255
|
-
|
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(
|
269
|
+
function create(expr: ExpressionNode): WithItemNode;
|
259
270
|
}
|
260
|
-
export interface DecoratorNode extends ParseNodeBase {
|
261
|
-
|
262
|
-
|
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,
|
277
|
+
function create(atToken: Token, expr: ExpressionNode): DecoratorNode;
|
266
278
|
}
|
267
|
-
export interface StatementListNode extends ParseNodeBase {
|
268
|
-
|
269
|
-
|
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
|
-
|
280
|
-
|
281
|
-
|
282
|
-
|
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
|
-
|
289
|
-
|
290
|
-
|
291
|
-
|
292
|
-
|
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,
|
310
|
+
function create(operatorToken: Token, expr: ExpressionNode, operator: OperatorType): UnaryOperationNode;
|
296
311
|
}
|
297
|
-
export interface BinaryOperationNode extends ParseNodeBase {
|
298
|
-
|
299
|
-
|
300
|
-
|
301
|
-
|
302
|
-
|
303
|
-
|
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(
|
322
|
+
function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
|
307
323
|
}
|
308
|
-
export interface AssignmentExpressionNode extends ParseNodeBase {
|
309
|
-
|
310
|
-
|
311
|
-
|
312
|
-
|
313
|
-
|
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,
|
333
|
+
function create(name: NameNode, walrusToken: Token, rightExpr: ExpressionNode): AssignmentExpressionNode;
|
317
334
|
}
|
318
|
-
export interface AssignmentNode extends ParseNodeBase {
|
319
|
-
|
320
|
-
|
321
|
-
|
322
|
-
|
323
|
-
|
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(
|
344
|
+
function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode): AssignmentNode;
|
327
345
|
}
|
328
|
-
export declare enum
|
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
|
-
|
335
|
-
|
336
|
-
|
337
|
-
|
338
|
-
|
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,
|
360
|
+
function create(name: NameNode, typeParamKind: TypeParameterKind, boundExpr?: ExpressionNode, defaultExpr?: ExpressionNode): TypeParameterNode;
|
342
361
|
}
|
343
|
-
export interface TypeParameterListNode extends ParseNodeBase {
|
344
|
-
|
345
|
-
|
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,
|
368
|
+
function create(startToken: Token, endToken: Token, params: TypeParameterNode[]): TypeParameterListNode;
|
349
369
|
}
|
350
|
-
export interface TypeAliasNode extends ParseNodeBase {
|
351
|
-
|
352
|
-
|
353
|
-
|
354
|
-
|
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,
|
378
|
+
function create(typeToken: KeywordToken, name: NameNode, expr: ExpressionNode, typeParams?: TypeParameterListNode): TypeAliasNode;
|
358
379
|
}
|
359
|
-
export interface TypeAnnotationNode extends ParseNodeBase {
|
360
|
-
|
361
|
-
|
362
|
-
|
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(
|
387
|
+
function create(valueExpr: ExpressionNode, annotation: ExpressionNode): TypeAnnotationNode;
|
366
388
|
}
|
367
|
-
export interface FunctionAnnotationNode extends ParseNodeBase {
|
368
|
-
|
369
|
-
|
370
|
-
|
371
|
-
|
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,
|
397
|
+
function create(openParenToken: Token, isEllipsis: boolean, paramAnnotations: ExpressionNode[], returnAnnotation: ExpressionNode): FunctionAnnotationNode;
|
375
398
|
}
|
376
|
-
export interface AugmentedAssignmentNode extends ParseNodeBase {
|
377
|
-
|
378
|
-
|
379
|
-
|
380
|
-
|
381
|
-
|
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(
|
408
|
+
function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operator: OperatorType, destExpr: ExpressionNode): AugmentedAssignmentNode;
|
385
409
|
}
|
386
|
-
export interface AwaitNode extends ParseNodeBase {
|
387
|
-
|
388
|
-
|
389
|
-
|
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,
|
417
|
+
function create(awaitToken: Token, expr: ExpressionNode): AwaitNode;
|
393
418
|
}
|
394
|
-
export interface TernaryNode extends ParseNodeBase {
|
395
|
-
|
396
|
-
|
397
|
-
|
398
|
-
|
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(
|
427
|
+
function create(ifExpr: ExpressionNode, testExpr: ExpressionNode, elseExpr: ExpressionNode): TernaryNode;
|
402
428
|
}
|
403
|
-
export interface UnpackNode extends ParseNodeBase {
|
404
|
-
|
405
|
-
|
406
|
-
|
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,
|
436
|
+
function create(starToken: Token, expr: ExpressionNode): UnpackNode;
|
410
437
|
}
|
411
|
-
export interface TupleNode extends ParseNodeBase {
|
412
|
-
|
413
|
-
|
414
|
-
|
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,
|
445
|
+
function create(range: TextRange, hasParens: boolean): TupleNode;
|
418
446
|
}
|
419
|
-
export interface CallNode extends ParseNodeBase {
|
420
|
-
|
421
|
-
|
422
|
-
|
423
|
-
|
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(
|
455
|
+
function create(leftExpr: ExpressionNode, args: ArgumentNode[], trailingComma: boolean): CallNode;
|
427
456
|
}
|
428
|
-
export interface ComprehensionNode extends ParseNodeBase {
|
429
|
-
|
430
|
-
|
431
|
-
|
432
|
-
|
433
|
-
|
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(
|
466
|
+
function create(expr: ParseNode, isGenerator: boolean): ComprehensionNode;
|
437
467
|
}
|
438
|
-
export interface IndexNode extends ParseNodeBase {
|
439
|
-
|
440
|
-
|
441
|
-
|
442
|
-
|
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(
|
476
|
+
function create(leftExpr: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
|
446
477
|
}
|
447
|
-
export interface SliceNode extends ParseNodeBase {
|
448
|
-
|
449
|
-
|
450
|
-
|
451
|
-
|
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
|
-
|
458
|
-
|
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,
|
494
|
+
function create(yieldToken: Token, expr?: ExpressionNode): YieldNode;
|
462
495
|
}
|
463
|
-
export interface YieldFromNode extends ParseNodeBase {
|
464
|
-
|
465
|
-
|
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,
|
502
|
+
function create(yieldToken: Token, expr: ExpressionNode): YieldFromNode;
|
469
503
|
}
|
470
|
-
export interface MemberAccessNode extends ParseNodeBase {
|
471
|
-
|
472
|
-
|
473
|
-
|
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(
|
511
|
+
function create(leftExpr: ExpressionNode, member: NameNode): MemberAccessNode;
|
477
512
|
}
|
478
|
-
export interface LambdaNode extends ParseNodeBase {
|
479
|
-
|
480
|
-
|
481
|
-
|
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,
|
520
|
+
function create(lambdaToken: Token, expr: ExpressionNode): LambdaNode;
|
485
521
|
}
|
486
|
-
export interface NameNode extends ParseNodeBase {
|
487
|
-
|
488
|
-
|
489
|
-
|
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
|
-
|
496
|
-
|
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
|
-
|
509
|
-
|
510
|
-
|
511
|
-
|
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
|
-
|
518
|
-
|
519
|
-
|
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,
|
561
|
+
function create(token: StringToken, value: string): StringNode;
|
523
562
|
}
|
524
|
-
export interface FormatStringNode extends ParseNodeBase {
|
525
|
-
|
526
|
-
|
527
|
-
|
528
|
-
|
529
|
-
|
530
|
-
|
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[],
|
573
|
+
function create(startToken: FStringStartToken, endToken: FStringEndToken | undefined, middleTokens: FStringMiddleToken[], fieldExprs: ExpressionNode[], formatExprs: ExpressionNode[]): FormatStringNode;
|
534
574
|
}
|
535
|
-
export interface StringListNode extends ParseNodeBase {
|
536
|
-
|
537
|
-
|
538
|
-
|
539
|
-
|
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
|
-
|
546
|
-
|
547
|
-
|
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
|
-
|
554
|
-
|
555
|
-
|
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(
|
601
|
+
function create(keyExpr: ExpressionNode, valueExpr: ExpressionNode): DictionaryKeyEntryNode;
|
559
602
|
}
|
560
|
-
export interface DictionaryExpandEntryNode extends ParseNodeBase {
|
561
|
-
|
562
|
-
|
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(
|
609
|
+
function create(expr: ExpressionNode): DictionaryExpandEntryNode;
|
566
610
|
}
|
567
611
|
export type DictionaryEntryNode = DictionaryKeyEntryNode | DictionaryExpandEntryNode | ComprehensionNode;
|
568
|
-
export interface SetNode extends ParseNodeBase {
|
569
|
-
|
570
|
-
|
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
|
-
|
577
|
-
|
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
|
-
|
589
|
-
|
590
|
-
|
591
|
-
|
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,
|
641
|
+
function create(startToken: Token | undefined, valueExpr: ExpressionNode, argCategory: ArgumentCategory): ArgumentNode;
|
595
642
|
}
|
596
|
-
export interface DelNode extends ParseNodeBase {
|
597
|
-
|
598
|
-
|
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
|
-
|
611
|
-
|
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(
|
662
|
+
function create(importToken: TextRange): ImportNode;
|
615
663
|
}
|
616
|
-
export interface ModuleNameNode extends ParseNodeBase {
|
617
|
-
|
618
|
-
|
619
|
-
|
620
|
-
|
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
|
-
|
627
|
-
|
628
|
-
|
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
|
-
|
635
|
-
|
636
|
-
|
637
|
-
|
638
|
-
|
639
|
-
|
640
|
-
|
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
|
-
|
647
|
-
|
648
|
-
|
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
|
-
|
655
|
-
|
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
|
-
|
662
|
-
|
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
|
-
|
669
|
-
|
670
|
-
|
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,
|
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
|
-
|
689
|
-
|
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
|
-
|
696
|
-
|
697
|
-
|
698
|
-
|
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
|
-
|
705
|
-
|
706
|
-
|
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,
|
765
|
+
function create(matchToken: TextRange, expr: ExpressionNode): MatchNode;
|
710
766
|
}
|
711
|
-
export interface CaseNode extends ParseNodeBase {
|
712
|
-
|
713
|
-
|
714
|
-
|
715
|
-
|
716
|
-
|
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,
|
776
|
+
function create(caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpr: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
|
720
777
|
}
|
721
|
-
export interface PatternSequenceNode extends ParseNodeBase {
|
722
|
-
|
723
|
-
|
724
|
-
|
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
|
-
|
731
|
-
|
732
|
-
|
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
|
-
|
739
|
-
|
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(
|
802
|
+
function create(expr: ExpressionNode): PatternLiteralNode;
|
743
803
|
}
|
744
|
-
export interface PatternClassNode extends ParseNodeBase {
|
745
|
-
|
746
|
-
|
747
|
-
|
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
|
-
|
754
|
-
|
755
|
-
|
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
|
-
|
762
|
-
|
763
|
-
|
764
|
-
|
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
|
-
|
771
|
-
|
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
|
-
|
779
|
-
|
780
|
-
|
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
|
-
|
787
|
-
|
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
|
-
|
794
|
-
|
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(
|
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;
|