@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- 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 +672 -655
- package/dist/analyzer/checker.js.map +1 -1
- package/dist/analyzer/codeFlowEngine.d.ts +5 -3
- package/dist/analyzer/codeFlowEngine.js +112 -103
- 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 +70 -66
- package/dist/analyzer/constraintSolver.js.map +1 -1
- package/dist/analyzer/constructorTransform.d.ts +1 -2
- package/dist/analyzer/constructorTransform.js +26 -27
- package/dist/analyzer/constructorTransform.js.map +1 -1
- package/dist/analyzer/constructors.d.ts +2 -2
- package/dist/analyzer/constructors.js +95 -190
- package/dist/analyzer/constructors.js.map +1 -1
- package/dist/analyzer/dataClasses.js +110 -179
- 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 +78 -79
- 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 +194 -145
- 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 +30 -47
- package/dist/analyzer/parameterUtils.js.map +1 -1
- package/dist/analyzer/parseTreeUtils.d.ts +1 -0
- package/dist/analyzer/parseTreeUtils.js +294 -272
- 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 +178 -145
- 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 +82 -147
- package/dist/analyzer/properties.js.map +1 -1
- package/dist/analyzer/protocols.js +29 -25
- 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 +15 -3
- 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 +2443 -2350
- package/dist/analyzer/typeEvaluator.js.map +1 -1
- package/dist/analyzer/typeEvaluatorTypes.d.ts +13 -9
- package/dist/analyzer/typeEvaluatorTypes.js +7 -1
- package/dist/analyzer/typeEvaluatorTypes.js.map +1 -1
- package/dist/analyzer/typeGuards.js +212 -215
- 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 +30 -15
- package/dist/analyzer/typeUtils.js +534 -436
- 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 +97 -199
- package/dist/analyzer/typedDicts.js.map +1 -1
- package/dist/analyzer/types.d.ts +152 -106
- package/dist/analyzer/types.js +695 -496
- package/dist/analyzer/types.js.map +1 -1
- package/dist/commands/dumpFileDebugInfoCommand.js +34 -34
- 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 +36 -27
- 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.d.ts +10 -4
- package/dist/languageService/referencesProvider.js +30 -18
- package/dist/languageService/referencesProvider.js.map +1 -1
- package/dist/languageService/renameProvider.js +21 -4
- package/dist/languageService/renameProvider.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 +4 -3
- package/dist/localization/localize.js +2 -1
- package/dist/localization/localize.js.map +1 -1
- package/dist/localization/package.nls.cs.json +0 -1
- package/dist/localization/package.nls.de.json +0 -1
- package/dist/localization/package.nls.en-us.json +2 -1
- package/dist/localization/package.nls.es.json +0 -1
- package/dist/localization/package.nls.fr.json +0 -1
- package/dist/localization/package.nls.it.json +0 -1
- package/dist/localization/package.nls.ja.json +0 -1
- package/dist/localization/package.nls.ko.json +0 -1
- package/dist/localization/package.nls.pl.json +0 -1
- package/dist/localization/package.nls.pt-br.json +0 -1
- package/dist/localization/package.nls.qps-ploc.json +0 -1
- package/dist/localization/package.nls.ru.json +0 -1
- package/dist/localization/package.nls.tr.json +0 -1
- package/dist/localization/package.nls.zh-cn.json +0 -1
- package/dist/localization/package.nls.zh-tw.json +0 -1
- package/dist/parser/parseNodes.d.ts +471 -402
- package/dist/parser/parseNodes.js +629 -356
- package/dist/parser/parseNodes.js.map +1 -1
- package/dist/parser/parser.d.ts +1 -0
- package/dist/parser/parser.js +345 -300
- 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/fourslash/rename.args.fourslash.d.ts +1 -0
- package/dist/tests/fourslash/rename.args.fourslash.js +71 -0
- package/dist/tests/fourslash/rename.args.fourslash.js.map +1 -0
- 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/typeEvaluator1.test.js +17 -0
- package/dist/tests/typeEvaluator1.test.js.map +1 -1
- package/dist/tests/typeEvaluator2.test.js +4 -0
- package/dist/tests/typeEvaluator2.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/typeEvaluator4.test.js +10 -6
- package/dist/tests/typeEvaluator4.test.js.map +1 -1
- package/dist/tests/typeEvaluator6.test.js +6 -2
- package/dist/tests/typeEvaluator6.test.js.map +1 -1
- package/dist/tests/typeEvaluator7.test.js +7 -3
- 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
@@ -157,89 +157,7 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
|
|
157
157
|
// using special-case math. For example, Literal[1, 2] + Literal[3, 4]
|
158
158
|
// should result in Literal[4, 5, 6].
|
159
159
|
if (options.isLiteralMathAllowed) {
|
160
|
-
|
161
|
-
if (leftLiteralClassName && !(0, typeUtils_1.getTypeCondition)(leftType)) {
|
162
|
-
const rightLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(rightType);
|
163
|
-
if (leftLiteralClassName === rightLiteralClassName &&
|
164
|
-
!(0, typeUtils_1.getTypeCondition)(rightType) &&
|
165
|
-
(0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) < maxLiteralMathSubtypeCount) {
|
166
|
-
if (leftLiteralClassName === 'str' || leftLiteralClassName === 'bytes') {
|
167
|
-
if (operator === 0 /* OperatorType.Add */) {
|
168
|
-
type = (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
|
169
|
-
return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
|
170
|
-
const leftClassSubtype = leftSubtype;
|
171
|
-
const rightClassSubtype = rightSubtype;
|
172
|
-
return types_1.ClassType.cloneWithLiteral(leftClassSubtype, (leftClassSubtype.literalValue +
|
173
|
-
rightClassSubtype.literalValue));
|
174
|
-
});
|
175
|
-
});
|
176
|
-
}
|
177
|
-
}
|
178
|
-
else if (leftLiteralClassName === 'int') {
|
179
|
-
if (operator === 0 /* OperatorType.Add */ ||
|
180
|
-
operator === 33 /* OperatorType.Subtract */ ||
|
181
|
-
operator === 26 /* OperatorType.Multiply */ ||
|
182
|
-
operator === 13 /* OperatorType.FloorDivide */ ||
|
183
|
-
operator === 24 /* OperatorType.Mod */) {
|
184
|
-
let isValidResult = true;
|
185
|
-
type = (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
|
186
|
-
return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
|
187
|
-
try {
|
188
|
-
const leftClassSubtype = leftSubtype;
|
189
|
-
const rightClassSubtype = rightSubtype;
|
190
|
-
const leftLiteralValue = BigInt(leftClassSubtype.literalValue);
|
191
|
-
const rightLiteralValue = BigInt(rightClassSubtype.literalValue);
|
192
|
-
let newValue;
|
193
|
-
if (operator === 0 /* OperatorType.Add */) {
|
194
|
-
newValue = leftLiteralValue + rightLiteralValue;
|
195
|
-
}
|
196
|
-
else if (operator === 33 /* OperatorType.Subtract */) {
|
197
|
-
newValue = leftLiteralValue - rightLiteralValue;
|
198
|
-
}
|
199
|
-
else if (operator === 26 /* OperatorType.Multiply */) {
|
200
|
-
newValue = leftLiteralValue * rightLiteralValue;
|
201
|
-
}
|
202
|
-
else if (operator === 13 /* OperatorType.FloorDivide */) {
|
203
|
-
if (rightLiteralValue !== BigInt(0)) {
|
204
|
-
newValue = leftLiteralValue / rightLiteralValue;
|
205
|
-
}
|
206
|
-
}
|
207
|
-
else if (operator === 24 /* OperatorType.Mod */) {
|
208
|
-
if (rightLiteralValue !== BigInt(0)) {
|
209
|
-
newValue = leftLiteralValue % rightLiteralValue;
|
210
|
-
}
|
211
|
-
}
|
212
|
-
if (newValue === undefined) {
|
213
|
-
isValidResult = false;
|
214
|
-
return undefined;
|
215
|
-
}
|
216
|
-
else if (typeof newValue === 'number' && isNaN(newValue)) {
|
217
|
-
isValidResult = false;
|
218
|
-
return undefined;
|
219
|
-
}
|
220
|
-
else {
|
221
|
-
// Convert back to a simple number if it fits. Leave as a bigint
|
222
|
-
// if it doesn't.
|
223
|
-
if (newValue >= Number.MIN_SAFE_INTEGER &&
|
224
|
-
newValue <= Number.MAX_SAFE_INTEGER) {
|
225
|
-
newValue = Number(newValue);
|
226
|
-
}
|
227
|
-
return types_1.ClassType.cloneWithLiteral(leftClassSubtype, newValue);
|
228
|
-
}
|
229
|
-
}
|
230
|
-
catch {
|
231
|
-
isValidResult = false;
|
232
|
-
return undefined;
|
233
|
-
}
|
234
|
-
});
|
235
|
-
});
|
236
|
-
if (!isValidResult) {
|
237
|
-
type = undefined;
|
238
|
-
}
|
239
|
-
}
|
240
|
-
}
|
241
|
-
}
|
242
|
-
}
|
160
|
+
type = calcLiteralForBinaryOp(operator, leftType, rightType);
|
243
161
|
}
|
244
162
|
if (!type) {
|
245
163
|
type = evaluator.mapSubtypesExpandTypeVars(leftType,
|
@@ -254,10 +172,10 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
|
|
254
172
|
operator === 0 /* OperatorType.Add */ &&
|
255
173
|
(0, types_1.isClassInstance)(leftSubtypeExpanded) &&
|
256
174
|
(0, typeUtils_1.isTupleClass)(leftSubtypeExpanded) &&
|
257
|
-
leftSubtypeExpanded.tupleTypeArguments &&
|
175
|
+
leftSubtypeExpanded.priv.tupleTypeArguments &&
|
258
176
|
(0, types_1.isClassInstance)(rightSubtypeExpanded) &&
|
259
177
|
(0, typeUtils_1.isTupleClass)(rightSubtypeExpanded) &&
|
260
|
-
rightSubtypeExpanded.tupleTypeArguments &&
|
178
|
+
rightSubtypeExpanded.priv.tupleTypeArguments &&
|
261
179
|
tupleClassType &&
|
262
180
|
(0, types_1.isInstantiableClass)(tupleClassType)) {
|
263
181
|
// If at least one of the tuples is of fixed size, we can
|
@@ -268,8 +186,8 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
|
|
268
186
|
if (!(0, typeUtils_1.isUnboundedTupleClass)(leftSubtypeExpanded) ||
|
269
187
|
!(0, typeUtils_1.isUnboundedTupleClass)(rightSubtypeExpanded)) {
|
270
188
|
return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [
|
271
|
-
...leftSubtypeExpanded.tupleTypeArguments,
|
272
|
-
...rightSubtypeExpanded.tupleTypeArguments,
|
189
|
+
...leftSubtypeExpanded.priv.tupleTypeArguments,
|
190
|
+
...rightSubtypeExpanded.priv.tupleTypeArguments,
|
273
191
|
]));
|
274
192
|
}
|
275
193
|
}
|
@@ -327,47 +245,47 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
|
|
327
245
|
}
|
328
246
|
exports.validateBinaryOperation = validateBinaryOperation;
|
329
247
|
function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
330
|
-
const leftExpression = node.
|
331
|
-
let rightExpression = node.
|
248
|
+
const leftExpression = node.d.leftExpr;
|
249
|
+
let rightExpression = node.d.rightExpr;
|
332
250
|
let isIncomplete = false;
|
333
251
|
let typeErrors = false;
|
334
252
|
// If this is a comparison and the left expression is also a comparison,
|
335
253
|
// we need to change the behavior to accommodate python's "chained
|
336
254
|
// comparisons" feature.
|
337
|
-
if ((0, parseTreeUtils_1.operatorSupportsChaining)(node.operator)) {
|
255
|
+
if ((0, parseTreeUtils_1.operatorSupportsChaining)(node.d.operator)) {
|
338
256
|
if (rightExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
|
339
|
-
!rightExpression.
|
340
|
-
(0, parseTreeUtils_1.operatorSupportsChaining)(rightExpression.operator)) {
|
257
|
+
!rightExpression.d.hasParens &&
|
258
|
+
(0, parseTreeUtils_1.operatorSupportsChaining)(rightExpression.d.operator)) {
|
341
259
|
// Evaluate the right expression so it is type checked.
|
342
260
|
getTypeOfBinaryOperation(evaluator, rightExpression, flags, inferenceContext);
|
343
261
|
// Use the left side of the right expression for comparison purposes.
|
344
|
-
rightExpression = rightExpression.
|
262
|
+
rightExpression = rightExpression.d.leftExpr;
|
345
263
|
}
|
346
264
|
}
|
347
265
|
// For most binary operations, the "expected type" is applied to the output
|
348
266
|
// of the magic method for that operation. However, the "or" and "and" operators
|
349
267
|
// have no magic method, so we apply the expected type directly to both operands.
|
350
|
-
let expectedOperandType = node.operator === 37 /* OperatorType.Or */ || node.operator === 36 /* OperatorType.And */
|
268
|
+
let expectedOperandType = node.d.operator === 37 /* OperatorType.Or */ || node.d.operator === 36 /* OperatorType.And */
|
351
269
|
? inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType
|
352
270
|
: undefined;
|
353
271
|
// Handle the very special case where the expected type is a list
|
354
272
|
// and the operator is a multiply. This comes up in the common case
|
355
273
|
// of "x: List[Optional[X]] = [None] * y" where y is an integer literal.
|
356
274
|
let expectedLeftOperandType;
|
357
|
-
if (node.operator === 26 /* OperatorType.Multiply */ &&
|
275
|
+
if (node.d.operator === 26 /* OperatorType.Multiply */ &&
|
358
276
|
inferenceContext &&
|
359
277
|
(0, types_1.isClassInstance)(inferenceContext.expectedType) &&
|
360
278
|
types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'list') &&
|
361
|
-
inferenceContext.expectedType.typeArguments &&
|
362
|
-
inferenceContext.expectedType.typeArguments.length >= 1 &&
|
363
|
-
node.
|
279
|
+
inferenceContext.expectedType.priv.typeArguments &&
|
280
|
+
inferenceContext.expectedType.priv.typeArguments.length >= 1 &&
|
281
|
+
node.d.leftExpr.nodeType === 34 /* ParseNodeType.List */) {
|
364
282
|
expectedLeftOperandType = inferenceContext.expectedType;
|
365
283
|
}
|
366
284
|
const effectiveExpectedType = expectedOperandType !== null && expectedOperandType !== void 0 ? expectedOperandType : expectedLeftOperandType;
|
367
285
|
const leftTypeResult = evaluator.getTypeOfExpression(leftExpression, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
|
368
286
|
let leftType = leftTypeResult.type;
|
369
287
|
if (!expectedOperandType) {
|
370
|
-
if (node.operator === 37 /* OperatorType.Or */ || node.operator === 36 /* OperatorType.And */) {
|
288
|
+
if (node.d.operator === 37 /* OperatorType.Or */ || node.d.operator === 36 /* OperatorType.And */) {
|
371
289
|
// For "or" and "and", use the type of the left operand under certain
|
372
290
|
// circumstances. This allows us to infer a better type for expressions
|
373
291
|
// like `x or []`. Do this only if it's a generic class (like list or dict)
|
@@ -376,17 +294,17 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
376
294
|
if (!(0, types_1.isClassInstance)(subtype)) {
|
377
295
|
return false;
|
378
296
|
}
|
379
|
-
return types_1.ClassType.isTypedDictClass(subtype) || subtype.
|
297
|
+
return types_1.ClassType.isTypedDictClass(subtype) || subtype.shared.typeParameters.length > 0;
|
380
298
|
})) {
|
381
299
|
expectedOperandType = leftType;
|
382
300
|
}
|
383
301
|
}
|
384
|
-
else if (node.operator === 0 /* OperatorType.Add */ && node.
|
302
|
+
else if (node.d.operator === 0 /* OperatorType.Add */ && node.d.rightExpr.nodeType === 34 /* ParseNodeType.List */) {
|
385
303
|
// For the "+" operator , use this technique only if the right operand is
|
386
304
|
// a list expression. This heuristic handles the common case of `my_list + [0]`.
|
387
305
|
expectedOperandType = leftType;
|
388
306
|
}
|
389
|
-
else if (node.operator === 6 /* OperatorType.BitwiseOr */) {
|
307
|
+
else if (node.d.operator === 6 /* OperatorType.BitwiseOr */) {
|
390
308
|
// If this is a bitwise or ("|"), use the type of the left operand. This allows
|
391
309
|
// us to support the case where a TypedDict is being updated with a dict expression.
|
392
310
|
if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isTypedDictClass(leftType)) {
|
@@ -401,7 +319,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
401
319
|
}
|
402
320
|
// Is this a "|" operator used in a context where it is supposed to be
|
403
321
|
// interpreted as a union operator?
|
404
|
-
if (node.operator === 6 /* OperatorType.BitwiseOr */ &&
|
322
|
+
if (node.d.operator === 6 /* OperatorType.BitwiseOr */ &&
|
405
323
|
!customMetaclassSupportsMethod(leftType, '__or__') &&
|
406
324
|
!customMetaclassSupportsMethod(rightType, '__ror__')) {
|
407
325
|
let adjustedRightType = rightType;
|
@@ -425,7 +343,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
425
343
|
// If the left type is Any, we can't say for sure whether this
|
426
344
|
// is an illegal syntax or a valid application of the "|" operator.
|
427
345
|
if (!(0, types_1.isAnyOrUnknown)(adjustedLeftType)) {
|
428
|
-
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionSyntaxIllegal(), node, node.operatorToken);
|
346
|
+
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionSyntaxIllegal(), node, node.d.operatorToken);
|
429
347
|
}
|
430
348
|
}
|
431
349
|
const isLeftTypeArgValid = evaluator.validateTypeArg({ ...leftTypeResult, node: leftExpression });
|
@@ -433,9 +351,9 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
433
351
|
if (!isLeftTypeArgValid || !isRightTypeArgValid) {
|
434
352
|
return { type: types_1.UnknownType.create() };
|
435
353
|
}
|
436
|
-
adjustedLeftType = evaluator.reportMissingTypeArguments(node.
|
437
|
-
adjustedRightType = evaluator.reportMissingTypeArguments(node.
|
438
|
-
let newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType]);
|
354
|
+
adjustedLeftType = evaluator.reportMissingTypeArguments(node.d.leftExpr, adjustedLeftType, flags | 128 /* EvalFlags.InstantiableType */);
|
355
|
+
adjustedRightType = evaluator.reportMissingTypeArguments(node.d.rightExpr, adjustedRightType, flags | 128 /* EvalFlags.InstantiableType */);
|
356
|
+
let newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType], { skipElideRedundantLiterals: true });
|
439
357
|
const unionClass = evaluator.getUnionClassType();
|
440
358
|
if (unionClass && (0, types_1.isInstantiableClass)(unionClass)) {
|
441
359
|
newUnion = types_1.TypeBase.cloneAsSpecialForm(newUnion, types_1.ClassType.cloneAsInstance(unionClass));
|
@@ -460,7 +378,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
460
378
|
if (stringNode && otherNode && otherType) {
|
461
379
|
let isAllowed = true;
|
462
380
|
if ((0, types_1.isClass)(otherType)) {
|
463
|
-
if (!otherType.isTypeArgumentExplicit || (0, types_1.isClassInstance)(otherType)) {
|
381
|
+
if (!otherType.priv.isTypeArgumentExplicit || (0, types_1.isClassInstance)(otherType)) {
|
464
382
|
isAllowed = false;
|
465
383
|
}
|
466
384
|
}
|
@@ -474,23 +392,23 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
474
392
|
}
|
475
393
|
if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
|
476
394
|
// Exempt "|" because it might be a union operation involving unknowns.
|
477
|
-
if (node.operator !== 6 /* OperatorType.BitwiseOr */) {
|
395
|
+
if (node.d.operator !== 6 /* OperatorType.BitwiseOr */) {
|
478
396
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.binaryOperationNotAllowed(), node);
|
479
397
|
return { type: types_1.UnknownType.create() };
|
480
398
|
}
|
481
399
|
}
|
482
400
|
// Optional checks apply to all operations except for boolean operations.
|
483
401
|
let isLeftOptionalType = false;
|
484
|
-
if (booleanOperatorMap[node.operator] === undefined) {
|
402
|
+
if (booleanOperatorMap[node.d.operator] === undefined) {
|
485
403
|
// None is a valid operand for == and != even if the type stub says otherwise.
|
486
|
-
if (node.operator === 12 /* OperatorType.Equals */ || node.operator === 28 /* OperatorType.NotEquals */) {
|
404
|
+
if (node.d.operator === 12 /* OperatorType.Equals */ || node.d.operator === 28 /* OperatorType.NotEquals */) {
|
487
405
|
leftType = (0, typeUtils_1.removeNoneFromUnion)(leftType);
|
488
406
|
}
|
489
407
|
else {
|
490
408
|
isLeftOptionalType = (0, typeUtils_1.isOptionalType)(leftType);
|
491
409
|
}
|
492
410
|
// None is a valid operand for == and != even if the type stub says otherwise.
|
493
|
-
if (node.operator === 12 /* OperatorType.Equals */ || node.operator === 28 /* OperatorType.NotEquals */) {
|
411
|
+
if (node.d.operator === 12 /* OperatorType.Equals */ || node.d.operator === 28 /* OperatorType.NotEquals */) {
|
494
412
|
rightType = (0, typeUtils_1.removeNoneFromUnion)(rightType);
|
495
413
|
}
|
496
414
|
}
|
@@ -504,7 +422,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
504
422
|
// can result in an infinite loop if we keep creating new tuple types
|
505
423
|
// within a loop construct using __add__.
|
506
424
|
const isTupleAddAllowed = !(0, types_1.isUnion)(leftType);
|
507
|
-
const type = validateBinaryOperation(evaluator, node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
|
425
|
+
const type = validateBinaryOperation(evaluator, node.d.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
|
508
426
|
if (!diag.isEmpty()) {
|
509
427
|
typeErrors = true;
|
510
428
|
if (!isIncomplete) {
|
@@ -514,8 +432,8 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
514
432
|
// this as a reportOptionalOperand diagnostic rather than a
|
515
433
|
// reportGeneralTypeIssues diagnostic.
|
516
434
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.LocMessage.noneOperator().format({
|
517
|
-
operator: (0, parseTreeUtils_1.printOperator)(node.operator),
|
518
|
-
}), node.
|
435
|
+
operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
|
436
|
+
}), node.d.leftExpr);
|
519
437
|
}
|
520
438
|
else {
|
521
439
|
// If neither the LHS or RHS are unions, don't include a diagnostic addendum
|
@@ -527,7 +445,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
|
|
527
445
|
diagString = diag.getString();
|
528
446
|
}
|
529
447
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportBinaryOperator().format({
|
530
|
-
operator: (0, parseTreeUtils_1.printOperator)(node.operator),
|
448
|
+
operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
|
531
449
|
leftType: evaluator.printType(leftType),
|
532
450
|
rightType: evaluator.printType(rightType),
|
533
451
|
}) + diagString, node);
|
@@ -556,15 +474,15 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
|
|
556
474
|
let type;
|
557
475
|
let typeResult;
|
558
476
|
const diag = new diagnostic_1.DiagnosticAddendum();
|
559
|
-
const leftTypeResult = evaluator.getTypeOfExpression(node.
|
477
|
+
const leftTypeResult = evaluator.getTypeOfExpression(node.d.leftExpr);
|
560
478
|
const leftType = leftTypeResult.type;
|
561
479
|
let expectedOperandType;
|
562
|
-
if (node.operator === 7 /* OperatorType.BitwiseOrEqual */) {
|
480
|
+
if (node.d.operator === 7 /* OperatorType.BitwiseOrEqual */) {
|
563
481
|
// If this is a bitwise or ("|="), use the type of the left operand. This allows
|
564
482
|
// us to support the case where a TypedDict is being updated with a dict expression.
|
565
483
|
expectedOperandType = leftType;
|
566
484
|
}
|
567
|
-
const rightTypeResult = evaluator.getTypeOfExpression(node.
|
485
|
+
const rightTypeResult = evaluator.getTypeOfExpression(node.d.rightExpr,
|
568
486
|
/* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedOperandType));
|
569
487
|
const rightType = rightTypeResult.type;
|
570
488
|
const isIncomplete = !!rightTypeResult.isIncomplete || !!leftTypeResult.isIncomplete;
|
@@ -578,7 +496,7 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
|
|
578
496
|
if ((0, types_1.isAnyOrUnknown)(leftSubtypeUnexpanded) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
|
579
497
|
return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
|
580
498
|
}
|
581
|
-
const magicMethodName = operatorMap[node.operator][0];
|
499
|
+
const magicMethodName = operatorMap[node.d.operator][0];
|
582
500
|
let returnType = evaluator.getTypeOfMagicMethodCall(leftSubtypeUnexpanded, magicMethodName, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], node, inferenceContext);
|
583
501
|
if (!returnType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
|
584
502
|
// Try with the expanded left type.
|
@@ -591,11 +509,11 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
|
|
591
509
|
if (!returnType) {
|
592
510
|
// If the LHS class didn't support the magic method for augmented
|
593
511
|
// assignment, fall back on the normal binary expression evaluator.
|
594
|
-
const binaryOperator = operatorMap[node.operator][1];
|
512
|
+
const binaryOperator = operatorMap[node.d.operator][1];
|
595
513
|
// Don't use literal math if the operation is within a loop
|
596
514
|
// because the literal values may change each time.
|
597
515
|
const isLiteralMathAllowed = !(0, parseTreeUtils_1.isWithinLoop)(node) &&
|
598
|
-
isExpressionLocalVariable(evaluator, node.
|
516
|
+
isExpressionLocalVariable(evaluator, node.d.leftExpr) &&
|
599
517
|
(0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
|
600
518
|
maxLiteralMathSubtypeCount;
|
601
519
|
// Don't special-case tuple __add__ if the left type is a union. This
|
@@ -612,7 +530,7 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
|
|
612
530
|
if (!diag.isEmpty() || !type || (0, types_1.isNever)(type)) {
|
613
531
|
if (!isIncomplete) {
|
614
532
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportBinaryOperator().format({
|
615
|
-
operator: (0, parseTreeUtils_1.printOperator)(node.operator),
|
533
|
+
operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
|
616
534
|
leftType: evaluator.printType(leftType),
|
617
535
|
rightType: evaluator.printType(rightType),
|
618
536
|
}) + diag.getString(), node);
|
@@ -620,7 +538,7 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
|
|
620
538
|
}
|
621
539
|
typeResult = { type, isIncomplete };
|
622
540
|
}
|
623
|
-
evaluator.assignTypeToExpression(node.
|
541
|
+
evaluator.assignTypeToExpression(node.d.destExpr, typeResult, node.d.rightExpr);
|
624
542
|
return typeResult;
|
625
543
|
}
|
626
544
|
exports.getTypeOfAugmentedAssignment = getTypeOfAugmentedAssignment;
|
@@ -629,7 +547,7 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
|
|
629
547
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unaryOperationNotAllowed(), node);
|
630
548
|
return { type: types_1.UnknownType.create() };
|
631
549
|
}
|
632
|
-
const exprTypeResult = evaluator.getTypeOfExpression(node.
|
550
|
+
const exprTypeResult = evaluator.getTypeOfExpression(node.d.expr);
|
633
551
|
let exprType = evaluator.makeTopLevelTypeVarsConcrete((0, typeUtils_1.transformPossibleRecursiveTypeAlias)(exprTypeResult.type));
|
634
552
|
const isIncomplete = exprTypeResult.isIncomplete;
|
635
553
|
if ((0, types_1.isNever)(exprType)) {
|
@@ -643,11 +561,11 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
|
|
643
561
|
[5 /* OperatorType.BitwiseInvert */]: '__invert__',
|
644
562
|
};
|
645
563
|
let type;
|
646
|
-
if (node.operator !== 38 /* OperatorType.Not */) {
|
564
|
+
if (node.d.operator !== 38 /* OperatorType.Not */) {
|
647
565
|
if ((0, typeUtils_1.isOptionalType)(exprType)) {
|
648
566
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.LocMessage.noneOperator().format({
|
649
|
-
operator: (0, parseTreeUtils_1.printOperator)(node.operator),
|
650
|
-
}), node.
|
567
|
+
operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
|
568
|
+
}), node.d.expr);
|
651
569
|
exprType = (0, typeUtils_1.removeNoneFromUnion)(exprType);
|
652
570
|
}
|
653
571
|
}
|
@@ -656,30 +574,37 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
|
|
656
574
|
// is incomplete because we may be evaluating an expression within
|
657
575
|
// a loop, so the literal value may change each time.
|
658
576
|
if (!exprTypeResult.isIncomplete) {
|
577
|
+
const operator = node.d.operator;
|
659
578
|
const literalClassName = (0, typeUtils_1.getLiteralTypeClassName)(exprType);
|
660
579
|
if (literalClassName === 'int') {
|
661
|
-
if (
|
580
|
+
if (operator === 0 /* OperatorType.Add */) {
|
662
581
|
type = exprType;
|
663
582
|
}
|
664
|
-
else if (
|
583
|
+
else if (operator === 33 /* OperatorType.Subtract */) {
|
584
|
+
type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
|
585
|
+
const classSubtype = subtype;
|
586
|
+
return types_1.ClassType.cloneWithLiteral(classSubtype, -classSubtype.priv.literalValue);
|
587
|
+
});
|
588
|
+
}
|
589
|
+
else if (operator === 5 /* OperatorType.BitwiseInvert */) {
|
665
590
|
type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
|
666
591
|
const classSubtype = subtype;
|
667
|
-
return types_1.ClassType.cloneWithLiteral(classSubtype,
|
592
|
+
return types_1.ClassType.cloneWithLiteral(classSubtype, ~classSubtype.priv.literalValue);
|
668
593
|
});
|
669
594
|
}
|
670
595
|
}
|
671
596
|
else if (literalClassName === 'bool') {
|
672
|
-
if (
|
597
|
+
if (operator === 38 /* OperatorType.Not */) {
|
673
598
|
type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
|
674
599
|
const classSubtype = subtype;
|
675
|
-
return types_1.ClassType.cloneWithLiteral(classSubtype, !classSubtype.literalValue);
|
600
|
+
return types_1.ClassType.cloneWithLiteral(classSubtype, !classSubtype.priv.literalValue);
|
676
601
|
});
|
677
602
|
}
|
678
603
|
}
|
679
604
|
}
|
680
605
|
if (!type) {
|
681
606
|
// __not__ always returns a boolean.
|
682
|
-
if (node.operator === 38 /* OperatorType.Not */) {
|
607
|
+
if (node.d.operator === 38 /* OperatorType.Not */) {
|
683
608
|
type = evaluator.getBuiltInObject(node, 'bool');
|
684
609
|
if (!type) {
|
685
610
|
type = types_1.UnknownType.create();
|
@@ -690,7 +615,7 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
|
|
690
615
|
type = exprType;
|
691
616
|
}
|
692
617
|
else {
|
693
|
-
const magicMethodName = unaryOperatorMap[node.operator];
|
618
|
+
const magicMethodName = unaryOperatorMap[node.d.operator];
|
694
619
|
let isResultValid = true;
|
695
620
|
type = evaluator.mapSubtypesExpandTypeVars(exprType, /* options */ undefined, (subtypeExpanded) => {
|
696
621
|
const result = evaluator.getTypeOfMagicMethodCall(subtypeExpanded, magicMethodName, [], node, inferenceContext);
|
@@ -707,14 +632,14 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
|
|
707
632
|
if (!isIncomplete) {
|
708
633
|
if (inferenceContext) {
|
709
634
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportUnaryOperatorBidirectional().format({
|
710
|
-
operator: (0, parseTreeUtils_1.printOperator)(node.operator),
|
635
|
+
operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
|
711
636
|
type: evaluator.printType(exprType),
|
712
637
|
expectedType: evaluator.printType(inferenceContext.expectedType),
|
713
638
|
}), node);
|
714
639
|
}
|
715
640
|
else {
|
716
641
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportUnaryOperator().format({
|
717
|
-
operator: (0, parseTreeUtils_1.printOperator)(node.operator),
|
642
|
+
operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
|
718
643
|
type: evaluator.printType(exprType),
|
719
644
|
}), node);
|
720
645
|
}
|
@@ -732,13 +657,13 @@ function getTypeOfTernaryOperation(evaluator, node, flags, inferenceContext) {
|
|
732
657
|
evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ternaryNotAllowed(), node);
|
733
658
|
return { type: types_1.UnknownType.create() };
|
734
659
|
}
|
735
|
-
evaluator.getTypeOfExpression(node.
|
660
|
+
evaluator.getTypeOfExpression(node.d.testExpr);
|
736
661
|
const typesToCombine = [];
|
737
662
|
let isIncomplete = false;
|
738
663
|
let typeErrors = false;
|
739
|
-
const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.
|
740
|
-
if (constExprValue !== false && evaluator.isNodeReachable(node.
|
741
|
-
const ifType = evaluator.getTypeOfExpression(node.
|
664
|
+
const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.d.testExpr, fileInfo.executionEnvironment, fileInfo.definedConstants);
|
665
|
+
if (constExprValue !== false && evaluator.isNodeReachable(node.d.ifExpr)) {
|
666
|
+
const ifType = evaluator.getTypeOfExpression(node.d.ifExpr, flags, inferenceContext);
|
742
667
|
typesToCombine.push(ifType.type);
|
743
668
|
if (ifType.isIncomplete) {
|
744
669
|
isIncomplete = true;
|
@@ -747,8 +672,8 @@ function getTypeOfTernaryOperation(evaluator, node, flags, inferenceContext) {
|
|
747
672
|
typeErrors = true;
|
748
673
|
}
|
749
674
|
}
|
750
|
-
if (constExprValue !== true && evaluator.isNodeReachable(node.
|
751
|
-
const elseType = evaluator.getTypeOfExpression(node.
|
675
|
+
if (constExprValue !== true && evaluator.isNodeReachable(node.d.elseExpr)) {
|
676
|
+
const elseType = evaluator.getTypeOfExpression(node.d.elseExpr, flags, inferenceContext);
|
752
677
|
typesToCombine.push(elseType.type);
|
753
678
|
if (elseType.isIncomplete) {
|
754
679
|
isIncomplete = true;
|
@@ -760,11 +685,135 @@ function getTypeOfTernaryOperation(evaluator, node, flags, inferenceContext) {
|
|
760
685
|
return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete, typeErrors };
|
761
686
|
}
|
762
687
|
exports.getTypeOfTernaryOperation = getTypeOfTernaryOperation;
|
688
|
+
// Attempts to apply "literal math" for two literal operands.
|
689
|
+
function calcLiteralForBinaryOp(operator, leftType, rightType) {
|
690
|
+
const leftLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(leftType);
|
691
|
+
if (!leftLiteralClassName || (0, typeUtils_1.getTypeCondition)(leftType)) {
|
692
|
+
return undefined;
|
693
|
+
}
|
694
|
+
const rightLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(rightType);
|
695
|
+
if (leftLiteralClassName !== rightLiteralClassName ||
|
696
|
+
(0, typeUtils_1.getTypeCondition)(rightType) ||
|
697
|
+
(0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) >= maxLiteralMathSubtypeCount) {
|
698
|
+
return undefined;
|
699
|
+
}
|
700
|
+
// Handle str and bytes literals.
|
701
|
+
if (leftLiteralClassName === 'str' || leftLiteralClassName === 'bytes') {
|
702
|
+
if (operator === 0 /* OperatorType.Add */) {
|
703
|
+
return (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
|
704
|
+
return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
|
705
|
+
const leftClassSubtype = leftSubtype;
|
706
|
+
const rightClassSubtype = rightSubtype;
|
707
|
+
return types_1.ClassType.cloneWithLiteral(leftClassSubtype, (leftClassSubtype.priv.literalValue + rightClassSubtype.priv.literalValue));
|
708
|
+
});
|
709
|
+
});
|
710
|
+
}
|
711
|
+
}
|
712
|
+
// Handle int literals.
|
713
|
+
if (leftLiteralClassName === 'int') {
|
714
|
+
const supportedOps = [
|
715
|
+
0 /* OperatorType.Add */,
|
716
|
+
33 /* OperatorType.Subtract */,
|
717
|
+
26 /* OperatorType.Multiply */,
|
718
|
+
13 /* OperatorType.FloorDivide */,
|
719
|
+
24 /* OperatorType.Mod */,
|
720
|
+
29 /* OperatorType.Power */,
|
721
|
+
17 /* OperatorType.LeftShift */,
|
722
|
+
31 /* OperatorType.RightShift */,
|
723
|
+
3 /* OperatorType.BitwiseAnd */,
|
724
|
+
6 /* OperatorType.BitwiseOr */,
|
725
|
+
8 /* OperatorType.BitwiseXor */,
|
726
|
+
];
|
727
|
+
if (!supportedOps.includes(operator)) {
|
728
|
+
return undefined;
|
729
|
+
}
|
730
|
+
let isValidResult = true;
|
731
|
+
const type = (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
|
732
|
+
return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
|
733
|
+
try {
|
734
|
+
const leftClassSubtype = leftSubtype;
|
735
|
+
const rightClassSubtype = rightSubtype;
|
736
|
+
const leftLiteralValue = BigInt(leftClassSubtype.priv.literalValue);
|
737
|
+
const rightLiteralValue = BigInt(rightClassSubtype.priv.literalValue);
|
738
|
+
let newValue;
|
739
|
+
if (operator === 0 /* OperatorType.Add */) {
|
740
|
+
newValue = leftLiteralValue + rightLiteralValue;
|
741
|
+
}
|
742
|
+
else if (operator === 33 /* OperatorType.Subtract */) {
|
743
|
+
newValue = leftLiteralValue - rightLiteralValue;
|
744
|
+
}
|
745
|
+
else if (operator === 26 /* OperatorType.Multiply */) {
|
746
|
+
newValue = leftLiteralValue * rightLiteralValue;
|
747
|
+
}
|
748
|
+
else if (operator === 13 /* OperatorType.FloorDivide */) {
|
749
|
+
if (rightLiteralValue !== BigInt(0)) {
|
750
|
+
newValue = leftLiteralValue / rightLiteralValue;
|
751
|
+
}
|
752
|
+
}
|
753
|
+
else if (operator === 24 /* OperatorType.Mod */) {
|
754
|
+
if (rightLiteralValue !== BigInt(0)) {
|
755
|
+
newValue = leftLiteralValue % rightLiteralValue;
|
756
|
+
}
|
757
|
+
}
|
758
|
+
else if (operator === 29 /* OperatorType.Power */) {
|
759
|
+
if (rightLiteralValue >= BigInt(0)) {
|
760
|
+
try {
|
761
|
+
newValue = leftLiteralValue ** rightLiteralValue;
|
762
|
+
}
|
763
|
+
catch {
|
764
|
+
// Don't allow if we exceed max bigint integer value.
|
765
|
+
}
|
766
|
+
}
|
767
|
+
}
|
768
|
+
else if (operator === 17 /* OperatorType.LeftShift */) {
|
769
|
+
newValue = leftLiteralValue << rightLiteralValue;
|
770
|
+
}
|
771
|
+
else if (operator === 31 /* OperatorType.RightShift */) {
|
772
|
+
newValue = leftLiteralValue >> rightLiteralValue;
|
773
|
+
}
|
774
|
+
else if (operator === 3 /* OperatorType.BitwiseAnd */) {
|
775
|
+
newValue = leftLiteralValue & rightLiteralValue;
|
776
|
+
}
|
777
|
+
else if (operator === 6 /* OperatorType.BitwiseOr */) {
|
778
|
+
newValue = leftLiteralValue | rightLiteralValue;
|
779
|
+
}
|
780
|
+
else if (operator === 8 /* OperatorType.BitwiseXor */) {
|
781
|
+
newValue = leftLiteralValue ^ rightLiteralValue;
|
782
|
+
}
|
783
|
+
if (newValue === undefined) {
|
784
|
+
isValidResult = false;
|
785
|
+
return undefined;
|
786
|
+
}
|
787
|
+
else if (typeof newValue === 'number' && isNaN(newValue)) {
|
788
|
+
isValidResult = false;
|
789
|
+
return undefined;
|
790
|
+
}
|
791
|
+
else {
|
792
|
+
// Convert back to a simple number if it fits. Leave as a bigint
|
793
|
+
// if it doesn't.
|
794
|
+
if (newValue >= Number.MIN_SAFE_INTEGER && newValue <= Number.MAX_SAFE_INTEGER) {
|
795
|
+
newValue = Number(newValue);
|
796
|
+
}
|
797
|
+
return types_1.ClassType.cloneWithLiteral(leftClassSubtype, newValue);
|
798
|
+
}
|
799
|
+
}
|
800
|
+
catch {
|
801
|
+
isValidResult = false;
|
802
|
+
return undefined;
|
803
|
+
}
|
804
|
+
});
|
805
|
+
});
|
806
|
+
if (isValidResult) {
|
807
|
+
return type;
|
808
|
+
}
|
809
|
+
}
|
810
|
+
return undefined;
|
811
|
+
}
|
763
812
|
function customMetaclassSupportsMethod(type, methodName) {
|
764
813
|
if (!(0, types_1.isInstantiableClass)(type)) {
|
765
814
|
return false;
|
766
815
|
}
|
767
|
-
const metaclass = type.
|
816
|
+
const metaclass = type.shared.effectiveMetaclass;
|
768
817
|
if (!metaclass || !(0, types_1.isInstantiableClass)(metaclass)) {
|
769
818
|
return false;
|
770
819
|
}
|
@@ -801,7 +850,7 @@ function isExpressionLocalVariable(evaluator, node) {
|
|
801
850
|
if (node.nodeType !== 38 /* ParseNodeType.Name */) {
|
802
851
|
return false;
|
803
852
|
}
|
804
|
-
const symbolWithScope = evaluator.lookUpSymbolRecursive(node, node.value, /* honorCodeFlow */ false);
|
853
|
+
const symbolWithScope = evaluator.lookUpSymbolRecursive(node, node.d.value, /* honorCodeFlow */ false);
|
805
854
|
if (!symbolWithScope) {
|
806
855
|
return false;
|
807
856
|
}
|