@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (184) hide show
  1. package/dist/analyzer/analyzerNodeInfo.js +74 -46
  2. package/dist/analyzer/analyzerNodeInfo.js.map +1 -1
  3. package/dist/analyzer/binder.js +506 -512
  4. package/dist/analyzer/binder.js.map +1 -1
  5. package/dist/analyzer/checker.js +672 -655
  6. package/dist/analyzer/checker.js.map +1 -1
  7. package/dist/analyzer/codeFlowEngine.d.ts +5 -3
  8. package/dist/analyzer/codeFlowEngine.js +112 -103
  9. package/dist/analyzer/codeFlowEngine.js.map +1 -1
  10. package/dist/analyzer/codeFlowTypes.js +30 -28
  11. package/dist/analyzer/codeFlowTypes.js.map +1 -1
  12. package/dist/analyzer/constraintSolver.js +70 -66
  13. package/dist/analyzer/constraintSolver.js.map +1 -1
  14. package/dist/analyzer/constructorTransform.d.ts +1 -2
  15. package/dist/analyzer/constructorTransform.js +26 -27
  16. package/dist/analyzer/constructorTransform.js.map +1 -1
  17. package/dist/analyzer/constructors.d.ts +2 -2
  18. package/dist/analyzer/constructors.js +95 -190
  19. package/dist/analyzer/constructors.js.map +1 -1
  20. package/dist/analyzer/dataClasses.js +110 -179
  21. package/dist/analyzer/dataClasses.js.map +1 -1
  22. package/dist/analyzer/declarationUtils.js +14 -15
  23. package/dist/analyzer/declarationUtils.js.map +1 -1
  24. package/dist/analyzer/decorators.js +78 -79
  25. package/dist/analyzer/decorators.js.map +1 -1
  26. package/dist/analyzer/enums.js +70 -56
  27. package/dist/analyzer/enums.js.map +1 -1
  28. package/dist/analyzer/functionTransform.js +8 -18
  29. package/dist/analyzer/functionTransform.js.map +1 -1
  30. package/dist/analyzer/importResolver.d.ts +2 -1
  31. package/dist/analyzer/importResolver.js +40 -29
  32. package/dist/analyzer/importResolver.js.map +1 -1
  33. package/dist/analyzer/importStatementUtils.js +27 -27
  34. package/dist/analyzer/importStatementUtils.js.map +1 -1
  35. package/dist/analyzer/namedTuples.js +33 -59
  36. package/dist/analyzer/namedTuples.js.map +1 -1
  37. package/dist/analyzer/operations.js +194 -145
  38. package/dist/analyzer/operations.js.map +1 -1
  39. package/dist/analyzer/packageTypeVerifier.js +66 -62
  40. package/dist/analyzer/packageTypeVerifier.js.map +1 -1
  41. package/dist/analyzer/parameterUtils.d.ts +4 -4
  42. package/dist/analyzer/parameterUtils.js +30 -47
  43. package/dist/analyzer/parameterUtils.js.map +1 -1
  44. package/dist/analyzer/parseTreeUtils.d.ts +1 -0
  45. package/dist/analyzer/parseTreeUtils.js +294 -272
  46. package/dist/analyzer/parseTreeUtils.js.map +1 -1
  47. package/dist/analyzer/parseTreeWalker.js +76 -76
  48. package/dist/analyzer/parseTreeWalker.js.map +1 -1
  49. package/dist/analyzer/patternMatching.js +178 -145
  50. package/dist/analyzer/patternMatching.js.map +1 -1
  51. package/dist/analyzer/program.js +1 -1
  52. package/dist/analyzer/program.js.map +1 -1
  53. package/dist/analyzer/properties.js +82 -147
  54. package/dist/analyzer/properties.js.map +1 -1
  55. package/dist/analyzer/protocols.js +29 -25
  56. package/dist/analyzer/protocols.js.map +1 -1
  57. package/dist/analyzer/sourceFile.js +3 -3
  58. package/dist/analyzer/sourceFile.js.map +1 -1
  59. package/dist/analyzer/sourceMapper.js +20 -19
  60. package/dist/analyzer/sourceMapper.js.map +1 -1
  61. package/dist/analyzer/staticExpressions.js +83 -84
  62. package/dist/analyzer/staticExpressions.js.map +1 -1
  63. package/dist/analyzer/testWalker.js +15 -3
  64. package/dist/analyzer/testWalker.js.map +1 -1
  65. package/dist/analyzer/tracePrinter.js +20 -20
  66. package/dist/analyzer/tracePrinter.js.map +1 -1
  67. package/dist/analyzer/typeDocStringUtils.js +25 -25
  68. package/dist/analyzer/typeDocStringUtils.js.map +1 -1
  69. package/dist/analyzer/typeEvaluator.js +2443 -2350
  70. package/dist/analyzer/typeEvaluator.js.map +1 -1
  71. package/dist/analyzer/typeEvaluatorTypes.d.ts +13 -9
  72. package/dist/analyzer/typeEvaluatorTypes.js +7 -1
  73. package/dist/analyzer/typeEvaluatorTypes.js.map +1 -1
  74. package/dist/analyzer/typeGuards.js +212 -215
  75. package/dist/analyzer/typeGuards.js.map +1 -1
  76. package/dist/analyzer/typePrinter.js +118 -115
  77. package/dist/analyzer/typePrinter.js.map +1 -1
  78. package/dist/analyzer/typeStubWriter.js +104 -103
  79. package/dist/analyzer/typeStubWriter.js.map +1 -1
  80. package/dist/analyzer/typeUtils.d.ts +30 -15
  81. package/dist/analyzer/typeUtils.js +534 -436
  82. package/dist/analyzer/typeUtils.js.map +1 -1
  83. package/dist/analyzer/typeVarContext.js +8 -8
  84. package/dist/analyzer/typeVarContext.js.map +1 -1
  85. package/dist/analyzer/typeWalker.js +13 -10
  86. package/dist/analyzer/typeWalker.js.map +1 -1
  87. package/dist/analyzer/typedDicts.js +97 -199
  88. package/dist/analyzer/typedDicts.js.map +1 -1
  89. package/dist/analyzer/types.d.ts +152 -106
  90. package/dist/analyzer/types.js +695 -496
  91. package/dist/analyzer/types.js.map +1 -1
  92. package/dist/commands/dumpFileDebugInfoCommand.js +34 -34
  93. package/dist/commands/dumpFileDebugInfoCommand.js.map +1 -1
  94. package/dist/common/fileSystem.d.ts +1 -0
  95. package/dist/common/fileSystem.js.map +1 -1
  96. package/dist/common/fullAccessHost.js +6 -4
  97. package/dist/common/fullAccessHost.js.map +1 -1
  98. package/dist/common/realFileSystem.d.ts +1 -0
  99. package/dist/common/realFileSystem.js +4 -0
  100. package/dist/common/realFileSystem.js.map +1 -1
  101. package/dist/common/textEditTracker.js +14 -14
  102. package/dist/common/textEditTracker.js.map +1 -1
  103. package/dist/languageService/autoImporter.js +10 -10
  104. package/dist/languageService/autoImporter.js.map +1 -1
  105. package/dist/languageService/callHierarchyProvider.js +23 -23
  106. package/dist/languageService/callHierarchyProvider.js.map +1 -1
  107. package/dist/languageService/completionProvider.js +153 -151
  108. package/dist/languageService/completionProvider.js.map +1 -1
  109. package/dist/languageService/definitionProvider.d.ts +1 -1
  110. package/dist/languageService/definitionProvider.js +3 -1
  111. package/dist/languageService/definitionProvider.js.map +1 -1
  112. package/dist/languageService/documentSymbolCollector.js +19 -19
  113. package/dist/languageService/documentSymbolCollector.js.map +1 -1
  114. package/dist/languageService/hoverProvider.js +36 -27
  115. package/dist/languageService/hoverProvider.js.map +1 -1
  116. package/dist/languageService/importSorter.js +8 -8
  117. package/dist/languageService/importSorter.js.map +1 -1
  118. package/dist/languageService/referencesProvider.d.ts +10 -4
  119. package/dist/languageService/referencesProvider.js +30 -18
  120. package/dist/languageService/referencesProvider.js.map +1 -1
  121. package/dist/languageService/renameProvider.js +21 -4
  122. package/dist/languageService/renameProvider.js.map +1 -1
  123. package/dist/languageService/signatureHelpProvider.d.ts +1 -1
  124. package/dist/languageService/signatureHelpProvider.js +6 -6
  125. package/dist/languageService/signatureHelpProvider.js.map +1 -1
  126. package/dist/languageService/symbolIndexer.js +3 -3
  127. package/dist/languageService/symbolIndexer.js.map +1 -1
  128. package/dist/languageService/tooltipUtils.js +13 -13
  129. package/dist/languageService/tooltipUtils.js.map +1 -1
  130. package/dist/localization/localize.d.ts +4 -3
  131. package/dist/localization/localize.js +2 -1
  132. package/dist/localization/localize.js.map +1 -1
  133. package/dist/localization/package.nls.cs.json +0 -1
  134. package/dist/localization/package.nls.de.json +0 -1
  135. package/dist/localization/package.nls.en-us.json +2 -1
  136. package/dist/localization/package.nls.es.json +0 -1
  137. package/dist/localization/package.nls.fr.json +0 -1
  138. package/dist/localization/package.nls.it.json +0 -1
  139. package/dist/localization/package.nls.ja.json +0 -1
  140. package/dist/localization/package.nls.ko.json +0 -1
  141. package/dist/localization/package.nls.pl.json +0 -1
  142. package/dist/localization/package.nls.pt-br.json +0 -1
  143. package/dist/localization/package.nls.qps-ploc.json +0 -1
  144. package/dist/localization/package.nls.ru.json +0 -1
  145. package/dist/localization/package.nls.tr.json +0 -1
  146. package/dist/localization/package.nls.zh-cn.json +0 -1
  147. package/dist/localization/package.nls.zh-tw.json +0 -1
  148. package/dist/parser/parseNodes.d.ts +471 -402
  149. package/dist/parser/parseNodes.js +629 -356
  150. package/dist/parser/parseNodes.js.map +1 -1
  151. package/dist/parser/parser.d.ts +1 -0
  152. package/dist/parser/parser.js +345 -300
  153. package/dist/parser/parser.js.map +1 -1
  154. package/dist/tests/classDeclaration.test.js +14 -14
  155. package/dist/tests/classDeclaration.test.js.map +1 -1
  156. package/dist/tests/fourslash/rename.args.fourslash.d.ts +1 -0
  157. package/dist/tests/fourslash/rename.args.fourslash.js +71 -0
  158. package/dist/tests/fourslash/rename.args.fourslash.js.map +1 -0
  159. package/dist/tests/harness/vfs/filesystem.d.ts +3 -2
  160. package/dist/tests/harness/vfs/filesystem.js +6 -2
  161. package/dist/tests/harness/vfs/filesystem.js.map +1 -1
  162. package/dist/tests/importResolver.test.js +4 -3
  163. package/dist/tests/importResolver.test.js.map +1 -1
  164. package/dist/tests/parseTreeUtils.test.js +5 -5
  165. package/dist/tests/parseTreeUtils.test.js.map +1 -1
  166. package/dist/tests/parser.test.js +8 -8
  167. package/dist/tests/parser.test.js.map +1 -1
  168. package/dist/tests/sourceMapperUtils.test.js +7 -7
  169. package/dist/tests/sourceMapperUtils.test.js.map +1 -1
  170. package/dist/tests/typeEvaluator1.test.js +17 -0
  171. package/dist/tests/typeEvaluator1.test.js.map +1 -1
  172. package/dist/tests/typeEvaluator2.test.js +4 -0
  173. package/dist/tests/typeEvaluator2.test.js.map +1 -1
  174. package/dist/tests/typeEvaluator3.test.js +8 -3
  175. package/dist/tests/typeEvaluator3.test.js.map +1 -1
  176. package/dist/tests/typeEvaluator4.test.js +10 -6
  177. package/dist/tests/typeEvaluator4.test.js.map +1 -1
  178. package/dist/tests/typeEvaluator6.test.js +6 -2
  179. package/dist/tests/typeEvaluator6.test.js.map +1 -1
  180. package/dist/tests/typeEvaluator7.test.js +7 -3
  181. package/dist/tests/typeEvaluator7.test.js.map +1 -1
  182. package/dist/tests/typePrinter.test.js +14 -39
  183. package/dist/tests/typePrinter.test.js.map +1 -1
  184. package/package.json +1 -1
@@ -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
- const leftLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(leftType);
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.leftExpression;
331
- let rightExpression = node.rightExpression;
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.parenthesized &&
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.leftExpression;
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.leftExpression.nodeType === 34 /* ParseNodeType.List */) {
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.details.typeParameters.length > 0;
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.rightExpression.nodeType === 34 /* ParseNodeType.List */) {
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.leftExpression, adjustedLeftType, flags | 128 /* EvalFlags.InstantiableType */);
437
- adjustedRightType = evaluator.reportMissingTypeArguments(node.rightExpression, adjustedRightType, flags | 128 /* EvalFlags.InstantiableType */);
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.leftExpression);
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.leftExpression);
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.rightExpression,
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.leftExpression) &&
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.destExpression, typeResult, node.rightExpression);
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.expression);
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.expression);
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 (node.operator === 0 /* OperatorType.Add */) {
580
+ if (operator === 0 /* OperatorType.Add */) {
662
581
  type = exprType;
663
582
  }
664
- else if (node.operator === 33 /* OperatorType.Subtract */) {
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, -classSubtype.literalValue);
592
+ return types_1.ClassType.cloneWithLiteral(classSubtype, ~classSubtype.priv.literalValue);
668
593
  });
669
594
  }
670
595
  }
671
596
  else if (literalClassName === 'bool') {
672
- if (node.operator === 38 /* OperatorType.Not */) {
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.testExpression);
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.testExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
740
- if (constExprValue !== false && evaluator.isNodeReachable(node.ifExpression)) {
741
- const ifType = evaluator.getTypeOfExpression(node.ifExpression, flags, inferenceContext);
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.elseExpression)) {
751
- const elseType = evaluator.getTypeOfExpression(node.elseExpression, flags, inferenceContext);
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.details.effectiveMetaclass;
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
  }