@zzzen/pyright-internal 1.2.0-dev.20241110 → 1.2.0-dev.20241117

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 (35) hide show
  1. package/dist/analyzer/parseTreeUtils.js +6 -3
  2. package/dist/analyzer/parseTreeUtils.js.map +1 -1
  3. package/dist/analyzer/service.js +2 -2
  4. package/dist/analyzer/service.js.map +1 -1
  5. package/dist/analyzer/symbol.js +1 -1
  6. package/dist/analyzer/symbol.js.map +1 -1
  7. package/dist/analyzer/typeEvaluator.js +171 -143
  8. package/dist/analyzer/typeEvaluator.js.map +1 -1
  9. package/dist/analyzer/typeEvaluatorTypes.d.ts +18 -0
  10. package/dist/analyzer/typeEvaluatorTypes.js.map +1 -1
  11. package/dist/analyzer/typeGuards.js +9 -7
  12. package/dist/analyzer/typeGuards.js.map +1 -1
  13. package/dist/analyzer/typeUtils.js +1 -1
  14. package/dist/analyzer/typeUtils.js.map +1 -1
  15. package/dist/common/asyncInitialization.d.ts +1 -0
  16. package/dist/common/asyncInitialization.js +20 -0
  17. package/dist/common/asyncInitialization.js.map +1 -0
  18. package/dist/common/tomlUtils.d.ts +6 -0
  19. package/dist/common/tomlUtils.js +28 -0
  20. package/dist/common/tomlUtils.js.map +1 -0
  21. package/dist/nodeMain.d.ts +1 -1
  22. package/dist/nodeMain.js +2 -2
  23. package/dist/nodeMain.js.map +1 -1
  24. package/dist/nodeServer.d.ts +1 -1
  25. package/dist/nodeServer.js +3 -5
  26. package/dist/nodeServer.js.map +1 -1
  27. package/dist/pyright.js +2 -4
  28. package/dist/pyright.js.map +1 -1
  29. package/dist/tests/lsp/languageServer.d.ts +1 -1
  30. package/dist/tests/lsp/languageServer.js +3 -1
  31. package/dist/tests/lsp/languageServer.js.map +1 -1
  32. package/dist/tests/typeEvaluator1.test.js +1 -1
  33. package/dist/tests/typeEvaluator5.test.js +1 -1
  34. package/dist/tests/typeEvaluator7.test.js +1 -1
  35. package/package.json +2 -2
@@ -191,25 +191,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
191
191
  let incompleteGenerationCount = 0;
192
192
  const returnTypeInferenceContextStack = [];
193
193
  let returnTypeInferenceTypeCache;
194
- let isPrefetchedTypesInitialized = false;
195
194
  const signatureTrackerStack = [];
196
- // Various types prefetched from stdlib stubs
197
- let noneTypeClass;
198
- let objectClass;
199
- let typeClass;
200
- let unionTypeClass;
201
- let awaitableClass;
202
- let functionClass;
203
- let tupleClass;
204
- let boolClass;
205
- let intClass;
206
- let strClass;
207
- let dictClass;
208
- let moduleTypeClass;
209
- let typedDictClass;
210
- let typedDictPrivateClass;
211
- let supportsKeysAndGetItemClass;
212
- let mappingClass;
195
+ let prefetched;
213
196
  function runWithCancellationToken(token, callback) {
214
197
  try {
215
198
  cancellationToken = token;
@@ -480,43 +463,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
480
463
  }
481
464
  function initializePrefetchedTypes(node) {
482
465
  var _a;
483
- if (!isPrefetchedTypesInitialized) {
466
+ if (!prefetched) {
484
467
  // Some of these types have cyclical dependencies on each other,
485
468
  // so don't re-enter this block once we start executing it.
486
- isPrefetchedTypesInitialized = true;
487
- objectClass = getBuiltInType(node, 'object');
488
- typeClass = getBuiltInType(node, 'type');
489
- functionClass = getBuiltInType(node, 'function');
490
- unionTypeClass = getTypesType(node, 'UnionType');
491
- if (unionTypeClass && (0, types_1.isClass)(unionTypeClass)) {
492
- unionTypeClass.shared.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
469
+ prefetched = {};
470
+ prefetched.objectClass = getBuiltInType(node, 'object');
471
+ prefetched.typeClass = getBuiltInType(node, 'type');
472
+ prefetched.functionClass = getBuiltInType(node, 'function');
473
+ prefetched.unionTypeClass = getTypesType(node, 'UnionType');
474
+ if (prefetched.unionTypeClass && (0, types_1.isClass)(prefetched.unionTypeClass)) {
475
+ prefetched.unionTypeClass.shared.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
493
476
  }
494
477
  // Initialize and cache "Collection" to break a cyclical dependency
495
478
  // that occurs when resolving tuple below.
496
479
  getTypingType(node, 'Collection');
497
- noneTypeClass = (_a = getTypeshedType(node, 'NoneType')) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
498
- tupleClass = getBuiltInType(node, 'tuple');
499
- boolClass = getBuiltInType(node, 'bool');
500
- intClass = getBuiltInType(node, 'int');
501
- strClass = getBuiltInType(node, 'str');
502
- dictClass = getBuiltInType(node, 'dict');
503
- moduleTypeClass = getTypingType(node, 'ModuleType');
504
- typedDictClass = getTypingType(node, 'TypedDict');
505
- typedDictPrivateClass = getTypingType(node, '_TypedDict');
506
- awaitableClass = getTypingType(node, 'Awaitable');
507
- mappingClass = getTypingType(node, 'Mapping');
508
- supportsKeysAndGetItemClass = getTypeshedType(node, 'SupportsKeysAndGetItem');
509
- if (!supportsKeysAndGetItemClass) {
480
+ prefetched.noneTypeClass = (_a = getTypeshedType(node, 'NoneType')) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
481
+ prefetched.tupleClass = getBuiltInType(node, 'tuple');
482
+ prefetched.boolClass = getBuiltInType(node, 'bool');
483
+ prefetched.intClass = getBuiltInType(node, 'int');
484
+ prefetched.strClass = getBuiltInType(node, 'str');
485
+ prefetched.dictClass = getBuiltInType(node, 'dict');
486
+ prefetched.moduleTypeClass = getTypingType(node, 'ModuleType');
487
+ prefetched.typedDictClass = getTypingType(node, 'TypedDict');
488
+ prefetched.typedDictPrivateClass = getTypingType(node, '_TypedDict');
489
+ prefetched.awaitableClass = getTypingType(node, 'Awaitable');
490
+ prefetched.mappingClass = getTypingType(node, 'Mapping');
491
+ prefetched.supportsKeysAndGetItemClass = getTypeshedType(node, 'SupportsKeysAndGetItem');
492
+ if (!prefetched.supportsKeysAndGetItemClass) {
510
493
  // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
511
- supportsKeysAndGetItemClass = mappingClass;
494
+ prefetched.supportsKeysAndGetItemClass = prefetched.mappingClass;
512
495
  }
513
496
  // Wire up the `Any` class to the special-form version of our internal AnyType.
514
- if (objectClass && (0, types_1.isInstantiableClass)(objectClass) && typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
497
+ if (prefetched.objectClass &&
498
+ (0, types_1.isInstantiableClass)(prefetched.objectClass) &&
499
+ prefetched.typeClass &&
500
+ (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
515
501
  const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltIn */ | 8388608 /* ClassTypeFlags.SpecialFormClass */ | 16777216 /* ClassTypeFlags.IllegalIsinstanceClass */,
516
502
  /* typeSourceId */ -1,
517
503
  /* declaredMetaclass */ undefined,
518
- /* effectiveMetaclass */ typeClass);
519
- anyClass.shared.baseClasses.push(objectClass);
504
+ /* effectiveMetaclass */ prefetched.typeClass);
505
+ anyClass.shared.baseClasses.push(prefetched.objectClass);
520
506
  (0, typeUtils_1.computeMroLinearization)(anyClass);
521
507
  const anySpecialForm = types_1.AnyType.createSpecialForm();
522
508
  if ((0, types_1.isAny)(anySpecialForm)) {
@@ -1122,8 +1108,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
1122
1108
  }
1123
1109
  if (types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
1124
1110
  // Handle "LiteralString" specially.
1125
- if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
1126
- let strInstance = types_1.ClassType.cloneAsInstance(strClass);
1111
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)) {
1112
+ let strInstance = types_1.ClassType.cloneAsInstance(prefetched.strClass);
1127
1113
  strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
1128
1114
  return strInstance;
1129
1115
  }
@@ -1437,7 +1423,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
1437
1423
  function stripTypeGuard(type) {
1438
1424
  return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
1439
1425
  if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs'])) {
1440
- return boolClass ? (0, typeUtils_1.convertToInstance)(boolClass) : types_1.UnknownType.create();
1426
+ return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.boolClass) ? (0, typeUtils_1.convertToInstance)(prefetched.boolClass) : types_1.UnknownType.create();
1441
1427
  }
1442
1428
  return subtype;
1443
1429
  });
@@ -1866,10 +1852,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
1866
1852
  // (object that provides an __await__ that returns a generator object).
1867
1853
  // If errorNode is undefined, no errors are reported.
1868
1854
  function getTypeOfAwaitable(type, errorNode) {
1869
- if (!awaitableClass || !(0, types_1.isInstantiableClass)(awaitableClass) || awaitableClass.shared.typeParams.length !== 1) {
1855
+ if (!(prefetched === null || prefetched === void 0 ? void 0 : prefetched.awaitableClass) ||
1856
+ !(0, types_1.isInstantiableClass)(prefetched.awaitableClass) ||
1857
+ prefetched.awaitableClass.shared.typeParams.length !== 1) {
1870
1858
  return types_1.UnknownType.create();
1871
1859
  }
1872
- const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(awaitableClass);
1860
+ const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(prefetched.awaitableClass);
1873
1861
  return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
1874
1862
  subtype = makeTopLevelTypeVarsConcrete(subtype);
1875
1863
  if ((0, types_1.isAnyOrUnknown)(subtype)) {
@@ -1931,8 +1919,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
1931
1919
  if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
1932
1920
  const getItemReturnType = (_b = getTypeOfMagicMethodCall(subtype, '__getitem__', [
1933
1921
  {
1934
- type: intClass && (0, types_1.isInstantiableClass)(intClass)
1935
- ? types_1.ClassType.cloneAsInstance(intClass)
1922
+ type: (prefetched === null || prefetched === void 0 ? void 0 : prefetched.intClass) && (0, types_1.isInstantiableClass)(prefetched.intClass)
1923
+ ? types_1.ClassType.cloneAsInstance(prefetched.intClass)
1936
1924
  : types_1.UnknownType.create(),
1937
1925
  },
1938
1926
  ], errorNode)) === null || _b === void 0 ? void 0 : _b.type;
@@ -2059,29 +2047,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
2059
2047
  return isTypeHashable;
2060
2048
  }
2061
2049
  function getTypedDictClassType() {
2062
- return typedDictPrivateClass && (0, types_1.isInstantiableClass)(typedDictPrivateClass) ? typedDictPrivateClass : undefined;
2050
+ return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.typedDictPrivateClass) && (0, types_1.isInstantiableClass)(prefetched.typedDictPrivateClass)
2051
+ ? prefetched.typedDictPrivateClass
2052
+ : undefined;
2063
2053
  }
2064
2054
  function getTupleClassType() {
2065
- return tupleClass && (0, types_1.isInstantiableClass)(tupleClass) ? tupleClass : undefined;
2055
+ return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.tupleClass) && (0, types_1.isInstantiableClass)(prefetched.tupleClass) ? prefetched.tupleClass : undefined;
2066
2056
  }
2067
2057
  function getDictClassType() {
2068
- return dictClass && (0, types_1.isInstantiableClass)(dictClass) ? dictClass : undefined;
2058
+ return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.dictClass) && (0, types_1.isInstantiableClass)(prefetched.dictClass) ? prefetched.dictClass : undefined;
2069
2059
  }
2070
2060
  function getStrClassType() {
2071
- return strClass && (0, types_1.isInstantiableClass)(strClass) ? strClass : undefined;
2061
+ return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass) ? prefetched.strClass : undefined;
2072
2062
  }
2073
2063
  function getObjectType() {
2074
- return objectClass ? (0, typeUtils_1.convertToInstance)(objectClass) : types_1.UnknownType.create();
2064
+ return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) ? (0, typeUtils_1.convertToInstance)(prefetched.objectClass) : types_1.UnknownType.create();
2075
2065
  }
2076
2066
  function getNoneType() {
2077
- return noneTypeClass ? (0, typeUtils_1.convertToInstance)(noneTypeClass) : types_1.UnknownType.create();
2067
+ return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) ? (0, typeUtils_1.convertToInstance)(prefetched.noneTypeClass) : types_1.UnknownType.create();
2078
2068
  }
2079
2069
  function getUnionClassType() {
2080
- return unionTypeClass !== null && unionTypeClass !== void 0 ? unionTypeClass : types_1.UnknownType.create();
2070
+ var _a;
2071
+ return (_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
2081
2072
  }
2082
2073
  function getTypeClassType() {
2083
- if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
2084
- return typeClass;
2074
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
2075
+ return prefetched.typeClass;
2085
2076
  }
2086
2077
  return undefined;
2087
2078
  }
@@ -2665,8 +2656,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
2665
2656
  return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: getObjectType(), isUnbounded: true }]);
2666
2657
  }
2667
2658
  else if (subtype.priv.paramSpecAccess === 'kwargs') {
2668
- if (dictClass && (0, types_1.isInstantiableClass)(dictClass) && strClass && (0, types_1.isInstantiableClass)(strClass)) {
2669
- return types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(dictClass, [(0, typeUtils_1.convertToInstance)(strClass), getObjectType()]));
2659
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.dictClass) &&
2660
+ (0, types_1.isInstantiableClass)(prefetched.dictClass) &&
2661
+ (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) &&
2662
+ (0, types_1.isInstantiableClass)(prefetched.strClass)) {
2663
+ return types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(prefetched.dictClass, [
2664
+ (0, typeUtils_1.convertToInstance)(prefetched.strClass),
2665
+ getObjectType(),
2666
+ ]));
2670
2667
  }
2671
2668
  return types_1.UnknownType.create();
2672
2669
  }
@@ -2683,8 +2680,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
2683
2680
  // If it's in a union, convert to type or object.
2684
2681
  if (subtype.priv.isInUnion) {
2685
2682
  if (types_1.TypeBase.isInstantiable(subtype)) {
2686
- if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
2687
- return typeClass;
2683
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
2684
+ return prefetched.typeClass;
2688
2685
  }
2689
2686
  }
2690
2687
  else {
@@ -3293,8 +3290,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
3293
3290
  if ((flags & exemptFlags) !== 0) {
3294
3291
  return type;
3295
3292
  }
3296
- if (convertModule && (0, types_1.isModule)(type) && moduleTypeClass && (0, types_1.isInstantiableClass)(moduleTypeClass)) {
3297
- return types_1.ClassType.cloneAsInstance(moduleTypeClass);
3293
+ if (convertModule &&
3294
+ (0, types_1.isModule)(type) &&
3295
+ (prefetched === null || prefetched === void 0 ? void 0 : prefetched.moduleTypeClass) &&
3296
+ (0, types_1.isInstantiableClass)(prefetched.moduleTypeClass)) {
3297
+ return types_1.ClassType.cloneAsInstance(prefetched.moduleTypeClass);
3298
3298
  }
3299
3299
  // Isinstance treats traditional (non-PEP 695) type aliases that are unions
3300
3300
  // as tuples of classes rather than unions.
@@ -4015,7 +4015,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
4015
4015
  }
4016
4016
  }
4017
4017
  else {
4018
- type = getTypeOfMemberAccessWithBaseType(node, { type: functionClass ? (0, typeUtils_1.convertToInstance)(functionClass) : types_1.UnknownType.create() }, usage, flags).type;
4018
+ type = getTypeOfMemberAccessWithBaseType(node, {
4019
+ type: (prefetched === null || prefetched === void 0 ? void 0 : prefetched.functionClass)
4020
+ ? (0, typeUtils_1.convertToInstance)(prefetched.functionClass)
4021
+ : types_1.UnknownType.create(),
4022
+ }, usage, flags).type;
4019
4023
  }
4020
4024
  break;
4021
4025
  }
@@ -4539,8 +4543,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
4539
4543
  isAsymmetric = false;
4540
4544
  }
4541
4545
  else {
4542
- let getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
4543
- const setterType = getEffectiveTypeOfSymbol(setterSymbolResult.symbol);
4546
+ let getterType = getTypeOfMember(getterSymbolResult);
4547
+ const setterType = getTypeOfMember(setterSymbolResult);
4544
4548
  // If this is an overload, find the appropriate overload.
4545
4549
  if ((0, types_1.isOverloaded)(getterType)) {
4546
4550
  const getOverloads = types_1.OverloadedType.getOverloads(getterType).filter((overload) => {
@@ -4642,8 +4646,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
4642
4646
  argList.push({
4643
4647
  argCategory: 0 /* ArgCategory.Simple */,
4644
4648
  typeResult: {
4645
- type: strClass && (0, types_1.isInstantiableClass)(strClass)
4646
- ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClass), memberName)
4649
+ type: (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)
4650
+ ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(prefetched.strClass), memberName)
4647
4651
  : types_1.AnyType.create(),
4648
4652
  },
4649
4653
  });
@@ -4903,7 +4907,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
4903
4907
  },
4904
4908
  });
4905
4909
  }
4906
- else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
4910
+ else if ((0, types_1.isTypeVarTuple)(param) && (prefetched === null || prefetched === void 0 ? void 0 : prefetched.tupleClass) && (0, types_1.isInstantiableClass)(prefetched.tupleClass)) {
4907
4911
  defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: types_1.UnknownType.create(), isUnbounded: true }],
4908
4912
  /* isUnpacked */ true);
4909
4913
  }
@@ -5725,10 +5729,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
5725
5729
  setTypeResultForNode(node, { type: types_1.UnknownType.create() });
5726
5730
  }
5727
5731
  else if (node.nodeType === 18 /* ParseNodeType.Dictionary */ && supportsDictExpression) {
5728
- const inlinedTypeDict = typedDictClass && (0, types_1.isInstantiableClass)(typedDictClass)
5729
- ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClass)
5732
+ const inlinedTypeDict = (prefetched === null || prefetched === void 0 ? void 0 : prefetched.typedDictClass) && (0, types_1.isInstantiableClass)(prefetched.typedDictClass)
5733
+ ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, prefetched.typedDictClass)
5730
5734
  : undefined;
5731
- const keyTypeFallback = strClass && (0, types_1.isInstantiableClass)(strClass) ? strClass : types_1.UnknownType.create();
5735
+ const keyTypeFallback = (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)
5736
+ ? prefetched.strClass
5737
+ : types_1.UnknownType.create();
5732
5738
  typeResult = {
5733
5739
  type: keyTypeFallback,
5734
5740
  inlinedTypeDict,
@@ -6107,7 +6113,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
6107
6113
  return getNoneType();
6108
6114
  }
6109
6115
  function getTypeOfSuperCall(node) {
6110
- var _a, _b;
6116
+ var _a, _b, _c;
6111
6117
  if (node.d.args.length > 2) {
6112
6118
  addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.superCallArgCount(), node.d.args[2]);
6113
6119
  }
@@ -6267,7 +6273,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
6267
6273
  else if (effectiveTargetClass &&
6268
6274
  !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
6269
6275
  !(0, typeUtils_1.derivesFromAnyOrUnknown)(effectiveTargetClass)) {
6270
- resultType = objectClass !== null && objectClass !== void 0 ? objectClass : types_1.UnknownType.create();
6276
+ resultType = (_b = prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
6271
6277
  }
6272
6278
  else {
6273
6279
  resultType = types_1.UnknownType.create();
@@ -6285,7 +6291,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
6285
6291
  // If this is a zero-argument form of super(), synthesize
6286
6292
  // a Self type to bind to.
6287
6293
  bindToSelfType = types_1.TypeBase.cloneForCondition(types_1.TypeVarType.cloneAsBound((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false),
6288
- /* isClsParam */ false)), (_b = bindToType.props) === null || _b === void 0 ? void 0 : _b.condition);
6294
+ /* isClsParam */ false)), (_c = bindToType.props) === null || _c === void 0 ? void 0 : _c.condition);
6289
6295
  }
6290
6296
  }
6291
6297
  const type = resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType;
@@ -6320,9 +6326,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
6320
6326
  return { type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(nextBaseClassType) : nextBaseClassType };
6321
6327
  }
6322
6328
  // There's not much we can say about the type. Simply return object or type.
6323
- if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
6329
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
6324
6330
  return {
6325
- type: resultIsInstance ? getObjectType() : (0, typeUtils_1.convertToInstance)(typeClass),
6331
+ type: resultIsInstance ? getObjectType() : (0, typeUtils_1.convertToInstance)(prefetched.typeClass),
6326
6332
  };
6327
6333
  }
6328
6334
  }
@@ -7310,7 +7316,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
7310
7316
  // If this is a tuple with specified element types, use those
7311
7317
  // specified types rather than using the more generic iterator
7312
7318
  // type which will be a union of all element types.
7313
- const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClass);
7319
+ const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), prefetched === null || prefetched === void 0 ? void 0 : prefetched.tupleClass);
7314
7320
  if ((0, types_1.isClassInstance)(combinedArgType) && (0, typeUtils_1.isTupleClass)(combinedArgType)) {
7315
7321
  const tupleTypeArgs = (_a = combinedArgType.priv.tupleTypeArgs) !== null && _a !== void 0 ? _a : [];
7316
7322
  if (tupleTypeArgs.length !== 1 || !tupleTypeArgs[0].isUnbounded) {
@@ -7863,8 +7869,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
7863
7869
  }
7864
7870
  else {
7865
7871
  const strObjType = getBuiltInObject(errorNode, 'str');
7866
- if (supportsKeysAndGetItemClass &&
7867
- (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass) &&
7872
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.supportsKeysAndGetItemClass) &&
7873
+ (0, types_1.isInstantiableClass)(prefetched.supportsKeysAndGetItemClass) &&
7868
7874
  strObjType &&
7869
7875
  (0, types_1.isClassInstance)(strObjType)) {
7870
7876
  const mappingConstraints = new constraintTracker_1.ConstraintTracker();
@@ -7874,9 +7880,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
7874
7880
  if ((0, types_1.isTypeVar)(argType)) {
7875
7881
  isValidMappingType = true;
7876
7882
  }
7877
- else if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), argType,
7883
+ else if (assignType(types_1.ClassType.cloneAsInstance(prefetched.supportsKeysAndGetItemClass), argType,
7878
7884
  /* diag */ undefined, mappingConstraints)) {
7879
- const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
7885
+ const specializedMapping = solveAndApplyConstraints(prefetched.supportsKeysAndGetItemClass, mappingConstraints);
7880
7886
  const typeArgs = specializedMapping.priv.typeArgs;
7881
7887
  if (typeArgs && typeArgs.length >= 2) {
7882
7888
  if (assignType(strObjType, typeArgs[0])) {
@@ -9334,7 +9340,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
9334
9340
  // in the Python specification: The static type checker will treat
9335
9341
  // the new type as if it were a subclass of the original type.
9336
9342
  function createNewType(errorNode, argList) {
9337
- var _a, _b, _c, _d;
9343
+ var _a, _b, _c, _d, _e;
9338
9344
  const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
9339
9345
  let className = '';
9340
9346
  if (argList.length !== 2) {
@@ -9360,12 +9366,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
9360
9366
  let baseClass = getTypeOfArgExpectingType(argList[1]).type;
9361
9367
  let isBaseClassAny = false;
9362
9368
  if ((0, types_1.isAnyOrUnknown)(baseClass)) {
9363
- baseClass = objectClass !== null && objectClass !== void 0 ? objectClass : types_1.UnknownType.create();
9364
- addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
9369
+ baseClass = (_c = prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
9370
+ addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_d = argList[1].node) !== null && _d !== void 0 ? _d : errorNode);
9365
9371
  isBaseClassAny = true;
9366
9372
  }
9367
9373
  // Specifically disallow Annotated.
9368
- if (((_d = baseClass.props) === null || _d === void 0 ? void 0 : _d.specialForm) &&
9374
+ if (((_e = baseClass.props) === null || _e === void 0 ? void 0 : _e.specialForm) &&
9369
9375
  (0, types_1.isClassInstance)(baseClass.props.specialForm) &&
9370
9376
  types_1.ClassType.isBuiltIn(baseClass.props.specialForm, 'Annotated')) {
9371
9377
  addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
@@ -9433,8 +9439,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
9433
9439
  function getTypeOfConstant(node, flags) {
9434
9440
  let type;
9435
9441
  if (node.d.constType === 26 /* KeywordType.None */) {
9436
- if (noneTypeClass) {
9437
- type = (flags & 128 /* EvalFlags.InstantiableType */) !== 0 ? noneTypeClass : (0, typeUtils_1.convertToInstance)(noneTypeClass);
9442
+ if (prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) {
9443
+ type =
9444
+ (flags & 128 /* EvalFlags.InstantiableType */) !== 0
9445
+ ? prefetched.noneTypeClass
9446
+ : (0, typeUtils_1.convertToInstance)(prefetched.noneTypeClass);
9438
9447
  if (isTypeFormSupported(node)) {
9439
9448
  type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
9440
9449
  }
@@ -9526,15 +9535,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
9526
9535
  return handleSubtype(subtype);
9527
9536
  }
9528
9537
  if ((0, typeUtils_1.isNoneInstance)(subtype)) {
9529
- if (objectClass && (0, types_1.isInstantiableClass)(objectClass)) {
9538
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) && (0, types_1.isInstantiableClass)(prefetched.objectClass)) {
9530
9539
  // Use 'object' for 'None'.
9531
- return handleSubtype(types_1.ClassType.cloneAsInstance(objectClass));
9540
+ return handleSubtype(types_1.ClassType.cloneAsInstance(prefetched.objectClass));
9532
9541
  }
9533
9542
  }
9534
9543
  if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
9535
- if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
9544
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
9536
9545
  // Use 'type' for 'type[None]'.
9537
- return handleSubtype(types_1.ClassType.cloneAsInstance(typeClass));
9546
+ return handleSubtype(types_1.ClassType.cloneAsInstance(prefetched.typeClass));
9538
9547
  }
9539
9548
  }
9540
9549
  magicMethodSupported = false;
@@ -9821,8 +9830,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
9821
9830
  else if (entryNode.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
9822
9831
  let expectedType;
9823
9832
  if (expectedKeyType && expectedValueType) {
9824
- if (supportsKeysAndGetItemClass && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass)) {
9825
- expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(supportsKeysAndGetItemClass, [expectedKeyType, expectedValueType]));
9833
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.supportsKeysAndGetItemClass) &&
9834
+ (0, types_1.isInstantiableClass)(prefetched.supportsKeysAndGetItemClass)) {
9835
+ expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(prefetched.supportsKeysAndGetItemClass, [
9836
+ expectedKeyType,
9837
+ expectedValueType,
9838
+ ]));
9826
9839
  }
9827
9840
  }
9828
9841
  const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(expectedType);
@@ -9845,8 +9858,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
9845
9858
  }
9846
9859
  else if ((0, types_1.isClassInstance)(unexpandedType) && types_1.ClassType.isTypedDictClass(unexpandedType)) {
9847
9860
  // Handle dictionary expansion for a TypedDict.
9848
- if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
9849
- const strObject = types_1.ClassType.cloneAsInstance(strClass);
9861
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)) {
9862
+ const strObject = types_1.ClassType.cloneAsInstance(prefetched.strClass);
9850
9863
  const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType,
9851
9864
  /* allowNarrowed */ true);
9852
9865
  tdEntries.knownItems.forEach((entry, name) => {
@@ -9868,9 +9881,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
9868
9881
  addUnknown = false;
9869
9882
  }
9870
9883
  }
9871
- else if (supportsKeysAndGetItemClass && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass)) {
9884
+ else if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.supportsKeysAndGetItemClass) &&
9885
+ (0, types_1.isInstantiableClass)(prefetched.supportsKeysAndGetItemClass)) {
9872
9886
  const mappingConstraints = new constraintTracker_1.ConstraintTracker();
9873
- supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemClass);
9887
+ const supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(prefetched.supportsKeysAndGetItemClass);
9874
9888
  if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), unexpandedType,
9875
9889
  /* diag */ undefined, mappingConstraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
9876
9890
  const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
@@ -10707,7 +10721,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
10707
10721
  }
10708
10722
  // Creates an Optional[X] type.
10709
10723
  function createOptionalType(classType, errorNode, typeArgs, flags) {
10710
- var _a;
10724
+ var _a, _b, _c;
10711
10725
  if (!typeArgs) {
10712
10726
  // If no type arguments are provided, the resulting type
10713
10727
  // depends on whether we're evaluating a type annotation or
@@ -10726,14 +10740,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
10726
10740
  if (!validateTypeArg(typeArgs[0])) {
10727
10741
  typeArg0Type = types_1.UnknownType.create();
10728
10742
  }
10729
- let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create()]);
10730
- if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
10731
- optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionTypeClass));
10743
+ let optionalType = (0, types_1.combineTypes)([typeArg0Type, (_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create()]);
10744
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) && (0, types_1.isInstantiableClass)(prefetched.unionTypeClass)) {
10745
+ optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(prefetched.unionTypeClass));
10732
10746
  }
10733
- if ((_a = typeArg0Type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
10747
+ if ((_b = typeArg0Type.props) === null || _b === void 0 ? void 0 : _b.typeForm) {
10734
10748
  const typeFormType = (0, types_1.combineTypes)([
10735
10749
  typeArg0Type.props.typeForm,
10736
- (0, typeUtils_1.convertToInstance)(noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create()),
10750
+ (0, typeUtils_1.convertToInstance)((_c = prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) !== null && _c !== void 0 ? _c : types_1.UnknownType.create()),
10737
10751
  ]);
10738
10752
  optionalType = types_1.TypeBase.cloneWithTypeForm(optionalType, typeFormType);
10739
10753
  }
@@ -10757,6 +10771,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
10757
10771
  }
10758
10772
  // Creates a type that represents a Literal.
10759
10773
  function createLiteralType(classType, node, flags) {
10774
+ var _a;
10760
10775
  if (node.d.items.length === 0) {
10761
10776
  addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalEmptyArgs(), node.d.leftExpr);
10762
10777
  return types_1.UnknownType.create();
@@ -10813,7 +10828,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
10813
10828
  type = cloneBuiltinClassWithLiteral(node, classType, 'bool', false);
10814
10829
  }
10815
10830
  else if (itemExpr.d.constType === 26 /* KeywordType.None */) {
10816
- type = noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create();
10831
+ type = (_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
10817
10832
  }
10818
10833
  }
10819
10834
  else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
@@ -10863,8 +10878,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
10863
10878
  literalTypes.push(type);
10864
10879
  }
10865
10880
  let result = (0, types_1.combineTypes)(literalTypes, { skipElideRedundantLiterals: true });
10866
- if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
10867
- result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
10881
+ if ((0, types_1.isUnion)(result) && (prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) && (0, types_1.isInstantiableClass)(prefetched.unionTypeClass)) {
10882
+ result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(prefetched.unionTypeClass));
10868
10883
  }
10869
10884
  if (isTypeFormSupported(node) && isValidTypeForm) {
10870
10885
  result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
@@ -11368,8 +11383,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
11368
11383
  isValidTypeForm = false;
11369
11384
  }
11370
11385
  let unionType = (0, types_1.combineTypes)(types, { skipElideRedundantLiterals: true });
11371
- if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
11372
- unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(unionTypeClass));
11386
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) && (0, types_1.isInstantiableClass)(prefetched.unionTypeClass)) {
11387
+ unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(prefetched.unionTypeClass));
11373
11388
  }
11374
11389
  if (!isValidTypeForm || types.some((t) => { var _a; return !((_a = t.props) === null || _a === void 0 ? void 0 : _a.typeForm); })) {
11375
11390
  if ((_a = unionType.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
@@ -11568,6 +11583,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
11568
11583
  // Handles some special-case type annotations that are found
11569
11584
  // within the typings.pyi file.
11570
11585
  function handleTypingStubTypeAnnotation(node) {
11586
+ var _a;
11571
11587
  if (!node.parent || node.parent.nodeType !== 54 /* ParseNodeType.TypeAnnotation */) {
11572
11588
  return undefined;
11573
11589
  }
@@ -11640,7 +11656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
11640
11656
  // Handle 'LiteralString' specially because we want it to act as
11641
11657
  // though it derives from 'str'.
11642
11658
  if (assignedName === 'LiteralString') {
11643
- specialType.shared.baseClasses.push(strClass !== null && strClass !== void 0 ? strClass : types_1.AnyType.create());
11659
+ specialType.shared.baseClasses.push((_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) !== null && _a !== void 0 ? _a : types_1.AnyType.create());
11644
11660
  (0, typeUtils_1.computeMroLinearization)(specialType);
11645
11661
  if (isTypeFormSupported(node)) {
11646
11662
  specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
@@ -12679,12 +12695,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
12679
12695
  return paramTypes;
12680
12696
  }
12681
12697
  function computeEffectiveMetaclass(classType, errorNode) {
12698
+ var _a;
12682
12699
  let effectiveMetaclass = classType.shared.declaredMetaclass;
12683
12700
  let reportedMetaclassConflict = false;
12684
12701
  if (!effectiveMetaclass || (0, types_1.isInstantiableClass)(effectiveMetaclass)) {
12685
12702
  for (const baseClass of classType.shared.baseClasses) {
12686
12703
  if ((0, types_1.isInstantiableClass)(baseClass)) {
12687
- const baseClassMeta = baseClass.shared.effectiveMetaclass || typeClass;
12704
+ const baseClassMeta = (_a = baseClass.shared.effectiveMetaclass) !== null && _a !== void 0 ? _a : prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass;
12688
12705
  if (baseClassMeta && (0, types_1.isInstantiableClass)(baseClassMeta)) {
12689
12706
  // Make sure there is no metaclass conflict.
12690
12707
  if (!effectiveMetaclass) {
@@ -13767,6 +13784,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
13767
13784
  }
13768
13785
  const exceptionTypeResult = getTypeOfExpression(node.d.typeExpr);
13769
13786
  const exceptionTypes = exceptionTypeResult.type;
13787
+ let includesBaseException = false;
13770
13788
  function getExceptionType(exceptionType, errorNode) {
13771
13789
  var _a, _b;
13772
13790
  exceptionType = makeTopLevelTypeVarsConcrete(exceptionType);
@@ -13774,6 +13792,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
13774
13792
  return exceptionType;
13775
13793
  }
13776
13794
  if ((0, types_1.isInstantiableClass)(exceptionType)) {
13795
+ if (types_1.ClassType.isBuiltIn(exceptionType, 'BaseException')) {
13796
+ includesBaseException = true;
13797
+ }
13777
13798
  return types_1.ClassType.cloneAsInstance(exceptionType);
13778
13799
  }
13779
13800
  if ((0, types_1.isClassInstance)(exceptionType)) {
@@ -13800,9 +13821,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
13800
13821
  }
13801
13822
  return getExceptionType(subType, node.d.typeExpr);
13802
13823
  });
13803
- // If this is an except group, wrap the exception type in an BaseExceptionGroup.
13824
+ // If this is an except group, wrap the exception type in an ExceptionGroup
13825
+ // or BaseExceptionGroup depending on whether the target exception is
13826
+ // a BaseException.
13804
13827
  if (node.d.isExceptGroup) {
13805
- targetType = getBuiltInObject(node, 'BaseExceptionGroup', [targetType]);
13828
+ targetType = getBuiltInObject(node, includesBaseException ? 'BaseExceptionGroup' : 'ExceptionGroup', [
13829
+ targetType,
13830
+ ]);
13806
13831
  }
13807
13832
  if (node.d.name) {
13808
13833
  assignTypeToExpression(node.d.name, { type: targetType }, node.d.name);
@@ -14801,8 +14826,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
14801
14826
  return { type: types_1.UnknownType.create() };
14802
14827
  }
14803
14828
  }
14804
- if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
14805
- let typeType = createSpecialType(typeClass, typeArgs, 1,
14829
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
14830
+ let typeType = createSpecialType(prefetched.typeClass, typeArgs, 1,
14806
14831
  /* allowParamSpec */ undefined,
14807
14832
  /* isSpecialForm */ false);
14808
14833
  if ((0, types_1.isInstantiableClass)(typeType)) {
@@ -15196,9 +15221,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
15196
15221
  // aliased symbols in outer scopes if they haven't yet been assigned
15197
15222
  // within the local scope.
15198
15223
  let scopeTypeHonorsCodeFlow = scopeType !== 2 /* ScopeType.Function */ && scopeType !== 1 /* ScopeType.Comprehension */;
15199
- // Type parameter scopes don't honor code flow, but if the symbol is resolved
15200
- // using the proxy scope for the type parameter scope, we should use code flow.
15201
- if (scopeType === 0 /* ScopeType.TypeParameter */ && symbolWithScope && symbolWithScope.scope === scope) {
15224
+ // Type parameter scopes don't honor code flow.
15225
+ if ((symbolWithScope === null || symbolWithScope === void 0 ? void 0 : symbolWithScope.scope.type) === 0 /* ScopeType.TypeParameter */) {
15202
15226
  scopeTypeHonorsCodeFlow = false;
15203
15227
  }
15204
15228
  if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
@@ -16012,6 +16036,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
16012
16036
  'TypedDict',
16013
16037
  'NamedTuple',
16014
16038
  'NewType',
16039
+ 'TypeAliasType',
16015
16040
  ];
16016
16041
  if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, exemptBuiltins)) {
16017
16042
  isUnambiguousType = true;
@@ -16872,12 +16897,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
16872
16897
  if (types_1.ClassType.isBuiltIn(destType, 'Mapping')) {
16873
16898
  const mappingValueType = (0, typedDicts_1.getTypedDictMappingEquivalent)(evaluatorInterface, srcType);
16874
16899
  if (mappingValueType &&
16875
- mappingClass &&
16876
- (0, types_1.isInstantiableClass)(mappingClass) &&
16877
- strClass &&
16878
- (0, types_1.isInstantiableClass)(strClass)) {
16879
- srcType = types_1.ClassType.specialize(mappingClass, [
16880
- types_1.ClassType.cloneAsInstance(strClass),
16900
+ (prefetched === null || prefetched === void 0 ? void 0 : prefetched.mappingClass) &&
16901
+ (0, types_1.isInstantiableClass)(prefetched.mappingClass) &&
16902
+ (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) &&
16903
+ (0, types_1.isInstantiableClass)(prefetched.strClass)) {
16904
+ srcType = types_1.ClassType.specialize(prefetched.mappingClass, [
16905
+ types_1.ClassType.cloneAsInstance(prefetched.strClass),
16881
16906
  mappingValueType,
16882
16907
  ]);
16883
16908
  }
@@ -16885,11 +16910,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
16885
16910
  else if (types_1.ClassType.isBuiltIn(destType, ['dict', 'MutableMapping'])) {
16886
16911
  const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, srcType, recursionCount);
16887
16912
  if (dictValueType &&
16888
- dictClass &&
16889
- (0, types_1.isInstantiableClass)(dictClass) &&
16890
- strClass &&
16891
- (0, types_1.isInstantiableClass)(strClass)) {
16892
- srcType = types_1.ClassType.specialize(dictClass, [types_1.ClassType.cloneAsInstance(strClass), dictValueType]);
16913
+ (prefetched === null || prefetched === void 0 ? void 0 : prefetched.dictClass) &&
16914
+ (0, types_1.isInstantiableClass)(prefetched.dictClass) &&
16915
+ prefetched.strClass &&
16916
+ (0, types_1.isInstantiableClass)(prefetched.strClass)) {
16917
+ srcType = types_1.ClassType.specialize(prefetched.dictClass, [
16918
+ types_1.ClassType.cloneAsInstance(prefetched.strClass),
16919
+ dictValueType,
16920
+ ]);
16893
16921
  }
16894
16922
  }
16895
16923
  }
@@ -17652,10 +17680,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
17652
17680
  }
17653
17681
  }
17654
17682
  else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
17655
- strClass &&
17656
- (0, types_1.isInstantiableClass)(strClass) &&
17683
+ (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) &&
17684
+ (0, types_1.isInstantiableClass)(prefetched.strClass) &&
17657
17685
  (flags & 1 /* AssignTypeFlags.Invariant */) === 0) {
17658
- concreteSrcType = types_1.ClassType.cloneAsInstance(strClass);
17686
+ concreteSrcType = types_1.ClassType.cloneAsInstance(prefetched.strClass);
17659
17687
  }
17660
17688
  if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, constraints, flags, recursionCount,
17661
17689
  /* reportErrorsUsingObjType */ true)) {
@@ -17670,8 +17698,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
17670
17698
  return assignType(destCallbackType, concreteSrcType, diag, constraints, flags, recursionCount);
17671
17699
  }
17672
17700
  // All functions are considered instances of "builtins.function".
17673
- if (functionClass) {
17674
- return assignType(destType, (0, typeUtils_1.convertToInstance)(functionClass), diag, constraints, flags, recursionCount);
17701
+ if (prefetched === null || prefetched === void 0 ? void 0 : prefetched.functionClass) {
17702
+ return assignType(destType, (0, typeUtils_1.convertToInstance)(prefetched.functionClass), diag, constraints, flags, recursionCount);
17675
17703
  }
17676
17704
  }
17677
17705
  else if ((0, types_1.isModule)(concreteSrcType)) {
@@ -17825,8 +17853,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
17825
17853
  }
17826
17854
  // Are we trying to assign None to a protocol?
17827
17855
  if ((0, typeUtils_1.isNoneInstance)(srcType) && (0, types_1.isClassInstance)(destType) && types_1.ClassType.isProtocolClass(destType)) {
17828
- if (noneTypeClass && (0, types_1.isInstantiableClass)(noneTypeClass)) {
17829
- return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneTypeClass), diag, constraints, flags, recursionCount);
17856
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) && (0, types_1.isInstantiableClass)(prefetched.noneTypeClass)) {
17857
+ return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(prefetched.noneTypeClass), diag, constraints, flags, recursionCount);
17830
17858
  }
17831
17859
  }
17832
17860
  if ((0, typeUtils_1.isNoneInstance)(destType)) {
@@ -18348,8 +18376,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
18348
18376
  for (const field of types_1.ClassType.getSymbolTable(mroClass)) {
18349
18377
  if (field[0] !== '__call__' && !field[1].isIgnoredForProtocolMatch()) {
18350
18378
  let fieldIsPartOfFunction = false;
18351
- if (functionClass && (0, types_1.isClass)(functionClass)) {
18352
- if (types_1.ClassType.getSymbolTable(functionClass).has(field[0])) {
18379
+ if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.functionClass) && (0, types_1.isClass)(prefetched.functionClass)) {
18380
+ if (types_1.ClassType.getSymbolTable(prefetched.functionClass).has(field[0])) {
18353
18381
  fieldIsPartOfFunction = true;
18354
18382
  }
18355
18383
  }
@@ -18972,9 +19000,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
18972
19000
  // type at runtime.
18973
19001
  if ((0, types_1.isClassInstance)(srcReturnType) &&
18974
19002
  types_1.ClassType.isBuiltIn(srcReturnType, ['TypeGuard', 'TypeIs']) &&
18975
- boolClass &&
18976
- (0, types_1.isInstantiableClass)(boolClass)) {
18977
- if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), constraints, flags, recursionCount)) {
19003
+ (prefetched === null || prefetched === void 0 ? void 0 : prefetched.boolClass) &&
19004
+ (0, types_1.isInstantiableClass)(prefetched.boolClass)) {
19005
+ if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(prefetched.boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), constraints, flags, recursionCount)) {
18978
19006
  isReturnTypeCompatible = true;
18979
19007
  }
18980
19008
  }