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