coc-pyright 1.1.383 → 1.1.385

package/lib/index.js

@@ -625,6 +625,7 @@ var require_collectionUtils = __commonJS({
     exports2.contains = contains;
     exports2.append = append;
     exports2.appendArray = appendArray;
+    exports2.partition = partition;
     exports2.find = find;
     exports2.addRange = addRange;
     exports2.insertAt = insertAt;
@@ -675,6 +676,18 @@ var require_collectionUtils = __commonJS({
         to.push(elem);
       }
     }
+    function partition(array, cb) {
+      const trueItems = [];
+      const falseItems = [];
+      for (const item of array) {
+        if (cb(item)) {
+          trueItems.push(item);
+        } else {
+          falseItems.push(item);
+        }
+      }
+      return [trueItems, falseItems];
+    }
     function find(array, predicate) {
       for (let i = 0; i < array.length; i++) {
         const value = array[i];
@@ -12895,7 +12908,7 @@ var require_pythonVersion = __commonJS({
     exports2.pythonVersion3_12 = PythonVersion.create(3, 12);
     exports2.pythonVersion3_13 = PythonVersion.create(3, 13);
     exports2.pythonVersion3_14 = PythonVersion.create(3, 14);
-    exports2.latestStablePythonVersion = exports2.pythonVersion3_12;
+    exports2.latestStablePythonVersion = exports2.pythonVersion3_13;
   }
 });
 
@@ -16929,6 +16942,7 @@ var require_package_nls_cs = __commonJS({
         typedDictFieldReadOnlyRedefinition: "Polo\u017Eka TypedDict {name} nejde p\u0159edefinovat jako ReadOnly.",
         typedDictFieldRequiredRedefinition: "Polo\u017Eka TypedDict {name} nejde p\u0159edefinovat jako Required.",
         typedDictFirstArg: "Jako prvn\xED argument byl o\u010Dek\xE1v\xE1n n\xE1zev t\u0159\xEDdy TypedDict",
+        typedDictInClassPattern: "T\u0159\xEDda TypedDict nen\xED ve vzoru t\u0159\xEDdy povolena.",
         typedDictInitsubclassParameter: "TypedDict nepodporuje parametr __init_subclass__ \u201E{name}\u201C.",
         typedDictNotAllowed: "\u201ETypedDict\u201C se v tomto kontextu ned\xE1 pou\u017E\xEDt.",
         typedDictSecondArgDict: "Jako druh\xFD parametr se o\u010Dek\xE1val parametr dict nebo keyword.",
@@ -17158,7 +17172,7 @@ var require_package_nls_cs = __commonJS({
         typedDictClosedExtraTypeMismatch: "Nelze p\u0159idat polo\u017Eku {name} s typem {type}.",
         typedDictClosedFieldNotRequired: "Nelze p\u0159idat polo\u017Eku {name}, proto\u017Ee mus\xED b\xFDt NotRequired.",
         typedDictExtraFieldNotAllowed: "{name} nen\xED k dispozici v {type}",
-        typedDictExtraFieldTypeMismatch: "Typ {name} nen\xED kompatibiln\xED s typem __extra_items__ v typu {type}.",
+        typedDictExtraFieldTypeMismatch: "Typ {name} nen\xED kompatibiln\xED s typem extra_items v typu {type}.",
         typedDictFieldMissing: "V {type} chyb\xED {name}",
         typedDictFieldNotReadOnly: "{name} nen\xED v {type} jen pro \u010Dten\xED",
         typedDictFieldNotRequired: "{name} se v typu {type} nevy\u017Eaduje",
@@ -17755,6 +17769,7 @@ var require_package_nls_de = __commonJS({
         typedDictFieldReadOnlyRedefinition: "Das TypedDict-Element \u201E{name}\u201C kann nicht als \u201EReadOnly\u201C neu definiert werden.",
         typedDictFieldRequiredRedefinition: "Das TypedDict-Element \u201E{name}\u201C kann nicht als \u201ERequired\u201C neu definiert werden.",
         typedDictFirstArg: 'Der Klassenname "TypedDict" wird als erstes Argument erwartet.',
+        typedDictInClassPattern: "Die TypedDict-Klasse ist im Klassenmuster nicht zul\xE4ssig.",
         typedDictInitsubclassParameter: "TypedDict unterst\xFCtzt __init_subclass__ Parameter \u201E{name}\u201C nicht.",
         typedDictNotAllowed: '"TypedDict" kann in diesem Kontext nicht verwendet werden.',
         typedDictSecondArgDict: "Es wird ein dict- oder Schl\xFCsselwortparameter als zweiter Parameter erwartet.",
@@ -17984,7 +17999,7 @@ var require_package_nls_de = __commonJS({
         typedDictClosedExtraTypeMismatch: "Das Element \u201E{name}\u201C mit dem Typ \u201E{type}\u201C kann nicht hinzugef\xFCgt werden.",
         typedDictClosedFieldNotRequired: "Das Element \u201E{name}\u201C kann nicht hinzugef\xFCgt werden, da es \u201ENotRequired\u201C sein muss.",
         typedDictExtraFieldNotAllowed: "\u201E{name}\u201C ist in \u201E{type}\u201C nicht vorhanden.",
-        typedDictExtraFieldTypeMismatch: "Der Typ von \u201E{name}\u201C ist nicht mit dem Typ \u201E__extra_items__\u201C in \u201E{type}\u201C kompatibel.",
+        typedDictExtraFieldTypeMismatch: "Der Typ von \u201E{name}\u201C ist nicht mit dem Typ \u201Eextra_items\u201C in \u201E{type}\u201C kompatibel.",
         typedDictFieldMissing: '"{name}" fehlt in "{type}"',
         typedDictFieldNotReadOnly: '"{name}" ist in "{type}" nicht schreibgesch\xFCtzt.',
         typedDictFieldNotRequired: '"{name}" ist in "{type}" nicht erforderlich.',
@@ -18234,6 +18249,7 @@ var require_package_nls_en_us = __commonJS({
         dataClassConverterFunction: 'Argument of type "{argType}" is not a valid converter for field "{fieldName}" of type "{fieldType}"',
         dataClassConverterOverloads: 'No overloads of "{funcName}" are valid converters for field "{fieldName}" of type "{fieldType}"',
         dataClassFieldInheritedDefault: '"{fieldName}" overrides a field of the same name but is missing a default value',
+        dataClassFieldInvalidAlias: 'Alias name "{aliasName}" is not a valid identifier',
         dataClassFieldWithDefault: "Fields without default values cannot appear after fields with default values",
         dataClassFieldWithPrivateName: "Dataclass field cannot use private name",
         dataClassFieldWithoutAnnotation: "Dataclass field without type annotation will cause runtime exception",
@@ -19468,6 +19484,10 @@ var require_package_nls_en_us = __commonJS({
           message: "Extra TypedDict arguments not supported",
           comment: "{Locked='TypedDict'}"
         },
+        typedDictExtraItemsClosed: {
+          message: "A TypedDict cannot be closed if it supports extra items",
+          comment: "{Locked='TypedDict','closed'}"
+        },
         typedDictFieldNotRequiredRedefinition: {
           message: 'TypedDict item "{name}" cannot be redefined as NotRequired',
           comment: "{Locked='TypedDict','NotRequired'}"
@@ -20027,8 +20047,8 @@ var require_package_nls_en_us = __commonJS({
         },
         typedDictExtraFieldNotAllowed: '"{name}" is not present in "{type}"',
         typedDictExtraFieldTypeMismatch: {
-          message: 'Type of "{name}" is incompatible with type of "__extra_items__" in "{type}"',
-          comment: "{Locked='__extra_items__'}"
+          message: 'Type of "{name}" is incompatible with type of "extra_items" in "{type}"',
+          comment: "{Locked='extra_items'}"
         },
         typedDictFieldMissing: '"{name}" is missing from "{type}"',
         typedDictFieldNotReadOnly: '"{name}" is not read-only in "{type}"',
@@ -20647,6 +20667,7 @@ var require_package_nls_es = __commonJS({
         typedDictFieldReadOnlyRedefinition: 'El elemento TypedDict "{name}" no se puede redefinir como ReadOnly',
         typedDictFieldRequiredRedefinition: 'El elemento TypedDict "{name}" no se puede redefinir como Required',
         typedDictFirstArg: "Nombre de clase TypedDict esperado como primer argumento",
+        typedDictInClassPattern: "No se permite la clase TypedDict en el patr\xF3n de clase",
         typedDictInitsubclassParameter: 'TypedDict no admite __init_subclass__ par\xE1metro "{name}"',
         typedDictNotAllowed: '"TypedDict" no puede utilizarse en este contexto',
         typedDictSecondArgDict: "Par\xE1metro dict o palabra clave esperado como segundo par\xE1metro",
@@ -20876,7 +20897,7 @@ var require_package_nls_es = __commonJS({
         typedDictClosedExtraTypeMismatch: 'No se puede agregar el elemento "{name}" con el tipo "{type}"',
         typedDictClosedFieldNotRequired: 'No se puede agregar el elemento "{name}" porque debe ser NotRequired.',
         typedDictExtraFieldNotAllowed: '"{name}" no est\xE1 presente en "{type}"',
-        typedDictExtraFieldTypeMismatch: 'El tipo de "{name}" no es compatible con el tipo de "__extra_items__" en "{type}"',
+        typedDictExtraFieldTypeMismatch: 'El tipo de "{name}" no es compatible con el tipo de "extra_items" en "{type}"',
         typedDictFieldMissing: '"{name}" falta en "{type}"',
         typedDictFieldNotReadOnly: '"{name}" no es de solo lectura en "{type}"',
         typedDictFieldNotRequired: '"{name}" no es obligatorio en "{type}"',
@@ -21473,6 +21494,7 @@ var require_package_nls_fr = __commonJS({
         typedDictFieldReadOnlyRedefinition: "L\u2019\xE9l\xE9ment TypedDict \xAB\xA0{name}\xA0\xBB ne peut pas \xEAtre red\xE9fini comme \xE9tat En ReadOnly",
         typedDictFieldRequiredRedefinition: "L\u2019\xE9l\xE9ment TypedDict \xAB\xA0{name}\xA0\xBB ne peut pas \xEAtre red\xE9fini comme \xE9tant Required",
         typedDictFirstArg: "Nom de classe TypedDict attendu comme premier argument",
+        typedDictInClassPattern: "La classe TypedDict n'est pas autoris\xE9e dans le mod\xE8le de classe",
         typedDictInitsubclassParameter: "TypedDict ne prend pas en charge __init_subclass__ param\xE8tre \xAB\xA0{name}\xA0\xBB",
         typedDictNotAllowed: '"TypedDict" ne peut pas \xEAtre utilis\xE9 dans ce contexte',
         typedDictSecondArgDict: "Param\xE8tre de mot cl\xE9 ou de dict attendu en tant que deuxi\xE8me param\xE8tre",
@@ -21702,7 +21724,7 @@ var require_package_nls_fr = __commonJS({
         typedDictClosedExtraTypeMismatch: "Impossible d\u2019ajouter l\u2019\xE9l\xE9ment \xAB\xA0{name}\xA0\xBB avec le type \xAB\xA0{type}\xA0\xBB",
         typedDictClosedFieldNotRequired: "Impossible d\u2019ajouter l\u2019\xE9l\xE9ment \xAB\xA0{name}\xA0\xBB, car il doit \xEAtre NotRequired",
         typedDictExtraFieldNotAllowed: "\xAB\xA0{name}\xA0\xBB n\u2019est pas pr\xE9sent dans \xAB\xA0{type}\xA0\xBB",
-        typedDictExtraFieldTypeMismatch: "Le type de \xAB\xA0{name}\xA0\xBB est incompatible avec le type \xAB\xA0__extra_items__\xA0\xBB dans \xAB\xA0{type}\xA0\xBB",
+        typedDictExtraFieldTypeMismatch: "Le type de \xAB\xA0{name}\xA0\xBB est incompatible avec le type \xAB\xA0extra_items\xA0\xBB dans \xAB\xA0{type}\xA0\xBB",
         typedDictFieldMissing: "\xAB\xA0{name}\xA0\xBB est manquant dans \xAB\xA0{type}\xA0\xBB",
         typedDictFieldNotReadOnly: "\xAB\xA0{name}\xA0\xBB n\u2019est pas en lecture seule dans \xAB\xA0{type}\xA0\xBB",
         typedDictFieldNotRequired: "\xAB\xA0{name}\xA0\xBB n\u2019est pas obligatoire dans \xAB\xA0{type}\xA0\xBB",
@@ -22299,6 +22321,7 @@ var require_package_nls_it = __commonJS({
         typedDictFieldReadOnlyRedefinition: 'Non \xE8 possibile ridefinire l\u2019elemento TypedDict "{name}" come ReadOnly',
         typedDictFieldRequiredRedefinition: 'Non \xE8 possibile ridefinire il campo TypedDict "{name}" come Required',
         typedDictFirstArg: "\xC8 previsto il nome della classe TypedDict come primo argomento",
+        typedDictInClassPattern: "Classe TypedDict non consentita nel modello di classe",
         typedDictInitsubclassParameter: "TypedDict non supporta __init_subclass__ parametro \u201C{name}\u201D",
         typedDictNotAllowed: '"TypedDict" non pu\xF2 essere usato in questo contesto',
         typedDictSecondArgDict: "Previsto parametro dict o keyword come secondo parametro",
@@ -22528,7 +22551,7 @@ var require_package_nls_it = __commonJS({
         typedDictClosedExtraTypeMismatch: `Non \xE8 possibile aggiungere l'elemento "{name}" con tipo "{type}"`,
         typedDictClosedFieldNotRequired: `Non \xE8 possibile aggiungere l'elemento "{name}" perch\xE9 deve essere NotRequired`,
         typedDictExtraFieldNotAllowed: '"{name}" non \xE8 presente in "{type}"',
-        typedDictExtraFieldTypeMismatch: 'Il tipo di "{name}" non \xE8 compatibile con il tipo "__extra_items__" in "{type}"',
+        typedDictExtraFieldTypeMismatch: 'Il tipo di "{name}" non \xE8 compatibile con il tipo "extra_items" in "{type}"',
         typedDictFieldMissing: '"{name}" mancante nel "{type}"',
         typedDictFieldNotReadOnly: '"{name}" non \xE8 di sola lettura in "{type}"',
         typedDictFieldNotRequired: '"{name}" non \xE8 obbligatorio in "{type}"',
@@ -23125,6 +23148,7 @@ var require_package_nls_ja = __commonJS({
         typedDictFieldReadOnlyRedefinition: 'TypedDict \u30A2\u30A4\u30C6\u30E0 "{name}" \u3092 ReadOnly \u3068\u3057\u3066\u518D\u5B9A\u7FA9\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
         typedDictFieldRequiredRedefinition: 'TypedDict \u30A2\u30A4\u30C6\u30E0 "{name}" \u3092 Required \u3068\u3057\u3066\u518D\u5B9A\u7FA9\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
         typedDictFirstArg: "\u6700\u521D\u306E\u5F15\u6570\u3068\u3057\u3066 TypedDict \u30AF\u30E9\u30B9\u540D\u304C\u5FC5\u8981\u3067\u3059",
+        typedDictInClassPattern: "TypedDict \u30AF\u30E9\u30B9\u306F\u30AF\u30E9\u30B9 \u30D1\u30BF\u30FC\u30F3\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
         typedDictInitsubclassParameter: 'TypedDict \u306F __init_subclass__\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC "{name}" \u3092\u30B5\u30DD\u30FC\u30C8\u3057\u3066\u3044\u307E\u305B\u3093',
         typedDictNotAllowed: '"TypedDict" \u306F\u3053\u306E\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093',
         typedDictSecondArgDict: "2 \u756A\u76EE\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u3068\u3057\u3066 dict \u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u307E\u305F\u306F\u30AD\u30FC\u30EF\u30FC\u30C9 \u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u304C\u5FC5\u8981\u3067\u3059",
@@ -23354,7 +23378,7 @@ var require_package_nls_ja = __commonJS({
         typedDictClosedExtraTypeMismatch: '\u578B "{type}" \u306E\u30A2\u30A4\u30C6\u30E0 "{name}" \u3092\u8FFD\u52A0\u3067\u304D\u307E\u305B\u3093',
         typedDictClosedFieldNotRequired: '\u30A2\u30A4\u30C6\u30E0 "{name}" \u3092\u8FFD\u52A0\u3067\u304D\u307E\u305B\u3093\u3002\u3053\u308C\u306F NotRequired \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308B\u305F\u3081\u3067\u3059\u3002',
         typedDictExtraFieldNotAllowed: '"{name}" \u306F "{type}" \u306B\u5B58\u5728\u3057\u307E\u305B\u3093',
-        typedDictExtraFieldTypeMismatch: '"{name}" \u306E\u578B\u306F\u3001"{type}" \u306E "__extra_items__" \u578B\u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093',
+        typedDictExtraFieldTypeMismatch: '"{name}" \u306E\u578B\u306F\u3001"{type}" \u306E "extra_items" \u578B\u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093',
         typedDictFieldMissing: '"{name}" \u304C "{type}" \u306B\u898B\u3064\u304B\u308A\u307E\u305B\u3093',
         typedDictFieldNotReadOnly: '"{name}" \u306F "{type}" \u3067\u306F\u8AAD\u307F\u53D6\u308A\u5C02\u7528\u3067\u306F\u3042\u308A\u307E\u305B\u3093',
         typedDictFieldNotRequired: '"{name}" \u306F "{type}" \u306B\u306F\u5FC5\u8981\u3042\u308A\u307E\u305B\u3093',
@@ -23951,6 +23975,7 @@ var require_package_nls_ko = __commonJS({
         typedDictFieldReadOnlyRedefinition: 'TypedDict \uD56D\uBAA9 "{name}"\uC740(\uB294) ReadOnly\uB85C \uC7AC\uC815\uC758\uB420 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictFieldRequiredRedefinition: 'TypedDict \uD56D\uBAA9 "{name}"\uC740(\uB294) Required\uB85C \uC7AC\uC815\uC758\uB420 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictFirstArg: "TypedDict \uD074\uB798\uC2A4 \uC774\uB984\uC774 \uCCAB \uBC88\uC9F8 \uC778\uC218\uB85C \uD544\uC694\uD569\uB2C8\uB2E4.",
+        typedDictInClassPattern: "TypedDict \uD074\uB798\uC2A4\uB294 \uD074\uB798\uC2A4 \uD328\uD134\uC5D0\uC11C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
         typedDictInitsubclassParameter: 'TypedDict\uB294 __init_subclass__ \uB9E4\uAC1C \uBCC0\uC218 "{name}"\uC744(\uB97C) \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
         typedDictNotAllowed: '\uC774 \uCEE8\uD14D\uC2A4\uD2B8\uC5D0\uC11C\uB294 "TypedDict"\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictSecondArgDict: "\uB450 \uBC88\uC9F8 \uB9E4\uAC1C \uBCC0\uC218\uB85C dict \uB610\uB294 \uD0A4\uC6CC\uB4DC \uB9E4\uAC1C \uBCC0\uC218\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.",
@@ -24180,7 +24205,7 @@ var require_package_nls_ko = __commonJS({
         typedDictClosedExtraTypeMismatch: '\uD615\uC2DD\uC774 "{type}"\uC778 \uD56D\uBAA9 "{name}"\uC744(\uB97C) \uCD94\uAC00\uD560 \uC218 \uC5C6\uC74C',
         typedDictClosedFieldNotRequired: '"{name}" \uD56D\uBAA9\uC740 NotRequired\uC5EC\uC57C \uD558\uBBC0\uB85C \uCD94\uAC00\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictExtraFieldNotAllowed: '"{name}"\uC774(\uAC00) "{type}"\uC5D0 \uC5C6\uC74C',
-        typedDictExtraFieldTypeMismatch: '"{name}" \uD615\uC2DD\uC740 "{type}"\uC758 "__extra_items__" \uD615\uC2DD\uACFC \uD638\uD658\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
+        typedDictExtraFieldTypeMismatch: '"{name}" \uD615\uC2DD\uC740 "{type}"\uC758 "extra_items" \uD615\uC2DD\uACFC \uD638\uD658\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
         typedDictFieldMissing: '"{name}"\uC774(\uAC00) "{type}"\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictFieldNotReadOnly: '"{name}"\uC740(\uB294) "{type}"\uC5D0\uC11C \uC77D\uAE30 \uC804\uC6A9\uC774 \uC544\uB2D9\uB2C8\uB2E4.',
         typedDictFieldNotRequired: '"{name}"\uC740(\uB294) "{type}"\uC5D0 \uD544\uC694\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
@@ -24777,6 +24802,7 @@ var require_package_nls_pl = __commonJS({
         typedDictFieldReadOnlyRedefinition: "Element TypedDict \u201E{name}\u201D nie mo\u017Ce by\u0107 przedefiniowany jako ReadOnly.",
         typedDictFieldRequiredRedefinition: "Element TypedDict \u201E{name}\u201D nie mo\u017Ce zosta\u0107 przedefiniowany jako Required",
         typedDictFirstArg: "Oczekiwano nazwy klasy TypedDict jako pierwszego argumentu",
+        typedDictInClassPattern: "klasa TypedDict nie jest dozwolona we wzorcu klasy",
         typedDictInitsubclassParameter: "Element TypedDict nie obs\u0142uguje parametru __init_subclass__ \u201E{name}\u201D",
         typedDictNotAllowed: "Nie mo\u017Cna u\u017Cy\u0107 elementu \u201ETypedDict\u201D w tym kontek\u015Bcie",
         typedDictSecondArgDict: "Oczekiwano parametru dict lub s\u0142owa kluczowego jako drugiego parametru",
@@ -25006,7 +25032,7 @@ var require_package_nls_pl = __commonJS({
         typedDictClosedExtraTypeMismatch: 'Nie mo\u017Cna doda\u0107 elementu "{name}" z typem \u201E{type}\u201D',
         typedDictClosedFieldNotRequired: 'Nie mo\u017Cna doda\u0107 elementu "{name}", poniewa\u017C musi on mie\u0107 warto\u015B\u0107 NotRequired',
         typedDictExtraFieldNotAllowed: "Element \u201E{name}\u201D nie jest obecny w typie \u201E{type}\u201D",
-        typedDictExtraFieldTypeMismatch: "Typ \u201E{name}\u201D jest niezgodny z typem \u201E__extra_items__\u201D w typie \u201E{type}\u201D",
+        typedDictExtraFieldTypeMismatch: "Typ \u201E{name}\u201D jest niezgodny z typem \u201Eextra_items\u201D w typie \u201E{type}\u201D",
         typedDictFieldMissing: "Brak nazwy \u201E{name}\u201D w \u201E{type}\u201D",
         typedDictFieldNotReadOnly: "Nazwa \u201E{name}\u201D nie jest tylko do odczytu w \u201E{type}\u201D",
         typedDictFieldNotRequired: "Nazwa \u201E{name}\u201D nie jest wymagana w typie \u201E{type}\u201D",
@@ -25603,6 +25629,7 @@ var require_package_nls_pt_br = __commonJS({
         typedDictFieldReadOnlyRedefinition: 'O item TypedDict "{name}" n\xE3o pode ser redefinido como ReadOnly',
         typedDictFieldRequiredRedefinition: 'O item TypedDict "{name}" n\xE3o pode ser redefinido como Required',
         typedDictFirstArg: "Nome da classe TypedDict esperado como primeiro argumento",
+        typedDictInClassPattern: "A classe TypedDict n\xE3o \xE9 permitida no padr\xE3o de classe",
         typedDictInitsubclassParameter: 'TypedDict n\xE3o d\xE1 suporte ao par\xE2metro __init_subclass__ "{name}"',
         typedDictNotAllowed: '"TypedDict" n\xE3o pode ser usado neste contexto',
         typedDictSecondArgDict: "Par\xE2metro dict ou de palavra-chave esperado como segundo par\xE2metro",
@@ -25832,7 +25859,7 @@ var require_package_nls_pt_br = __commonJS({
         typedDictClosedExtraTypeMismatch: 'N\xE3o \xE9 poss\xEDvel adicionar o item "{name}" com o tipo "{type}"',
         typedDictClosedFieldNotRequired: 'N\xE3o \xE9 poss\xEDvel adicionar o item "{name}" porque ele deve ser NotRequired',
         typedDictExtraFieldNotAllowed: '"{name}" n\xE3o est\xE1 presente em "{type}"',
-        typedDictExtraFieldTypeMismatch: 'O tipo de "{name}" \xE9 incompat\xEDvel com o tipo de "__extra_items__" em "{type}"',
+        typedDictExtraFieldTypeMismatch: 'O tipo de "{name}" \xE9 incompat\xEDvel com o tipo de "extra_items" em "{type}"',
         typedDictFieldMissing: '"{name}" est\xE1 ausente de "{type}"',
         typedDictFieldNotReadOnly: '"{name}" n\xE3o \xE9 somente leitura em "{type}"',
         typedDictFieldNotRequired: '"{name}" n\xE3o \xE9 obrigat\xF3rio em "{type}"',
@@ -26429,6 +26456,7 @@ var require_package_nls_qps_ploc = __commonJS({
         typedDictFieldReadOnlyRedefinition: '[8IFAz][\u0E19\u0E31\u0E49TypedDict \xEFt\xEBm "{\xF1\xE6m\xEB}" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB r\xEB\xF0\xEBf\xEF\xF1\xEB\xF0 \xE6s ReadOnly\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFieldRequiredRedefinition: '[lpw97][\u0E19\u0E31\u0E49TypedDict \xEFt\xEBm "{\xF1\xE6m\xEB}" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB r\xEB\xF0\xEBf\xEF\xF1\xEB\xF0 \xE6s Required\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFirstArg: "[OPlNk][\u0E19\u0E31\u0E49\xCBxp\xEB\xE7t\xEB\xF0 TypedDict \xE7l\xE6ss \xF1\xE6m\xEB \xE6s f\xEFrst \xE6rg\xB5m\xEB\xF1t\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
+        typedDictInClassPattern: "[IqJCA][\u0E19\u0E31\u0E49TypedDict \xE7l\xE6ss \xF1\xF8t \xE6ll\xF8w\xEB\xF0 \xEF\xF1 \xE7l\xE6ss p\xE6tt\xEBr\xF1\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typedDictInitsubclassParameter: '[HMpfK][\u0E19\u0E31\u0E49TypedDict \xF0\xF8\xEBs \xF1\xF8t s\xB5pp\xF8rt __init_subclass__ p\xE6r\xE6m\xEBt\xEBr "{\xF1\xE6m\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictNotAllowed: '[UWg4F][\u0E19\u0E31\u0E49"TypedDict" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xB5s\xEB\xF0 \xEF\xF1 th\xEFs \xE7\xF8\xF1t\xEBxt\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictSecondArgDict: "[mwrv7][\u0E19\u0E31\u0E49\xCBxp\xEB\xE7t\xEB\xF0 dict \xF8r k\xEB\xFFw\xF8r\xF0 p\xE6r\xE6m\xEBt\xEBr \xE6s s\xEB\xE7\xF8\xF1\xF0 p\xE6r\xE6m\xEBt\xEBr\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
@@ -26658,7 +26686,7 @@ var require_package_nls_qps_ploc = __commonJS({
         typedDictClosedExtraTypeMismatch: '[blC1e][\u0E19\u0E31\u0E49\xC7\xE6\xF1\xF1\xF8t \xE6\xF0\xF0 \xEFt\xEBm "{\xF1\xE6m\xEB}" w\xEFth t\xFFp\xEB "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictClosedFieldNotRequired: '[6rtDR][\u0E19\u0E31\u0E49\xC7\xE6\xF1\xF1\xF8t \xE6\xF0\xF0 \xEFt\xEBm "{\xF1\xE6m\xEB}" \xFE\xEB\xE7\xE6\xB5s\xEB \xEFt m\xB5st \xFE\xEB NotRequired\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictExtraFieldNotAllowed: '[kFDh9][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs \xF1\xF8t pr\xEBs\xEB\xF1t \xEF\xF1 "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
-        typedDictExtraFieldTypeMismatch: '[DnAhM][\u0E19\u0E31\u0E49T\xFFp\xEB \xF8f "{\xF1\xE6m\xEB}" \xEFs \xEF\xF1\xE7\xF8mp\xE6t\xEF\xFEl\xEB w\xEFth t\xFFp\xEB \xF8f "__extra_items__" \xEF\xF1 "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
+        typedDictExtraFieldTypeMismatch: '[DnAhM][\u0E19\u0E31\u0E49T\xFFp\xEB \xF8f "{\xF1\xE6m\xEB}" \xEFs \xEF\xF1\xE7\xF8mp\xE6t\xEF\xFEl\xEB w\xEFth t\xFFp\xEB \xF8f "extra_items" \xEF\xF1 "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFieldMissing: '[rNzn7][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs m\xEFss\xEF\xF1g fr\xF8m "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFieldNotReadOnly: '[BJy1V][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs \xF1\xF8t r\xEB\xE6\xF0-\xF8\xF1l\xFF \xEF\xF1 "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFieldNotRequired: '[eqatW][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs \xF1\xF8t r\xEBq\xB5\xEFr\xEB\xF0 \xEF\xF1 "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -27255,6 +27283,7 @@ var require_package_nls_ru = __commonJS({
         typedDictFieldReadOnlyRedefinition: '\u042D\u043B\u0435\u043C\u0435\u043D\u0442 TypedDict "{name}" \u043D\u0435\u043B\u044C\u0437\u044F \u043F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043A\u0430\u043A \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B\u0439 ReadOnly',
         typedDictFieldRequiredRedefinition: '\u042D\u043B\u0435\u043C\u0435\u043D\u0442 TypedDict "{name}" \u043D\u0435\u043B\u044C\u0437\u044F \u043F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043A\u0430\u043A Required',
         typedDictFirstArg: "\u0412 \u043A\u0430\u0447\u0435\u0441\u0442\u0432\u0435 \u043F\u0435\u0440\u0432\u043E\u0433\u043E \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442\u0430 \u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F \u0438\u043C\u044F \u043A\u043B\u0430\u0441\u0441\u0430 TypedDict",
+        typedDictInClassPattern: "\u041A\u043B\u0430\u0441\u0441 TypedDict \u043D\u0435 \u0440\u0430\u0437\u0440\u0435\u0448\u0435\u043D \u0432 \u0448\u0430\u0431\u043B\u043E\u043D\u0435 \u043A\u043B\u0430\u0441\u0441\u0430",
         typedDictInitsubclassParameter: 'TypedDict \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 __init_subclass__ "{name}"',
         typedDictNotAllowed: '\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C "TypedDict" \u0432 \u044D\u0442\u043E\u043C \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0435',
         typedDictSecondArgDict: "\u0412 \u043A\u0430\u0447\u0435\u0441\u0442\u0432\u0435 \u0432\u0442\u043E\u0440\u043E\u0433\u043E \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430 \u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F dict \u0438\u043B\u0438 \u043A\u043B\u044E\u0447\u0435\u0432\u043E\u0435 \u0441\u043B\u043E\u0432\u043E",
@@ -27484,7 +27513,7 @@ var require_package_nls_ru = __commonJS({
         typedDictClosedExtraTypeMismatch: '\u041D\u0435 \u0443\u0434\u0430\u0435\u0442\u0441\u044F \u0434\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u044D\u043B\u0435\u043C\u0435\u043D\u0442 "{name}" \u0442\u0438\u043F\u0430 "{type}"',
         typedDictClosedFieldNotRequired: '\u041D\u0435 \u0443\u0434\u0430\u0435\u0442\u0441\u044F \u0434\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u044D\u043B\u0435\u043C\u0435\u043D\u0442 "{name}", \u0442\u0430\u043A \u043A\u0430\u043A \u043E\u043D \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043F\u043E\u043C\u0435\u0447\u0435\u043D \u043A\u0430\u043A NotRequired',
         typedDictExtraFieldNotAllowed: '\u042D\u043B\u0435\u043C\u0435\u043D\u0442 "{name}" \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u0432 \u0442\u0438\u043F\u0435 "{type}"',
-        typedDictExtraFieldTypeMismatch: '\u0422\u0438\u043F \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430 "{name}" \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C \u0441 \u0442\u0438\u043F\u043E\u043C "__extra_items__" \u0432 "{type}"',
+        typedDictExtraFieldTypeMismatch: '\u0422\u0438\u043F \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430 "{name}" \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C \u0441 \u0442\u0438\u043F\u043E\u043C "extra_items" \u0432 "{type}"',
         typedDictFieldMissing: '"{name}" \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u0432 "{type}"',
         typedDictFieldNotReadOnly: '"{name}" \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u043C "{type}" \u0442\u043E\u043B\u044C\u043A\u043E \u0434\u043B\u044F \u0447\u0442\u0435\u043D\u0438\u044F',
         typedDictFieldNotRequired: '"{name}" \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u044B\u043C \u0432 "{type}"',
@@ -28081,6 +28110,7 @@ var require_package_nls_tr = __commonJS({
         typedDictFieldReadOnlyRedefinition: '"{name}" TypedDict \xF6\u011Fesi ReadOnly olarak yeniden tan\u0131mlanamaz',
         typedDictFieldRequiredRedefinition: '"{name}" TypedDict \xF6\u011Fesi Required olarak yeniden tan\u0131mlanamaz',
         typedDictFirstArg: "Birinci ba\u011F\u0131ms\u0131z de\u011Fi\u015Fken olarak TypedDict s\u0131n\u0131f ad\u0131 bekleniyordu",
+        typedDictInClassPattern: "TypedDict s\u0131n\u0131f\u0131na s\u0131n\u0131f deseninde izin verilmez",
         typedDictInitsubclassParameter: 'TypedDict, "{name}" __init_subclass__ parametresini desteklemez',
         typedDictNotAllowed: '"TypedDict" bu ba\u011Flamda kullan\u0131lamaz',
         typedDictSecondArgDict: "Expected dict or keyword parameter as second parameter",
@@ -28310,7 +28340,7 @@ var require_package_nls_tr = __commonJS({
         typedDictClosedExtraTypeMismatch: '"{type}" t\xFCr\xFCndeki "{name}" \xF6\u011Fesi eklenemiyor',
         typedDictClosedFieldNotRequired: 'NotRequired olmas\u0131 gerekti\u011Finden "{name}" \xF6\u011Fesi eklenemiyor',
         typedDictExtraFieldNotAllowed: '"{name}" \xF6\u011Fesi "{type}" t\xFCr\xFCnde mevcut de\u011Fil',
-        typedDictExtraFieldTypeMismatch: '"{name}" t\xFCr\xFC, "{type}" alt\u0131ndaki "__extra_items__" t\xFCr\xFCyle uyumlu de\u011Fil',
+        typedDictExtraFieldTypeMismatch: '"{name}" t\xFCr\xFC, "{type}" alt\u0131ndaki "extra_items" t\xFCr\xFCyle uyumlu de\u011Fil',
         typedDictFieldMissing: '"{type}" i\xE7in "{name}" eksik',
         typedDictFieldNotReadOnly: '"{name}", "{type}" i\xE7inde salt okunur de\u011Fil',
         typedDictFieldNotRequired: '"{type}" i\xE7inde "{name}" gerekli de\u011Fil',
@@ -28382,7 +28412,7 @@ var require_package_nls_zh_cn = __commonJS({
         assertAlwaysTrue: "\u65AD\u8A00\u8868\u8FBE\u5F0F\u7684\u8BA1\u7B97\u7ED3\u679C\u59CB\u7EC8\u4E3A true",
         assertTypeArgs: "\u201Cassert_type\u201D\u9700\u8981\u4E24\u4E2A\u4F4D\u7F6E\u53C2\u6570",
         assertTypeTypeMismatch: "\u201Cassert_type\u201D\u4E0D\u5339\u914D:\u5E94\u4E3A\u201C{expected}\u201D\uFF0C\u4F46\u6536\u5230\u201C{received}\u201D",
-        assignmentExprComprehension: "\u8D4B\u503C\u8868\u8FBE\u5F0F\u76EE\u6807\u201C{name}\u201D\u4E0D\u80FD\u4F7F\u7528\u4E0E\u76EE\u6807\u7406\u89E3\u76F8\u540C\u7684\u540D\u79F0",
+        assignmentExprComprehension: "\u8D4B\u503C\u8868\u8FBE\u5F0F\u76EE\u6807\u201C{name}\u201D\u4E0D\u80FD\u4F7F\u7528\u4E0E\u76EE\u6807\u63A8\u5BFC\u5F0F\u76F8\u540C\u7684\u540D\u79F0",
         assignmentExprContext: "\u8D4B\u503C\u8868\u8FBE\u5F0F\u5FC5\u987B\u5728\u6A21\u5757\u3001\u51FD\u6570\u6216 lambda \u4E2D",
         assignmentExprInSubscript: "\u4EC5\u5728 Python 3.10 \u548C\u66F4\u9AD8\u7248\u672C\u4E2D\u652F\u6301\u4E0B\u6807\u4E2D\u7684\u8D4B\u503C\u8868\u8FBE\u5F0F",
         assignmentInProtocol: "Protocol \u7C7B\u4E2D\u7684\u5B9E\u4F8B\u6216\u7C7B\u53D8\u91CF\u5FC5\u987B\u5728\u7C7B\u4E3B\u4F53\u5185\u663E\u5F0F\u58F0\u660E",
@@ -28428,7 +28458,7 @@ var require_package_nls_zh_cn = __commonJS({
         collectionAliasInstantiation: "\u65E0\u6CD5\u5B9E\u4F8B\u5316\u7C7B\u578B\u201C{type}\u201D\uFF0C\u8BF7\u6539\u7528\u201C{alias}\u201D",
         comparisonAlwaysFalse: "\u6761\u4EF6\u7684\u8BA1\u7B97\u7ED3\u679C\u59CB\u7EC8\u4E3A False\uFF0C\u56E0\u4E3A\u7C7B\u578B\u201C{leftType}\u201D\u548C\u201C{rightType}\u201D\u6CA1\u6709\u91CD\u53E0",
         comparisonAlwaysTrue: "\u6761\u4EF6\u7684\u8BA1\u7B97\u7ED3\u679C\u59CB\u7EC8\u4E3A True\uFF0C\u56E0\u4E3A\u7C7B\u578B\u201C{leftType}\u201D\u548C\u201C{rightType}\u201D\u6CA1\u6709\u91CD\u53E0",
-        comprehensionInDict: "\u7406\u89E3\u4E0D\u80FD\u4E0E\u5176\u4ED6\u5B57\u5178\u6761\u76EE\u4E00\u8D77\u4F7F\u7528",
+        comprehensionInDict: "\u63A8\u5BFC\u5F0F\u4E0D\u80FD\u4E0E\u5176\u4ED6\u5B57\u5178\u6761\u76EE\u4E00\u8D77\u4F7F\u7528",
         comprehensionInSet: "\u63A8\u5BFC\u5F0F\u4E0D\u80FD\u4E0E\u5176\u4ED6 set \u6761\u76EE\u4E00\u8D77\u4F7F\u7528",
         concatenateContext: "\u6B64\u4E0A\u4E0B\u6587\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u201CConcatenate\u201D",
         concatenateParamSpecMissing: '\u201CConcatenate\u201D\u7684\u6700\u540E\u4E00\u4E2A\u7C7B\u578B\u53C2\u6570\u5FC5\u987B\u662F ParamSpec \u6216 "..."',
@@ -28473,7 +28503,7 @@ var require_package_nls_zh_cn = __commonJS({
         deprecatedPropertyGetter: '\u5DF2\u5F03\u7528 property "{name}" \u7684 getter',
         deprecatedPropertySetter: '\u5DF2\u5F03\u7528 property "{name}" \u7684 setter',
         deprecatedType: "\u81EA Python {version} \u8D77\uFF0C\u6B64\u7C7B\u578B\u5DF2\u5F03\u7528\uFF1B\u8BF7\u6539\u7528\u201C{replacement}\u201D",
-        dictExpandIllegalInComprehension: "\u7406\u89E3\u4E2D\u4E0D\u5141\u8BB8\u5B57\u5178\u6269\u5C55",
+        dictExpandIllegalInComprehension: "\u63A8\u5BFC\u5F0F\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u5B57\u5178\u6269\u5C55",
         dictInAnnotation: "\u7C7B\u578B\u8868\u8FBE\u5F0F\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u5B57\u5178\u8868\u8FBE\u5F0F",
         dictKeyValuePairs: "\u5B57\u5178\u6761\u76EE\u5FC5\u987B\u5305\u542B\u952E/\u503C\u5BF9",
         dictUnpackIsNotMapping: "\u5B57\u5178\u89E3\u5305\u8FD0\u7B97\u7B26\u7684\u9884\u671F\u6620\u5C04",
@@ -28907,6 +28937,7 @@ var require_package_nls_zh_cn = __commonJS({
         typedDictFieldReadOnlyRedefinition: "\u65E0\u6CD5\u5C06 TypedDict \u9879\u201C{name}\u201D\u91CD\u65B0\u5B9A\u4E49\u4E3A ReadOnly",
         typedDictFieldRequiredRedefinition: "\u65E0\u6CD5\u5C06 TypedDict \u9879\u201C{name}\u201D\u91CD\u65B0\u5B9A\u4E49\u4E3A Required",
         typedDictFirstArg: "\u5E94\u5C06 TypedDict \u7C7B\u540D\u4F5C\u4E3A\u7B2C\u4E00\u4E2A\u53C2\u6570",
+        typedDictInClassPattern: "\u7C7B\u6A21\u5F0F\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528 TypedDict \u7C7B",
         typedDictInitsubclassParameter: "TypedDict \u4E0D\u652F\u6301 __init_subclass__ parameter\u201C{name}\u201D",
         typedDictNotAllowed: '"TypedDict" \u4E0D\u80FD\u7528\u4E8E\u6B64\u4E0A\u4E0B\u6587',
         typedDictSecondArgDict: "\u9884\u671F\u7684 dict \u6216\u5173\u952E\u5B57\u53C2\u6570\u4F5C\u4E3A\u7B2C\u4E8C\u4E2A\u53C2\u6570",
@@ -28943,7 +28974,7 @@ var require_package_nls_zh_cn = __commonJS({
         unpackArgCount: '"Unpack"\u540E\u5E94\u4E3A\u5355\u4E2A\u7C7B\u578B\u53C2\u6570',
         unpackExpectedTypeVarTuple: "Unpack \u9884\u671F\u63A5\u6536 TypeVarTuple \u6216 tuple \u4F5C\u4E3A\u7C7B\u578B\u53C2\u6570",
         unpackExpectedTypedDict: "Unpack \u9884\u671F\u63A5\u6536 TypedDict \u7C7B\u578B\u53C2\u6570",
-        unpackIllegalInComprehension: "\u5728\u7406\u89E3\u4E2D\u4E0D\u5141\u8BB8\u89E3\u5305\u64CD\u4F5C",
+        unpackIllegalInComprehension: "\u5728\u63A8\u5BFC\u5F0F\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u89E3\u5305\u64CD\u4F5C",
         unpackInAnnotation: "\u7C7B\u578B\u8868\u8FBE\u5F0F\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u89E3\u5305\u8FD0\u7B97\u7B26",
         unpackInDict: "\u5B57\u5178\u4E2D\u4E0D\u5141\u8BB8\u89E3\u538B\u7F29\u64CD\u4F5C",
         unpackInSet: "set \u5185\u4E0D\u5141\u8BB8\u4F7F\u7528\u89E3\u5305\u8FD0\u7B97\u7B26",
@@ -28978,7 +29009,7 @@ var require_package_nls_zh_cn = __commonJS({
         yieldFromIllegal: "\u4F7F\u7528\u201Cyield from\u201D\u9700\u8981 Python 3.3 \u6216\u66F4\u9AD8\u7248\u672C",
         yieldFromOutsideAsync: 'async \u51FD\u6570\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528 "yield from"',
         yieldOutsideFunction: "\u4E0D\u5141\u8BB8\u5728\u51FD\u6570\u6216 lambda \u4E4B\u5916\u4F7F\u7528\u201Cyield\u201D",
-        yieldWithinComprehension: '\u4E0D\u5141\u8BB8\u5728\u7406\u89E3\u4E2D\u4F7F\u7528 "yield"',
+        yieldWithinComprehension: '\u5141\u8BB8\u5728\u63A8\u5BFC\u5F0F\u4E2D\u4F7F\u7528 "yield"',
         zeroCaseStatementsFound: "Match \u8BED\u53E5\u5FC5\u987B\u81F3\u5C11\u5305\u542B\u4E00\u4E2A case \u8BED\u53E5",
         zeroLengthTupleNotAllowed: "\u6B64\u4E0A\u4E0B\u6587\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u96F6\u957F\u5EA6 tuple"
       },
@@ -29136,7 +29167,7 @@ var require_package_nls_zh_cn = __commonJS({
         typedDictClosedExtraTypeMismatch: "\u65E0\u6CD5\u6DFB\u52A0\u7C7B\u578B\u4E3A\u201C{type}\u201D\u7684\u9879\u201C{name}\u201D",
         typedDictClosedFieldNotRequired: "\u65E0\u6CD5\u6DFB\u52A0\u9879\u201C{name}\u201D\uFF0C\u56E0\u4E3A\u5B83\u5FC5\u987B\u662F NotRequired",
         typedDictExtraFieldNotAllowed: "\u201C{type}\u201D\u4E2D\u4E0D\u5B58\u5728\u201C{name}\u201D",
-        typedDictExtraFieldTypeMismatch: "\u201C{name}\u201D\u7684\u7C7B\u578B\u4E0E\u201C{type}\u201D\u4E2D\u7684 \u201C__extra_items__\u201D \u7C7B\u578B\u4E0D\u517C\u5BB9",
+        typedDictExtraFieldTypeMismatch: "\u201C{name}\u201D\u7684\u7C7B\u578B\u4E0E\u201C{type}\u201D\u4E2D\u7684 \u201Cextra_items\u201D \u7C7B\u578B\u4E0D\u517C\u5BB9",
         typedDictFieldMissing: '"{type}"\u4E2D\u7F3A\u5C11"{name}"',
         typedDictFieldNotReadOnly: '"{name}"\u5728"{type}"\u4E2D\u4E0D\u662F\u53EA\u8BFB\u7684',
         typedDictFieldNotRequired: "\u201C{type}\u201D\u4E2D\u4E0D\u9700\u8981\u201C{name}\u201D",
@@ -29208,7 +29239,7 @@ var require_package_nls_zh_tw = __commonJS({
         assertAlwaysTrue: "Assert \u904B\u7B97\u5F0F\u4E00\u5F8B\u6703\u8A55\u4F30\u70BA true",
         assertTypeArgs: '"assert_type" \u9700\u8981\u5169\u500B\u4F4D\u7F6E\u5F15\u6578',
         assertTypeTypeMismatch: '"assert_type" \u4E0D\u7B26: \u9810\u671F\u70BA "{expected}"\uFF0C\u4F46\u6536\u5230 "{received}"',
-        assignmentExprComprehension: '\u6307\u6D3E\u904B\u7B97\u5F0F\u76EE\u6A19 "{name}" \u4E0D\u80FD\u4F7F\u7528\u8207\u76EE\u6A19 comprehension \u76F8\u540C\u7684\u540D\u7A31',
+        assignmentExprComprehension: '\u6307\u6D3E\u904B\u7B97\u5F0F\u76EE\u6A19 "{name}" \u4E0D\u80FD\u4F7F\u7528\u8207\u76EE\u6A19 Comprehension \u76F8\u540C\u7684\u540D\u7A31',
         assignmentExprContext: "Assignment \u904B\u7B97\u5F0F\u5FC5\u9808\u5728\u6A21\u7D44\u3001\u51FD\u5F0F\u6216 Lambda \u5167",
         assignmentExprInSubscript: "\u4E0B\u6A19\u5167\u7684 Assignment \u904B\u7B97\u5F0F\u50C5\u5728 Python 3.10 \u548C\u66F4\u65B0\u7248\u672C\u4E2D\u652F\u63F4",
         assignmentInProtocol: "\u5FC5\u9808\u5728\u985E\u5225\u4E3B\u9AD4\u5167\u660E\u78BA\u5BA3\u544A Protocol \u985E\u5225\u5167\u7684\u57F7\u884C\u500B\u9AD4\u6216\u985E\u5225\u8B8A\u6578",
@@ -29254,7 +29285,7 @@ var require_package_nls_zh_tw = __commonJS({
         collectionAliasInstantiation: '\u7121\u6CD5\u5C07\u578B\u5225 "{type}" \u5177\u73FE\u5316\uFF0C\u8ACB\u6539\u7528 "{alias}"',
         comparisonAlwaysFalse: '\u689D\u4EF6\u4E00\u5F8B\u6703\u8A55\u4F30\u70BA False\uFF0C\u56E0\u70BA\u985E\u578B "{leftType}" \u548C "{rightType}" \u6C92\u6709\u91CD\u758A',
         comparisonAlwaysTrue: '\u689D\u4EF6\u4E00\u5F8B\u6703\u8A55\u4F30\u70BA True\uFF0C\u56E0\u70BA\u985E\u578B "{leftType}" \u548C "{rightType}" \u6C92\u6709\u91CD\u758A',
-        comprehensionInDict: "\u7406\u89E3\u4E0D\u80FD\u8207\u5176\u4ED6\u5B57\u5178\u9805\u76EE\u642D\u914D\u4F7F\u7528",
+        comprehensionInDict: "Comprehension \u4E0D\u80FD\u8207\u5176\u4ED6\u5B57\u5178\u9805\u76EE\u642D\u914D\u4F7F\u7528",
         comprehensionInSet: "Comprehension \u7121\u6CD5\u8207\u5176\u4ED6 set \u8F38\u5165\u9805\u76EE\u4E00\u8D77\u4F7F\u7528",
         concatenateContext: '\u6B64\u5167\u5BB9\u4E2D\u4E0D\u5141\u8A31 "Concatenate"',
         concatenateParamSpecMissing: '"Concatenate" \u7684\u6700\u5F8C\u4E00\u500B\u985E\u578B\u5F15\u6578\u5FC5\u9808\u662F ParamSpec \u6216 "..."',
@@ -29299,7 +29330,7 @@ var require_package_nls_zh_tw = __commonJS({
         deprecatedPropertyGetter: 'The getter for property "{name}" is deprecated',
         deprecatedPropertySetter: 'The setter for property "{name}" is deprecated',
         deprecatedType: '\u6B64\u985E\u578B\u5DF2\u96A8\u8457 Python {version} \u53D6\u4EE3; \u8ACB\u6539\u70BA\u4F7F\u7528 "{replacement}"',
-        dictExpandIllegalInComprehension: "\u7406\u89E3\u4E2D\u4E0D\u5141\u8A31\u5B57\u5178\u64F4\u5145",
+        dictExpandIllegalInComprehension: "Comprehension \u4E2D\u4E0D\u5141\u8A31\u5B57\u5178\u64F4\u5145",
         dictInAnnotation: "\u985E\u578B\u904B\u7B97\u5F0F\u4E2D\u4E0D\u5141\u8A31\u5B57\u5178\u904B\u7B97\u5F0F",
         dictKeyValuePairs: "\u5B57\u5178\u9805\u76EE\u5FC5\u9808\u5305\u542B\u91D1\u9470/\u503C\u7D44",
         dictUnpackIsNotMapping: "\u9810\u671F\u70BA\u5B57\u5178\u89E3\u58D3\u7E2E\u904B\u7B97\u5B50\u7684\u5C0D\u61C9",
@@ -29733,6 +29764,7 @@ var require_package_nls_zh_tw = __commonJS({
         typedDictFieldReadOnlyRedefinition: 'TypedDict \u9805\u76EE "{name}" \u4E0D\u80FD\u91CD\u65B0\u5B9A\u7FA9\u70BA ReadOnly',
         typedDictFieldRequiredRedefinition: 'TypedDict \u9805\u76EE "{name}" \u4E0D\u80FD\u91CD\u65B0\u5B9A\u7FA9\u70BA Required',
         typedDictFirstArg: "\u9810\u671F TypedDict \u985E\u5225\u540D\u7A31\u4F5C\u70BA\u7B2C\u4E00\u500B\u5F15\u6578",
+        typedDictInClassPattern: "\u985E\u5225\u6A21\u5F0F\u4E2D\u4E0D\u5141\u8A31 TypedDict \u985E\u5225",
         typedDictInitsubclassParameter: 'TypedDict \u4E0D\u652F\u63F4__init_subclass__\u53C3\u6578 "{name}"',
         typedDictNotAllowed: '"TypedDict" \u4E0D\u80FD\u7528\u5728\u6B64\u5167\u5BB9\u4E2D',
         typedDictSecondArgDict: "\u9810\u671F\u70BA dict \u6216\u95DC\u9375\u5B57\u53C3\u6578\u4F5C\u70BA\u7B2C\u4E8C\u500B\u53C3\u6578",
@@ -29769,7 +29801,7 @@ var require_package_nls_zh_tw = __commonJS({
         unpackArgCount: '"Unpack" \u5F8C\u9762\u61C9\u70BA\u55AE\u4E00\u578B\u5225\u5F15\u6578',
         unpackExpectedTypeVarTuple: "\u9810\u671F TypeVarTuple \u6216 tuple \u4F5C\u70BA Unpack \u7684\u985E\u578B\u5F15\u6578",
         unpackExpectedTypedDict: "\u61C9\u70BA Unpack \u7684 TypedDict \u578B\u5225\u5F15\u6578",
-        unpackIllegalInComprehension: "\u7406\u89E3\u4E2D\u4E0D\u5141\u8A31\u89E3\u58D3\u7E2E\u4F5C\u696D",
+        unpackIllegalInComprehension: "Comprehension \u4E2D\u4E0D\u5141\u8A31\u89E3\u58D3\u7E2E\u4F5C\u696D",
         unpackInAnnotation: "\u985E\u578B\u904B\u7B97\u5F0F\u4E2D\u4E0D\u5141\u8A31\u89E3\u58D3\u7E2E\u904B\u7B97\u5B50",
         unpackInDict: "\u5B57\u5178\u4E2D\u4E0D\u5141\u8A31\u89E3\u58D3\u7E2E\u4F5C\u696D",
         unpackInSet: "Unpack operator not allowed within a set",
@@ -29804,7 +29836,7 @@ var require_package_nls_zh_tw = __commonJS({
         yieldFromIllegal: '\u4F7F\u7528 "yield from" \u9700\u8981 Python 3.3 \u6216\u66F4\u65B0\u7248\u672C',
         yieldFromOutsideAsync: '"yield from" not allowed in an async function',
         yieldOutsideFunction: '\u5728\u51FD\u5F0F\u6216 lambda \u5916\u90E8\u4E0D\u5141\u8A31 "yield"',
-        yieldWithinComprehension: '\u7406\u89E3\u5167\u4E0D\u5141\u8A31 "yield"',
+        yieldWithinComprehension: 'Comprehension \u5167\u4E0D\u5141\u8A31 "yield"',
         zeroCaseStatementsFound: "Match \u9673\u8FF0\u5F0F\u5FC5\u9808\u81F3\u5C11\u5305\u542B\u4E00\u500B case \u9673\u8FF0\u5F0F",
         zeroLengthTupleNotAllowed: "\u6B64\u5167\u5BB9\u4E2D\u4E0D\u5141\u8A31\u96F6\u9577\u5EA6 tuple"
       },
@@ -29962,7 +29994,7 @@ var require_package_nls_zh_tw = __commonJS({
         typedDictClosedExtraTypeMismatch: '\u7121\u6CD5\u65B0\u589E\u578B\u5225\u70BA "{type}" \u7684\u9805\u76EE "{name}"',
         typedDictClosedFieldNotRequired: '\u7121\u6CD5\u65B0\u589E\u9805\u76EE "{name}"\uFF0C\u56E0\u70BA\u5B83\u5FC5\u9808\u662F NotRequired',
         typedDictExtraFieldNotAllowed: '"{name}" \u4E0D\u5B58\u5728\u65BC "{type}"',
-        typedDictExtraFieldTypeMismatch: '"{name}" \u578B\u5225\u8207 "{type}" \u4E2D\u7684 "__extra_items__" \u578B\u5225\u4E0D\u76F8\u5BB9',
+        typedDictExtraFieldTypeMismatch: '"{name}" \u578B\u5225\u8207 "{type}" \u4E2D\u7684 "extra_items" \u578B\u5225\u4E0D\u76F8\u5BB9',
         typedDictFieldMissing: '"{type}" \u907A\u5931 "{name}"',
         typedDictFieldNotReadOnly: '"{name}" \u5728 "{type}" \u4E2D\u4E0D\u662F\u552F\u8B80',
         typedDictFieldNotRequired: '"{type}" \u4E2D\u4E0D\u9700\u8981 "{name}"',
@@ -30233,6 +30265,7 @@ var require_localize = __commonJS({
         Diagnostic4.dataClassConverterFunction = () => new ParameterizedString(getRawString("Diagnostic.dataClassConverterFunction"));
         Diagnostic4.dataClassConverterOverloads = () => new ParameterizedString(getRawString("Diagnostic.dataClassConverterOverloads"));
         Diagnostic4.dataClassFieldInheritedDefault = () => new ParameterizedString(getRawString("Diagnostic.dataClassFieldInheritedDefault"));
+        Diagnostic4.dataClassFieldInvalidAlias = () => new ParameterizedString(getRawString("Diagnostic.dataClassFieldInvalidAlias"));
         Diagnostic4.dataClassFieldWithDefault = () => getRawString("Diagnostic.dataClassFieldWithDefault");
         Diagnostic4.dataClassFieldWithoutAnnotation = () => getRawString("Diagnostic.dataClassFieldWithoutAnnotation");
         Diagnostic4.dataClassFieldWithPrivateName = () => getRawString("Diagnostic.dataClassFieldWithPrivateName");
@@ -30639,6 +30672,7 @@ var require_localize = __commonJS({
         Diagnostic4.typedDictEntryName = () => getRawString("Diagnostic.typedDictEntryName");
         Diagnostic4.typedDictEntryUnique = () => getRawString("Diagnostic.typedDictEntryUnique");
         Diagnostic4.typedDictExtraArgs = () => getRawString("Diagnostic.typedDictExtraArgs");
+        Diagnostic4.typedDictExtraItemsClosed = () => getRawString("Diagnostic.typedDictExtraItemsClosed");
         Diagnostic4.typedDictFieldNotRequiredRedefinition = () => new ParameterizedString(getRawString("Diagnostic.typedDictFieldNotRequiredRedefinition"));
         Diagnostic4.typedDictFieldReadOnlyRedefinition = () => new ParameterizedString(getRawString("Diagnostic.typedDictFieldReadOnlyRedefinition"));
         Diagnostic4.typedDictFieldRequiredRedefinition = () => new ParameterizedString(getRawString("Diagnostic.typedDictFieldRequiredRedefinition"));
@@ -41518,6 +41552,14 @@ var require_tokenizer = __commonJS({
         }
         return !_softKeywords.has(name);
       }
+      static isPythonIdentifier(value) {
+        for (let i = 0; i < value.length; i++) {
+          if (i === 0 ? !(0, characters_1.isIdentifierStartChar)(value.charCodeAt(i)) : !(0, characters_1.isIdentifierChar)(value.charCodeAt(i))) {
+            return false;
+          }
+        }
+        return true;
+      }
       static isOperatorAssignment(operatorType) {
         if (operatorType === void 0 || _operatorInfo[operatorType] === void 0) {
           return false;
@@ -43429,7 +43471,6 @@ var require_binder = __commonJS({
     var AnalyzerNodeInfo = __importStar(require_analyzerNodeInfo());
     var codeFlowTypes_1 = require_codeFlowTypes();
     var declaration_1 = require_declaration();
-    var docStringUtils_1 = require_docStringUtils();
     var ParseTreeUtils = __importStar(require_parseTreeUtils());
     var parseTreeWalker_1 = require_parseTreeWalker();
     var scope_1 = require_scope();
@@ -43677,7 +43718,7 @@ var require_binder = __commonJS({
                   const symbol2 = this._bindNameToScope(this._currentScope, paramNode.d.name);
                   let docString = ParseTreeUtils.getDocString((_b = (_a = node === null || node === void 0 ? void 0 : node.d.suite) === null || _a === void 0 ? void 0 : _a.d.statements) !== null && _b !== void 0 ? _b : []);
                   if (docString !== void 0) {
-                    docString = (0, docStringUtils_1.extractParameterDocumentation)(docString, paramNode.d.name.d.value);
+                    docString = this._docStringService.extractParameterDocumentation(docString, paramNode.d.name.d.value);
                   }
                   if (symbol2) {
                     const paramDeclaration = {
@@ -46636,6 +46677,7 @@ var require_types = __commonJS({
     exports2.isParamSpec = isParamSpec;
     exports2.isTypeVarTuple = isTypeVarTuple;
     exports2.isUnpackedTypeVarTuple = isUnpackedTypeVarTuple;
+    exports2.isUnpackedTypeVar = isUnpackedTypeVar;
     exports2.isUnpackedClass = isUnpackedClass;
     exports2.isUnpacked = isUnpacked;
     exports2.isFunction = isFunction;
@@ -46648,6 +46690,7 @@ var require_types = __commonJS({
     exports2.findSubtype = findSubtype;
     exports2.combineTypes = combineTypes;
     exports2.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
+    var collectionUtils_1 = require_collectionUtils();
     var debug_1 = require_debug();
     var TypeCategory;
     (function(TypeCategory2) {
@@ -47104,21 +47147,30 @@ var require_types = __commonJS({
         return newClassType;
       }
       ClassType2.cloneRemoveTypePromotions = cloneRemoveTypePromotions;
-      function cloneForSymbolTableUpdate(classType) {
+      function cloneForPartial(classType, partialCallType) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.shared = { ...newClassType.shared };
-        newClassType.shared.fields = new Map(newClassType.shared.fields);
-        newClassType.shared.mro = Array.from(newClassType.shared.mro);
-        newClassType.shared.mro[0] = cloneAsInstantiable(newClassType);
+        newClassType.priv.partialCallType = partialCallType;
         return newClassType;
       }
-      ClassType2.cloneForSymbolTableUpdate = cloneForSymbolTableUpdate;
-      function cloneForUnpacked(classType, isUnpacked2 = true) {
+      ClassType2.cloneForPartial = cloneForPartial;
+      function cloneForUnpacked(classType) {
+        if (classType.priv.isUnpacked) {
+          return classType;
+        }
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.priv.isUnpacked = isUnpacked2;
+        newClassType.priv.isUnpacked = true;
         return newClassType;
       }
       ClassType2.cloneForUnpacked = cloneForUnpacked;
+      function cloneForPacked(classType) {
+        if (!classType.priv.isUnpacked) {
+          return classType;
+        }
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.priv.isUnpacked = false;
+        return newClassType;
+      }
+      ClassType2.cloneForPacked = cloneForPacked;
       function cloneWithNewFlags(classType, newFlags) {
         const newClassType = TypeBase.cloneType(classType);
         newClassType.shared = { ...newClassType.shared };
@@ -48359,7 +48411,9 @@ var require_types = __commonJS({
       function cloneForUnpacked(type, isInUnion = false) {
         const newInstance = TypeBase.cloneType(type);
         newInstance.priv.isUnpacked = true;
-        newInstance.priv.isInUnion = isInUnion;
+        if (isTypeVarTuple(newInstance) && isInUnion) {
+          newInstance.priv.isInUnion = isInUnion;
+        }
         if (newInstance.priv.freeTypeVar) {
           newInstance.priv.freeTypeVar = TypeVarType2.cloneForUnpacked(newInstance.priv.freeTypeVar, isInUnion);
         }
@@ -48492,8 +48546,8 @@ var require_types = __commonJS({
         return typeVarType.priv.nameWithScope || typeVarType.shared.name;
       }
       TypeVarType2.getNameWithScope = getNameWithScope;
-      function getReadableName(type) {
-        if (type.priv.scopeName) {
+      function getReadableName(type, includeScope = true) {
+        if (type.priv.scopeName && includeScope) {
           return `${type.shared.name}@${type.priv.scopeName}`;
         }
         return type.shared.name;
@@ -48583,6 +48637,9 @@ var require_types = __commonJS({
     function isUnpackedTypeVarTuple(type) {
       return isTypeVarTuple(type) && !!type.priv.isUnpacked && !type.priv.isInUnion;
     }
+    function isUnpackedTypeVar(type) {
+      return isTypeVar(type) && !isTypeVarTuple(type) && !!type.priv.isUnpacked;
+    }
     function isUnpackedClass(type) {
       if (!isClass(type) || !type.priv.isUnpacked) {
         return false;
@@ -48590,7 +48647,7 @@ var require_types = __commonJS({
       return true;
     }
     function isUnpacked(type) {
-      return isUnpackedTypeVarTuple(type) || isUnpackedClass(type);
+      return isUnpackedTypeVarTuple(type) || isUnpackedTypeVar(type) || isUnpackedClass(type);
     }
     function isFunction(type) {
       return type.category === 4;
@@ -48693,6 +48750,11 @@ var require_types = __commonJS({
           if (!type1.priv.isTypedDictPartial !== !classType2.priv.isTypedDictPartial) {
             return false;
           }
+          if (options.honorIsTypeArgExplicit) {
+            if (!!type1.priv.isTypeArgExplicit !== !!classType2.priv.isTypeArgExplicit) {
+              return false;
+            }
+          }
           if (!options.ignoreTypedDictNarrowEntries && !ClassType.isTypedDictNarrowedEntriesSame(type1, classType2)) {
             return false;
           }
@@ -48784,6 +48846,9 @@ var require_types = __commonJS({
           if (type1.priv.scopeId !== type2TypeVar.priv.scopeId) {
             return false;
           }
+          if (type1.priv.nameWithScope !== type2TypeVar.priv.nameWithScope) {
+            return false;
+          }
           if (type1.shared.recursiveAlias && type2TypeVar.shared.recursiveAlias) {
             const type1TypeArgs = ((_f = (_e = type1 === null || type1 === void 0 ? void 0 : type1.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo) === null || _f === void 0 ? void 0 : _f.typeArgs) || [];
             const type2TypeArgs = ((_h = (_g = type2 === null || type2 === void 0 ? void 0 : type2.props) === null || _g === void 0 ? void 0 : _g.typeAliasInfo) === null || _h === void 0 ? void 0 : _h.typeArgs) || [];
@@ -48887,20 +48952,14 @@ var require_types = __commonJS({
       return filter2(type) ? type : void 0;
     }
     function combineTypes(subtypes, options) {
-      var _a;
-      let sawNoReturn = false;
-      if (subtypes.some(
-        (subtype) => subtype.category === 3
-        /* TypeCategory.Never */
-      ))
-        subtypes = subtypes.filter((subtype) => {
-          if (subtype.category === 3 && subtype.priv.isNoReturn) {
-            sawNoReturn = true;
-          }
-          return subtype.category !== 3;
-        });
+      var _a, _b;
+      let neverTypes;
+      [neverTypes, subtypes] = (0, collectionUtils_1.partition)(subtypes, isNever);
       if (subtypes.length === 0) {
-        return sawNoReturn ? NeverType.createNoReturn() : NeverType.createNever();
+        if (neverTypes.length > 0) {
+          return (_a = neverTypes.find((t) => t.priv.isNoReturn)) !== null && _a !== void 0 ? _a : neverTypes[0];
+        }
+        return NeverType.createNever();
       }
       let allSubtypesAreSame = true;
       if (subtypes.length > 1) {
@@ -48923,7 +48982,7 @@ var require_types = __commonJS({
             expandedTypes = subtypes.slice(0, i);
           }
           expandedTypes = expandedTypes.concat(subtype.priv.subtypes);
-          if ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+          if ((_b = subtype.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) {
             typeAliasSources.add(subtype);
           } else if (subtype.priv.typeAliasSources) {
             subtype.priv.typeAliasSources.forEach((subtype2) => {
@@ -49433,6 +49492,8 @@ var require_typeUtils = __commonJS({
     exports2.combineSameSizedTuples = combineSameSizedTuples;
     exports2.combineTupleTypeArgs = combineTupleTypeArgs;
     exports2.specializeTupleClass = specializeTupleClass;
+    exports2.makePacked = makePacked;
+    exports2.makeUnpacked = makeUnpacked;
     exports2.getGeneratorTypeArgs = getGeneratorTypeArgs;
     exports2.requiresTypeArgs = requiresTypeArgs;
     exports2.requiresSpecialization = requiresSpecialization;
@@ -49441,7 +49502,6 @@ var require_typeUtils = __commonJS({
     exports2.isVarianceOfTypeArgCompatible = isVarianceOfTypeArgCompatible;
     exports2.computeMroLinearization = computeMroLinearization;
     exports2.getDeclaringModulesForType = getDeclaringModulesForType;
-    exports2.convertNodeToArg = convertNodeToArg;
     exports2.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
     exports2.simplifyFunctionToParamSpec = simplifyFunctionToParamSpec;
     var collectionUtils_1 = require_collectionUtils();
@@ -49757,6 +49817,16 @@ var require_typeUtils = __commonJS({
           if (isLiteralType(a)) {
             if (!isLiteralType(bClass)) {
               return -1;
+            } else if (types_1.ClassType.isSameGenericClass(a, bClass)) {
+              const aLiteralValue = a.priv.literalValue;
+              const bLiteralValue = bClass.priv.literalValue;
+              if (typeof aLiteralValue === "string" && typeof bLiteralValue === "string" || typeof aLiteralValue === "number" && typeof bLiteralValue === "number") {
+                if (aLiteralValue < bLiteralValue) {
+                  return -1;
+                } else if (aLiteralValue > bLiteralValue) {
+                  return 1;
+                }
+              }
             }
           } else if (isLiteralType(bClass)) {
             return 1;
@@ -49925,17 +49995,23 @@ var require_typeUtils = __commonJS({
       }
       return void 0;
     }
-    function addConditionToType(type, condition, skipSelfCondition = false) {
+    function addConditionToType(type, condition, options) {
       var _a, _b;
       if (!condition) {
         return type;
       }
-      if (skipSelfCondition) {
+      if (options === null || options === void 0 ? void 0 : options.skipSelfCondition) {
         condition = condition.filter((c) => !types_1.TypeVarType.isSelf(c.typeVar));
         if (condition.length === 0) {
           return type;
         }
       }
+      if (options === null || options === void 0 ? void 0 : options.skipBoundTypeVars) {
+        condition = condition.filter((c) => c.typeVar.shared.constraints.length > 0);
+        if (condition.length === 0) {
+          return type;
+        }
+      }
       switch (type.category) {
         case 0:
         case 1:
@@ -50278,13 +50354,13 @@ var require_typeUtils = __commonJS({
     }
     function isUnboundedTupleClass(type) {
       var _a;
-      return (_a = type.priv.tupleTypeArgs) === null || _a === void 0 ? void 0 : _a.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
+      return (_a = type.priv.tupleTypeArgs) === null || _a === void 0 ? void 0 : _a.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
     }
     function isTupleIndexUnambiguous(type, index) {
       if (!type.priv.tupleTypeArgs) {
         return false;
       }
-      const unboundedIndex = type.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
+      const unboundedIndex = type.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
       if (index < 0) {
         const lowerIndexLimit = unboundedIndex < 0 ? 0 : unboundedIndex;
         index += type.priv.tupleTypeArgs.length;
@@ -50384,7 +50460,7 @@ var require_typeUtils = __commonJS({
       }
     }
     function transformExpectedType(expectedType, liveTypeVarScopes, usageOffset) {
-      const transformer = new ExpectedTypeTransformer(liveTypeVarScopes, usageOffset);
+      const transformer = new UnificationTypeTransformer(liveTypeVarScopes, usageOffset);
       return transformer.apply(expectedType, 0);
     }
     function getProtocolSymbols(classType) {
@@ -50547,7 +50623,7 @@ var require_typeUtils = __commonJS({
             }
           }
           if ((flags & 32) === 0) {
-            const symbol = memberFields.get(memberName);
+            let symbol = memberFields.get(memberName);
             if (symbol && symbol.isClassMember()) {
               const hasDeclaredType = symbol.hasTypedDeclarations();
               if (!declaredTypesOnly || hasDeclaredType) {
@@ -50562,6 +50638,9 @@ var require_typeUtils = __commonJS({
                     isClassMember = isDataclass;
                   }
                 }
+                if (memberName === "__call__" && classType.priv.partialCallType && types_1.ClassType.isSameGenericClass(classType, specializedMroClass)) {
+                  symbol = symbol_1.Symbol.createWithType(4, classType.priv.partialCallType);
+                }
                 const cm = {
                   symbol,
                   isInstanceMember,
@@ -51200,16 +51279,27 @@ var require_typeUtils = __commonJS({
       })));
     }
     function combineTupleTypeArgs(typeArgs) {
-      return (0, types_1.combineTypes)(typeArgs.map((t) => {
-        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedTypeVarTuple)(t.type)) {
-          return types_1.TypeVarType.cloneForUnpacked(
-            t.type,
-            /* isInUnion */
-            true
-          );
+      const typesToCombine = [];
+      typeArgs.forEach((t) => {
+        if ((0, types_1.isTypeVar)(t.type)) {
+          if ((0, types_1.isUnpackedTypeVarTuple)(t.type)) {
+            typesToCombine.push(types_1.TypeVarType.cloneForUnpacked(
+              t.type,
+              /* isInUnion */
+              true
+            ));
+            return;
+          }
+          if ((0, types_1.isUnpackedTypeVar)(t.type)) {
+            if (t.type.shared.boundType && (0, types_1.isClassInstance)(t.type.shared.boundType) && isTupleClass(t.type.shared.boundType) && t.type.shared.boundType.priv.tupleTypeArgs) {
+              typesToCombine.push(combineTupleTypeArgs(t.type.shared.boundType.priv.tupleTypeArgs));
+            }
+            return;
+          }
         }
-        return t.type;
-      }));
+        typesToCombine.push(t.type);
+      });
+      return (0, types_1.combineTypes)(typesToCombine);
     }
     function specializeTupleClass(classType, typeArgs, isTypeArgExplicit = true, isUnpacked = false) {
       const clonedClassType = types_1.ClassType.specialize(
@@ -51231,6 +51321,30 @@ var require_typeUtils = __commonJS({
       }
       return type;
     }
+    function makePacked(type) {
+      if ((0, types_1.isUnpackedClass)(type)) {
+        return types_1.ClassType.cloneForPacked(type);
+      }
+      if ((0, types_1.isUnpackedTypeVarTuple)(type) && !type.priv.isInUnion) {
+        return types_1.TypeVarType.cloneForPacked(type);
+      }
+      if ((0, types_1.isUnpackedTypeVar)(type)) {
+        return types_1.TypeVarType.cloneForPacked(type);
+      }
+      return type;
+    }
+    function makeUnpacked(type) {
+      if ((0, types_1.isClass)(type)) {
+        return types_1.ClassType.cloneForUnpacked(type);
+      }
+      if ((0, types_1.isTypeVarTuple)(type) && !type.priv.isInUnion) {
+        return types_1.TypeVarType.cloneForUnpacked(type);
+      }
+      if ((0, types_1.isTypeVar)(type)) {
+        return types_1.TypeVarType.cloneForUnpacked(type);
+      }
+      return type;
+    }
     function getGeneratorTypeArgs(returnType) {
       var _a;
       if ((0, types_1.isClassInstance)(returnType)) {
@@ -51304,6 +51418,11 @@ var require_typeUtils = __commonJS({
           if (!type.priv.isTypeArgExplicit && (options === null || options === void 0 ? void 0 : options.ignoreImplicitTypeArgs)) {
             return false;
           }
+          if (type.priv.tupleTypeArgs) {
+            if (type.priv.tupleTypeArgs.some((typeArg) => requiresSpecialization(typeArg.type, options, recursionCount))) {
+              return true;
+            }
+          }
           if (type.priv.typeArgs) {
             return type.priv.typeArgs.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
           }
@@ -51516,13 +51635,6 @@ var require_typeUtils = __commonJS({
       addDeclaringModuleNamesForType(type, moduleList);
       return moduleList;
     }
-    function convertNodeToArg(node) {
-      return {
-        argCategory: node.d.argCategory,
-        name: node.d.name,
-        valueExpression: node.d.valueExpr
-      };
-    }
     function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
       if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -51798,6 +51910,8 @@ var require_typeUtils = __commonJS({
               }
               if ((0, types_1.isUnpackedTypeVarTuple)(oldTypeArgType.type) && (0, types_1.isClassInstance)(newTypeArgType) && isTupleClass(newTypeArgType) && newTypeArgType.priv.tupleTypeArgs) {
                 (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.priv.tupleTypeArgs);
+              } else if ((0, types_1.isUnpackedClass)(newTypeArgType) && newTypeArgType.priv.tupleTypeArgs) {
+                (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.priv.tupleTypeArgs);
               } else {
                 const isEmptyTuple = oldTypeArgType.isUnbounded && (0, types_1.isTypeVar)(oldTypeArgType.type) && (0, types_1.isNever)(newTypeArgType) && classType.priv.tupleTypeArgs.length === 1;
                 if (!isEmptyTuple) {
@@ -52129,9 +52243,15 @@ var require_typeUtils = __commonJS({
           if ((0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVarTuple)(typeVar) && typeVar.priv.isUnpacked) {
             return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isInUnion);
           }
+          if (!(0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVar)(replacement) && (0, types_1.isTypeVar)(typeVar) && typeVar.priv.isUnpacked) {
+            return types_1.TypeVarType.cloneForUnpacked(replacement);
+          }
           if (!(0, types_1.isTypeVarTuple)(typeVar) && (0, types_1.isClassInstance)(replacement) && replacement.priv.tupleTypeArgs && replacement.priv.isUnpacked) {
             replacement = combineTupleTypeArgs(replacement.priv.tupleTypeArgs);
           }
+          if ((0, types_1.isUnpackedTypeVar)(typeVar) && (0, types_1.isClass)(replacement)) {
+            replacement = types_1.ClassType.cloneForUnpacked(replacement);
+          }
           if (!(0, types_1.isTypeVar)(replacement) || !types_1.TypeVarType.isUnification(replacement) || !this._options.replaceUnsolved) {
             return replacement;
           }
@@ -52286,7 +52406,7 @@ var require_typeUtils = __commonJS({
         return result;
       }
     };
-    var ExpectedTypeTransformer = class extends TypeVarTransformer {
+    var UnificationTypeTransformer = class extends TypeVarTransformer {
       constructor(_liveTypeVarScopes, _usageOffset) {
         super();
         this._liveTypeVarScopes = _liveTypeVarScopes;
@@ -53515,7 +53635,7 @@ var require_constraintTracker = __commonJS({
           if (!type1 || !type2) {
             return type1 === type2;
           }
-          return (0, types_1.isTypeSame)(type1, type2);
+          return (0, types_1.isTypeSame)(type1, type2, { honorIsTypeArgExplicit: true, honorTypeForm: true });
         }
         let isSame = true;
         this._typeVarMap.forEach((value, key) => {
@@ -53676,8 +53796,9 @@ var require_typeEvaluatorTypes = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/typeEvaluatorTypes.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.AssignTypeFlags = exports2.Reachability = exports2.EvalFlags = exports2.maxSubtypesForInferredType = void 0;
+    exports2.AssignTypeFlags = exports2.Reachability = exports2.EvalFlags = exports2.maxInferredContainerDepth = exports2.maxSubtypesForInferredType = void 0;
     exports2.maxSubtypesForInferredType = 64;
+    exports2.maxInferredContainerDepth = 8;
     var EvalFlags;
     (function(EvalFlags2) {
       EvalFlags2[EvalFlags2["None"] = 0] = "None";
@@ -53697,13 +53818,15 @@ var require_typeEvaluatorTypes = __commonJS({
       EvalFlags2[EvalFlags2["TypeVarGetsCurScope"] = 8192] = "TypeVarGetsCurScope";
       EvalFlags2[EvalFlags2["EnforceVarianceConsistency"] = 16384] = "EnforceVarianceConsistency";
       EvalFlags2[EvalFlags2["VarTypeAnnotation"] = 32768] = "VarTypeAnnotation";
+      EvalFlags2[EvalFlags2["AllowEllipsis"] = 65536] = "AllowEllipsis";
       EvalFlags2[EvalFlags2["NoClassVar"] = 131072] = "NoClassVar";
       EvalFlags2[EvalFlags2["NoNakedGeneric"] = 262144] = "NoNakedGeneric";
       EvalFlags2[EvalFlags2["NotParsed"] = 524288] = "NotParsed";
       EvalFlags2[EvalFlags2["AllowRequired"] = 1048576] = "AllowRequired";
-      EvalFlags2[EvalFlags2["AllowUnpackedTuple"] = 2097152] = "AllowUnpackedTuple";
-      EvalFlags2[EvalFlags2["AllowUnpackedTypedDict"] = 4194304] = "AllowUnpackedTypedDict";
-      EvalFlags2[EvalFlags2["ParsesStringLiteral"] = 8388608] = "ParsesStringLiteral";
+      EvalFlags2[EvalFlags2["AllowReadOnly"] = 2097152] = "AllowReadOnly";
+      EvalFlags2[EvalFlags2["AllowUnpackedTuple"] = 4194304] = "AllowUnpackedTuple";
+      EvalFlags2[EvalFlags2["AllowUnpackedTypedDict"] = 8388608] = "AllowUnpackedTypedDict";
+      EvalFlags2[EvalFlags2["ParsesStringLiteral"] = 16777216] = "ParsesStringLiteral";
       EvalFlags2[EvalFlags2["NoConvertSpecialForm"] = 33554432] = "NoConvertSpecialForm";
       EvalFlags2[EvalFlags2["NoNonTypeSpecialForms"] = 67108864] = "NoNonTypeSpecialForms";
       EvalFlags2[EvalFlags2["AllowConcatenate"] = 134217728] = "AllowConcatenate";
@@ -53792,16 +53915,20 @@ var require_constraintSolver = __commonJS({
         isAssignable = assignParamSpec(evaluator, destType, srcType, diag, constraints, recursionCount);
       } else {
         if ((0, types_1.isTypeVarTuple)(destType) && !destType.priv.isInUnion) {
-          const tupleClassType = evaluator.getTupleClassType();
-          if (!(0, types_1.isUnpacked)(srcType) && tupleClassType) {
-            srcType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(
-              tupleClassType,
-              [{ type: srcType, isUnbounded: false }],
-              /* isTypeArgExplicit */
-              true,
-              /* isUnpacked */
-              true
-            ));
+          if (destType.priv.isUnpacked) {
+            const tupleClassType = evaluator.getTupleClassType();
+            if (!(0, types_1.isUnpacked)(srcType) && tupleClassType) {
+              srcType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(
+                tupleClassType,
+                [{ type: srcType, isUnbounded: false }],
+                /* isTypeArgExplicit */
+                true,
+                /* isUnpacked */
+                true
+              ));
+            }
+          } else {
+            srcType = (0, typeUtils_1.makeUnpacked)(srcType);
           }
         }
         if ((0, types_1.isTypeVarTuple)(srcType) && srcType.priv.isUnpacked && !srcType.priv.isInUnion && !(0, types_1.isTypeVarTuple)(destType)) {
@@ -53985,14 +54112,16 @@ var require_constraintSolver = __commonJS({
               if (liveTypeVarScopes) {
                 typeArgValue = (0, typeUtils_1.transformExpectedType)(typeArgValue, liveTypeVarScopes, usageOffset);
               }
-              if (typeArgValue) {
-                const variance = types_1.TypeVarType.getVariance(typeVar);
-                if (constraints.getMainConstraintSet().getTypeVar(targetTypeVar)) {
-                  isResultValid = false;
-                  typeArgValue = types_1.UnknownType.create();
-                }
-                constraints.setBounds(targetTypeVar, variance === 3 ? void 0 : typeArgValue, variance === 4 ? void 0 : typeArgValue);
-              } else {
+              if (!typeArgValue || !assignTypeVar(
+                evaluator,
+                targetTypeVar,
+                typeArgValue,
+                /* diag */
+                void 0,
+                constraints,
+                256
+                /* AssignTypeFlags.RetainLiteralsForTypeVar */
+              )) {
                 isResultValid = false;
               }
             }
@@ -54614,6 +54743,7 @@ var require_parameterUtils = __commonJS({
       ParamKind2[ParamKind2["Positional"] = 0] = "Positional";
       ParamKind2[ParamKind2["Standard"] = 1] = "Standard";
       ParamKind2[ParamKind2["Keyword"] = 2] = "Keyword";
+      ParamKind2[ParamKind2["ExpandedArgs"] = 3] = "ExpandedArgs";
     })(ParamKind || (exports2.ParamKind = ParamKind = {}));
     function getParamListDetails(type) {
       const result = {
@@ -54694,7 +54824,7 @@ var require_parameterUtils = __commonJS({
                 tupleArg.type,
                 /* defaultArgTypeOverride */
                 void 0,
-                ParamKind.Positional
+                ParamKind.ExpandedArgs
               );
               if (category === 0) {
                 result.positionParamCount++;
@@ -54825,7 +54955,6 @@ var require_constructorTransform = __commonJS({
     var constraintTracker_1 = require_constraintTracker();
     var constructors_1 = require_constructors();
     var parameterUtils_1 = require_parameterUtils();
-    var symbol_1 = require_symbol();
     var types_1 = require_types();
     var typeUtils_1 = require_typeUtils();
     function hasConstructorTransform(classType) {
@@ -54885,8 +55014,7 @@ var require_constructorTransform = __commonJS({
         if (!transformResult) {
           return void 0;
         }
-        const newPartialClass = types_1.ClassType.cloneForSymbolTableUpdate(result.returnType);
-        types_1.ClassType.getSymbolTable(newPartialClass).set("__call__", symbol_1.Symbol.createWithType(4, transformResult.returnType));
+        const newPartialClass = types_1.ClassType.cloneForPartial(result.returnType, transformResult.returnType);
         return {
           returnType: newPartialClass,
           isTypeIncomplete: result.isTypeIncomplete,
@@ -54922,7 +55050,6 @@ var require_constructorTransform = __commonJS({
           }
           return void 0;
         }
-        const newPartialClass = types_1.ClassType.cloneForSymbolTableUpdate(result.returnType);
         let synthesizedCallType;
         if (applicableOverloads.length === 1) {
           synthesizedCallType = applicableOverloads[0];
@@ -54936,7 +55063,7 @@ var require_constructorTransform = __commonJS({
             ))
           );
         }
-        types_1.ClassType.getSymbolTable(newPartialClass).set("__call__", symbol_1.Symbol.createWithType(4, synthesizedCallType));
+        const newPartialClass = types_1.ClassType.cloneForPartial(result.returnType, synthesizedCallType);
         return {
           returnType: newPartialClass,
           isTypeIncomplete: result.isTypeIncomplete,
@@ -55459,12 +55586,14 @@ var require_constructors = __commonJS({
           inferenceContext
         );
       });
-      const callType = metaclassCallMethodInfo.type;
-      if ((0, types_1.isFunction)(callType) && !callType.shared.declaredReturnType) {
-        return void 0;
-      }
-      if (callResult.returnType && (0, types_1.isUnknown)(callResult.returnType)) {
-        return void 0;
+      if (!callResult.argumentErrors) {
+        const callType = metaclassCallMethodInfo.type;
+        if ((0, types_1.isFunction)(callType) && !callType.shared.declaredReturnType) {
+          return void 0;
+        }
+        if (callResult.returnType && (0, types_1.isUnknown)(callResult.returnType)) {
+          return void 0;
+        }
       }
       return callResult;
     }
@@ -56175,8 +56304,11 @@ var require_dataClasses = __commonJS({
     var debug_1 = require_debug();
     var diagnostic_1 = require_diagnostic();
     var diagnosticRules_1 = require_diagnosticRules();
+    var positionUtils_1 = require_positionUtils();
     var pythonVersion_1 = require_pythonVersion();
+    var textRange_1 = require_textRange();
     var localize_1 = require_localize();
+    var tokenizer_1 = require_tokenizer();
     var AnalyzerNodeInfo = __importStar(require_analyzerNodeInfo());
     var analyzerNodeInfo_1 = require_analyzerNodeInfo();
     var constraintSolution_1 = require_constraintSolution();
@@ -56279,9 +56411,11 @@ var require_dataClasses = __commonJS({
             return;
           }
           let variableNameNode;
+          let typeAnnotationNode;
           let aliasName;
           let variableTypeEvaluator;
-          let hasDefaultValue = false;
+          let hasDefault = false;
+          let isDefaultFactory = false;
           let isKeywordOnly = types_1.ClassType.isDataClassKeywordOnly(classType) || sawKeywordOnlySeparator;
           let defaultExpr;
           let includeInInit = true;
@@ -56289,6 +56423,7 @@ var require_dataClasses = __commonJS({
           if (statement.nodeType === 3) {
             if (statement.d.leftExpr.nodeType === 54 && statement.d.leftExpr.d.valueExpr.nodeType === 38) {
               variableNameNode = statement.d.leftExpr.d.valueExpr;
+              typeAnnotationNode = statement.d.leftExpr;
               const assignmentStatement = statement;
               variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(assignmentStatement.d.leftExpr.d.annotation, {
                 varTypeAnnotation: true,
@@ -56296,7 +56431,7 @@ var require_dataClasses = __commonJS({
                 allowClassVar: true
               });
             }
-            hasDefaultValue = true;
+            hasDefault = true;
             defaultExpr = statement.d.rightExpr;
             if (statement.d.rightExpr.nodeType === 9) {
               const callTypeResult = evaluator.getTypeOfExpression(
@@ -56326,13 +56461,24 @@ var require_dataClasses = __commonJS({
                 } else {
                   isKeywordOnly = (_f = getDefaultArgValueForFieldSpecifier(evaluator, statement.d.rightExpr, callTypeResult, "kw_only")) !== null && _f !== void 0 ? _f : isKeywordOnly;
                 }
-                const defaultArg = statement.d.rightExpr.d.args.find((arg) => {
-                  var _a3, _b2, _c2;
-                  return ((_a3 = arg.d.name) === null || _a3 === void 0 ? void 0 : _a3.d.value) === "default" || ((_b2 = arg.d.name) === null || _b2 === void 0 ? void 0 : _b2.d.value) === "default_factory" || ((_c2 = arg.d.name) === null || _c2 === void 0 ? void 0 : _c2.d.value) === "factory";
+                const defaultValueArg = statement.d.rightExpr.d.args.find((arg) => {
+                  var _a3;
+                  return ((_a3 = arg.d.name) === null || _a3 === void 0 ? void 0 : _a3.d.value) === "default";
+                });
+                hasDefault = !!defaultValueArg;
+                if (defaultValueArg === null || defaultValueArg === void 0 ? void 0 : defaultValueArg.d.valueExpr) {
+                  defaultExpr = defaultValueArg.d.valueExpr;
+                }
+                const defaultFactoryArg = statement.d.rightExpr.d.args.find((arg) => {
+                  var _a3, _b2;
+                  return ((_a3 = arg.d.name) === null || _a3 === void 0 ? void 0 : _a3.d.value) === "default_factory" || ((_b2 = arg.d.name) === null || _b2 === void 0 ? void 0 : _b2.d.value) === "factory";
                 });
-                hasDefaultValue = !!defaultArg;
-                if (defaultArg === null || defaultArg === void 0 ? void 0 : defaultArg.d.valueExpr) {
-                  defaultExpr = defaultArg.d.valueExpr;
+                if (defaultFactoryArg) {
+                  hasDefault = true;
+                  isDefaultFactory = true;
+                }
+                if (defaultFactoryArg === null || defaultFactoryArg === void 0 ? void 0 : defaultFactoryArg.d.valueExpr) {
+                  defaultExpr = defaultFactoryArg.d.valueExpr;
                 }
                 const aliasArg = statement.d.rightExpr.d.args.find((arg) => {
                   var _a3;
@@ -56342,6 +56488,9 @@ var require_dataClasses = __commonJS({
                   const valueType = evaluator.getTypeOfExpression(aliasArg.d.valueExpr).type;
                   if ((0, types_1.isClassInstance)(valueType) && types_1.ClassType.isBuiltIn(valueType, "str") && (0, typeUtils_1.isLiteralType)(valueType)) {
                     aliasName = valueType.priv.literalValue;
+                    if (!tokenizer_1.Tokenizer.isPythonIdentifier(aliasName)) {
+                      evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassFieldInvalidAlias().format({ aliasName }), aliasArg.d.valueExpr);
+                    }
                   }
                 }
                 const converterArg = statement.d.rightExpr.d.args.find((arg) => {
@@ -56356,6 +56505,7 @@ var require_dataClasses = __commonJS({
           } else if (statement.nodeType === 54) {
             if (statement.d.valueExpr.nodeType === 38) {
               variableNameNode = statement.d.valueExpr;
+              typeAnnotationNode = statement;
               const annotationStatement = statement;
               variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(annotationStatement.d.annotation, {
                 varTypeAnnotation: true,
@@ -56367,6 +56517,7 @@ var require_dataClasses = __commonJS({
                 if ((0, types_1.isClassInstance)(annotatedType) && types_1.ClassType.isBuiltIn(annotatedType, "KW_ONLY")) {
                   sawKeywordOnlySeparator = true;
                   variableNameNode = void 0;
+                  typeAnnotationNode = void 0;
                   variableTypeEvaluator = void 0;
                 }
               }
@@ -56386,10 +56537,12 @@ var require_dataClasses = __commonJS({
                 classType,
                 alias: aliasName,
                 isKeywordOnly: false,
-                hasDefault: hasDefaultValue,
+                hasDefault,
+                isDefaultFactory,
                 defaultExpr,
                 includeInInit,
                 nameNode: variableNameNode,
+                typeAnnotationNode,
                 type: types_1.UnknownType.create(),
                 isClassVar: true,
                 converter
@@ -56401,10 +56554,12 @@ var require_dataClasses = __commonJS({
                 classType,
                 alias: aliasName,
                 isKeywordOnly,
-                hasDefault: hasDefaultValue,
+                hasDefault,
+                isDefaultFactory,
                 defaultExpr,
                 includeInInit,
                 nameNode: variableNameNode,
+                typeAnnotationNode,
                 type: types_1.UnknownType.create(),
                 isClassVar: false,
                 converter
@@ -56422,7 +56577,7 @@ var require_dataClasses = __commonJS({
                 if (!dataClassEntry.hasDefault && oldEntry.hasDefault && oldEntry.includeInInit) {
                   dataClassEntry.hasDefault = true;
                   dataClassEntry.defaultExpr = oldEntry.defaultExpr;
-                  hasDefaultValue = true;
+                  hasDefault = true;
                   evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassFieldInheritedDefault().format({ fieldName: variableName }), variableNameNode);
                 }
                 fullDataClassEntries[insertIndex] = dataClassEntry;
@@ -56430,7 +56585,7 @@ var require_dataClasses = __commonJS({
                 fullDataClassEntries.push(dataClassEntry);
                 insertIndex = fullDataClassEntries.length - 1;
               }
-              if (!isKeywordOnly && includeInInit && !skipSynthesizeInit && !hasDefaultValue) {
+              if (!isKeywordOnly && includeInInit && !skipSynthesizeInit && !hasDefault) {
                 const firstDefaultValueIndex = fullDataClassEntries.findIndex((p) => p.hasDefault && p.includeInInit && !p.isKeywordOnly);
                 if (firstDefaultValueIndex >= 0 && firstDefaultValueIndex < insertIndex) {
                   evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassFieldWithDefault(), variableNameNode);
@@ -56477,6 +56632,7 @@ var require_dataClasses = __commonJS({
         if (allAncestorsKnown) {
           fullDataClassEntries.forEach((entry) => {
             if (entry.includeInInit) {
+              let defaultType;
               let effectiveType = entry.type;
               if (entry.classType !== classType && (0, typeUtils_1.requiresSpecialization)(effectiveType)) {
                 const solution = new constraintSolution_1.ConstraintSolution();
@@ -56487,13 +56643,32 @@ var require_dataClasses = __commonJS({
               if (entry.converter) {
                 const fieldType = effectiveType;
                 effectiveType = getConverterInputType(evaluator, entry.converter, effectiveType, entry.name);
-                symbolTable.set(entry.name, getDescriptorForConverterField(evaluator, node, entry.converter, entry.name, fieldType, effectiveType));
+                symbolTable.set(entry.name, getDescriptorForConverterField(evaluator, node, entry.nameNode, entry.typeAnnotationNode, entry.converter, entry.name, fieldType, effectiveType));
+                if (entry.hasDefault) {
+                  defaultType = entry.type;
+                }
+              } else {
+                if (entry.hasDefault) {
+                  if (entry.isDefaultFactory || !entry.defaultExpr) {
+                    defaultType = entry.type;
+                  } else {
+                    const defaultExpr = entry.defaultExpr;
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    const flags = fileInfo.isStubFile ? 1 : 0;
+                    const liveTypeVars = (0, parseTreeUtils_1.getTypeVarScopesForNode)(entry.defaultExpr);
+                    const boundEffectiveType = (0, typeUtils_1.makeTypeVarsBound)(effectiveType, liveTypeVars);
+                    defaultType = evaluator.useSpeculativeMode(defaultExpr, () => {
+                      return evaluator.getTypeOfExpression(defaultExpr, flags, (0, typeUtils_1.makeInferenceContext)(boundEffectiveType)).type;
+                    });
+                    defaultType = (0, typeUtils_1.makeTypeVarsFree)(defaultType, liveTypeVars);
+                  }
+                }
               }
               const effectiveName = entry.alias || entry.name;
               if (!entry.alias && entry.nameNode && (0, symbolNameUtils_1.isPrivateName)(entry.nameNode.d.value)) {
                 evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassFieldWithPrivateName(), entry.nameNode);
               }
-              const param = types_1.FunctionParam.create(0, effectiveType, types_1.FunctionParamFlags.TypeDeclared, effectiveName, entry.hasDefault ? entry.type : void 0, entry.defaultExpr);
+              const param = types_1.FunctionParam.create(0, effectiveType, types_1.FunctionParamFlags.TypeDeclared, effectiveName, defaultType, entry.defaultExpr);
               if (entry.isKeywordOnly) {
                 keywordOnlyParams.push(param);
               } else {
@@ -56601,14 +56776,14 @@ var require_dataClasses = __commonJS({
       if ((0, types_1.isFunction)(callType)) {
         callTarget = callType;
       } else if ((0, types_1.isOverloaded)(callType)) {
-        callTarget = evaluator.getBestOverloadForArgs(callNode, { type: callType, isIncomplete: callTypeResult.isIncomplete }, callNode.d.args.map((arg) => (0, typeUtils_1.convertNodeToArg)(arg)));
+        callTarget = evaluator.getBestOverloadForArgs(callNode, { type: callType, isIncomplete: callTypeResult.isIncomplete }, callNode.d.args.map((arg) => evaluator.convertNodeToArg(arg)));
       } else if ((0, types_1.isInstantiableClass)(callType)) {
         const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluator, callNode, callType);
         if (initMethodResult) {
           if ((0, types_1.isFunction)(initMethodResult.type)) {
             callTarget = initMethodResult.type;
           } else if ((0, types_1.isOverloaded)(initMethodResult.type)) {
-            callTarget = evaluator.getBestOverloadForArgs(callNode, { type: initMethodResult.type }, callNode.d.args.map((arg) => (0, typeUtils_1.convertNodeToArg)(arg)));
+            callTarget = evaluator.getBestOverloadForArgs(callNode, { type: initMethodResult.type }, callNode.d.args.map((arg) => evaluator.convertNodeToArg(arg)));
           }
         }
       }
@@ -56707,7 +56882,7 @@ var require_dataClasses = __commonJS({
       }
       return void 0;
     }
-    function getDescriptorForConverterField(evaluator, dataclassNode, converterNode, fieldName, getType, setType) {
+    function getDescriptorForConverterField(evaluator, dataclassNode, fieldNameNode, fieldAnnotationNode, converterNode, fieldName, getType, setType) {
       const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(dataclassNode);
       const typeMetaclass = evaluator.getBuiltInType(dataclassNode, "type");
       const descriptorName = `__converterDescriptor_${fieldName}`;
@@ -56744,7 +56919,21 @@ var require_dataClasses = __commonJS({
       getFunction.shared.declaredReturnType = getType;
       const getSymbol = symbol_1.Symbol.createWithType(4, getFunction);
       fields.set("__get__", getSymbol);
-      return symbol_1.Symbol.createWithType(4, types_1.ClassType.cloneAsInstance(descriptorClass));
+      const symbol = symbol_1.Symbol.createWithType(4, types_1.ClassType.cloneAsInstance(descriptorClass));
+      if (fieldNameNode && fieldAnnotationNode) {
+        const fileInfo2 = AnalyzerNodeInfo.getFileInfo(dataclassNode);
+        const declaration = {
+          type: 1,
+          node: fieldNameNode,
+          uri: fileInfo2.fileUri,
+          typeAnnotationNode: fieldAnnotationNode,
+          range: (0, positionUtils_1.convertOffsetsToRange)(fieldNameNode.start, textRange_1.TextRange.getEnd(fieldNameNode), fileInfo2.lines),
+          moduleName: fileInfo2.moduleName,
+          isInExceptSuite: false
+        };
+        symbol.addDeclaration(declaration);
+      }
+      return symbol;
     }
     function transformDescriptorType(evaluator, type) {
       if (!(0, types_1.isClassInstance)(type) || (0, typeUtils_1.isMetaclassInstance)(type)) {
@@ -57008,7 +57197,7 @@ var require_dataClasses = __commonJS({
     }
     function applyDataClassDecorator(evaluator, errorNode, classType, defaultBehaviors, callNode) {
       var _a;
-      applyDataClassClassBehaviorOverrides(evaluator, errorNode, classType, ((_a = callNode === null || callNode === void 0 ? void 0 : callNode.d.args) !== null && _a !== void 0 ? _a : []).map((arg) => (0, typeUtils_1.convertNodeToArg)(arg)), defaultBehaviors);
+      applyDataClassClassBehaviorOverrides(evaluator, errorNode, classType, ((_a = callNode === null || callNode === void 0 ? void 0 : callNode.d.args) !== null && _a !== void 0 ? _a : []).map((arg) => evaluator.convertNodeToArg(arg)), defaultBehaviors);
     }
   }
 });
@@ -57439,7 +57628,7 @@ var require_typedDicts = __commonJS({
     var types_1 = require_types();
     var typeUtils_1 = require_typeUtils();
     function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
-      var _a, _b, _c;
+      var _a, _b, _c, _d, _e;
       const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
       let className;
       if (argList.length === 0) {
@@ -57516,7 +57705,8 @@ var require_typedDicts = __commonJS({
         }
       }
       if (usingDictSyntax) {
-        for (const arg of argList.slice(2)) {
+        const argsToConsider = argList.slice(2);
+        for (const arg of argsToConsider) {
           if (((_a = arg.name) === null || _a === void 0 ? void 0 : _a.d.value) === "total" || ((_b = arg.name) === null || _b === void 0 ? void 0 : _b.d.value) === "closed") {
             if (!arg.valueExpression || arg.valueExpression.nodeType !== 14 || !(arg.valueExpression.d.constType === 15 || arg.valueExpression.d.constType === 33)) {
               evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.d.value }), arg.valueExpression || errorNode);
@@ -57527,13 +57717,23 @@ var require_typedDicts = __commonJS({
                 classType.shared.flags |= 8 | 16;
               }
             }
+          } else if (((_c = arg.name) === null || _c === void 0 ? void 0 : _c.d.value) === "extra_items") {
+            classType.shared.typedDictExtraItemsExpr = arg.valueExpression;
+            classType.shared.flags |= 16;
           } else {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typedDictExtraArgs(), arg.valueExpression || errorNode);
           }
         }
+        if (types_1.ClassType.isTypedDictMarkedClosed(classType) && classType.shared.typedDictExtraItemsExpr) {
+          const arg = argsToConsider.find((arg2) => {
+            var _a2;
+            return ((_a2 = arg2.name) === null || _a2 === void 0 ? void 0 : _a2.d.value) === "extra_items";
+          });
+          evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), (_d = arg === null || arg === void 0 ? void 0 : arg.valueExpression) !== null && _d !== void 0 ? _d : errorNode);
+        }
       }
       synthesizeTypedDictClassMethods(evaluator, errorNode, classType);
-      if (((_c = errorNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 && className) {
+      if (((_e = errorNode.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 3 && className) {
         const target = errorNode.parent.d.leftExpr;
         const typedDictTarget = target.nodeType === 54 ? target.d.valueExpr : target;
         if (typedDictTarget.nodeType === 38) {
@@ -58016,18 +58216,33 @@ var require_typedDicts = __commonJS({
         }
       });
       const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(classType);
+      if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+        entries.extraItems = {
+          valueType: types_1.NeverType.createNever(),
+          isReadOnly: false,
+          isRequired: false,
+          isProvided: false
+        };
+      } else if (classType.shared.typedDictExtraItemsExpr) {
+        const extraItemsTypeResult = evaluator.getTypeOfExpressionExpectingType(classType.shared.typedDictExtraItemsExpr, { allowReadOnly: true });
+        entries.extraItems = {
+          valueType: (0, typeUtils_1.convertToInstance)(extraItemsTypeResult.type),
+          isReadOnly: !!extraItemsTypeResult.isReadOnly,
+          isRequired: false,
+          isProvided: true
+        };
+      }
       types_1.ClassType.getSymbolTable(classType).forEach((symbol, name) => {
         if (!symbol.isIgnoredForProtocolMatch()) {
           const lastDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
           if (lastDecl && lastDecl.type === 1) {
             let valueType = evaluator.getEffectiveTypeOfSymbol(symbol);
             valueType = (0, typeUtils_1.applySolvedTypeVars)(valueType, solution);
-            const allowRequired = !types_1.ClassType.isTypedDictMarkedClosed(classType) || name !== "__extra_items__";
             let isRequired = !types_1.ClassType.isCanOmitDictValues(classType);
             let isReadOnly = false;
-            if (isRequiredTypedDictVariable(evaluator, symbol, allowRequired)) {
+            if (isRequiredTypedDictVariable(evaluator, symbol)) {
               isRequired = true;
-            } else if (isNotRequiredTypedDictVariable(evaluator, symbol, allowRequired)) {
+            } else if (isNotRequiredTypedDictVariable(evaluator, symbol)) {
               isRequired = false;
             }
             if (isReadOnlyTypedDictVariable(evaluator, symbol)) {
@@ -58039,12 +58254,7 @@ var require_typedDicts = __commonJS({
               isRequired,
               isProvided: false
             };
-            if (types_1.ClassType.isTypedDictMarkedClosed(classType) && name === "__extra_items__") {
-              tdEntry.isRequired = false;
-              entries.extraItems = tdEntry;
-            } else {
-              entries.knownItems.set(name, tdEntry);
-            }
+            entries.knownItems.set(name, tdEntry);
           }
         }
       });
@@ -58168,13 +58378,13 @@ var require_typedDicts = __commonJS({
         const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
         if (!evaluator.assignType(extraDestEntries.valueType, extraSrcEntries.valueType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), constraints, extraDestEntries.isReadOnly ? flags : flags | 1, recursionCount)) {
           subDiag === null || subDiag === void 0 ? void 0 : subDiag.addMessage(localize_1.LocAddendum.typedDictExtraFieldTypeMismatch().format({
-            name: "__extra_items__",
+            name: "extra_items",
             type: evaluator.printType(types_1.ClassType.cloneAsInstance(srcType))
           }));
           typesAreConsistent = false;
         } else if (!extraDestEntries.isReadOnly && extraSrcEntries.isReadOnly) {
           diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.typedDictFieldNotReadOnly().format({
-            name: "__extra_items__",
+            name: "extra_items",
             type: evaluator.printType(types_1.ClassType.cloneAsInstance(destType))
           }));
           typesAreConsistent = false;
@@ -58221,7 +58431,7 @@ var require_typedDicts = __commonJS({
               )) {
                 if (subDiag) {
                   subDiag.addMessage(localize_1.LocAddendum.typedDictFieldTypeMismatch().format({
-                    name: "__extra_items__",
+                    name: "extra_items",
                     type: evaluator.printType(valueTypes[index].type)
                   }));
                   subDiag.addTextRange(keyTypeResult.node);
@@ -58391,39 +58601,29 @@ var require_typedDicts = __commonJS({
       });
       return types_1.ClassType.cloneForNarrowedTypedDictEntries(classType, narrowedEntries);
     }
-    function isRequiredTypedDictVariable(evaluator, symbol, allowRequired) {
+    function isRequiredTypedDictVariable(evaluator, symbol) {
       return symbol.getDeclarations().some((decl) => {
         if (decl.type !== 1 || !decl.typeAnnotationNode) {
           return false;
         }
         const annotatedType = evaluator.getTypeOfExpressionExpectingType(decl.typeAnnotationNode, {
           allowFinal: true,
-          allowRequired: true
+          allowRequired: true,
+          allowReadOnly: true
         });
-        if (!allowRequired) {
-          if (annotatedType.isRequired) {
-            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.requiredNotInTypedDict(), decl.typeAnnotationNode);
-          }
-          return false;
-        }
         return !!annotatedType.isRequired;
       });
     }
-    function isNotRequiredTypedDictVariable(evaluator, symbol, allowRequired) {
+    function isNotRequiredTypedDictVariable(evaluator, symbol) {
       return symbol.getDeclarations().some((decl) => {
         if (decl.type !== 1 || !decl.typeAnnotationNode) {
           return false;
         }
         const annotatedType = evaluator.getTypeOfExpressionExpectingType(decl.typeAnnotationNode, {
           allowFinal: true,
-          allowRequired: true
+          allowRequired: true,
+          allowReadOnly: true
         });
-        if (!allowRequired) {
-          if (annotatedType.isNotRequired) {
-            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.notRequiredNotInTypedDict(), decl.typeAnnotationNode);
-          }
-          return false;
-        }
         return !!annotatedType.isNotRequired;
       });
     }
@@ -58434,7 +58634,8 @@ var require_typedDicts = __commonJS({
         }
         const annotatedType = evaluator.getTypeOfExpressionExpectingType(decl.typeAnnotationNode, {
           allowFinal: true,
-          allowRequired: true
+          allowRequired: true,
+          allowReadOnly: true
         });
         return !!annotatedType.isReadOnly;
       });
@@ -59886,15 +60087,15 @@ var require_typeGuards = __commonJS({
         /* options */
         void 0,
         (subtype, unexpandedSubtype) => {
-          var _a;
+          var _a, _b;
           if ((0, types_1.isClassInstance)(subtype)) {
             const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
             if (isPositiveTest) {
               if (matches) {
                 if (types_1.ClassType.isSameGenericClass(subtype, classType)) {
-                  return subtype;
+                  return (0, typeUtils_1.addConditionToType)(subtype, (_a = classType.props) === null || _a === void 0 ? void 0 : _a.condition);
                 }
-                return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition);
+                return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_b = subtype.props) === null || _b === void 0 ? void 0 : _b.condition);
               }
               if (!classType.priv.includeSubclasses) {
                 return void 0;
@@ -61172,7 +61373,7 @@ var require_importResolver = __commonJS({
     var stringUtils_1 = require_stringUtils();
     var uri_1 = require_uri();
     var uriUtils_1 = require_uriUtils();
-    var characters_1 = require_characters();
+    var tokenizer_1 = require_tokenizer();
     var importStatementUtils_1 = require_importStatementUtils();
     var parentDirectoryCache_1 = require_parentDirectoryCache();
     var pyTypedUtils_1 = require_pyTypedUtils();
@@ -62967,7 +63168,7 @@ var require_importResolver = __commonJS({
       if (parts[0].endsWith(pathConsts_1.stubsSuffix)) {
         parts[0] = parts[0].substr(0, parts[0].length - pathConsts_1.stubsSuffix.length);
       }
-      const containsInvalidCharacters = parts.some((p) => !_isIdentifier(p));
+      const containsInvalidCharacters = parts.some((p) => !tokenizer_1.Tokenizer.isPythonIdentifier(p));
       return {
         moduleName: parts.join("."),
         containsInvalidCharacters
@@ -62979,14 +63180,6 @@ var require_importResolver = __commonJS({
     function _isDefaultWorkspace(uri) {
       return !uri || uri.isEmpty() || uri_1.Uri.isDefaultWorkspace(uri);
     }
-    function _isIdentifier(value) {
-      for (let i = 0; i < value.length; i++) {
-        if (i === 0 ? !(0, characters_1.isIdentifierStartChar)(value.charCodeAt(i)) : !(0, characters_1.isIdentifierChar)(value.charCodeAt(i))) {
-          return false;
-        }
-      }
-      return true;
-    }
   }
 });
 
@@ -63025,6 +63218,7 @@ var require_patternMatching = __commonJS({
       "builtins.str",
       "builtins.tuple"
     ];
+    var maxSequencePatternTupleExpansionSubtypes = 128;
     function narrowTypeBasedOnPattern(evaluator, type, pattern, isPositiveTest) {
       switch (pattern.nodeType) {
         case 65: {
@@ -63090,6 +63284,7 @@ var require_patternMatching = __commonJS({
       }
     }
     function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTest) {
+      let usingTupleExpansion = false;
       type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
       let sequenceInfo = getSequencePatternInfo(evaluator, pattern, type);
       sequenceInfo = sequenceInfo.filter((entry) => {
@@ -63194,6 +63389,7 @@ var require_patternMatching = __commonJS({
                   return { type: t, isUnbounded: false };
                 })));
               }));
+              usingTupleExpansion = true;
             }
           }
           return true;
@@ -63222,7 +63418,7 @@ var require_patternMatching = __commonJS({
         }
         return isPlausibleMatch;
       });
-      return (0, types_1.combineTypes)(sequenceInfo.map((entry) => entry.subtype));
+      return (0, types_1.combineTypes)(sequenceInfo.map((entry) => entry.subtype), { maxSubtypeCount: usingTupleExpansion ? maxSequencePatternTupleExpansionSubtypes : void 0 });
     }
     function narrowTypeBasedOnAsPattern(evaluator, type, pattern, isPositiveTest) {
       let remainingType = type;
@@ -63846,7 +64042,7 @@ var require_patternMatching = __commonJS({
               const typeArgs = (_a = specializedSequence.priv.tupleTypeArgs) !== null && _a !== void 0 ? _a : [
                 { type: types_1.UnknownType.create(), isUnbounded: true }
               ];
-              const tupleIndeterminateIndex = typeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
+              const tupleIndeterminateIndex = typeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
               let tupleDeterminateEntryCount = typeArgs.length;
               if (tupleIndeterminateIndex >= 0) {
                 tupleDeterminateEntryCount--;
@@ -63862,7 +64058,7 @@ var require_patternMatching = __commonJS({
                 const removedEntries = typeArgs.splice(patternStarEntryIndex, entriesToCombine);
                 typeArgs.splice(patternStarEntryIndex, 0, {
                   type: (0, types_1.combineTypes)(removedEntries.map((t) => t.type)),
-                  isUnbounded: removedEntries.every((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type))
+                  isUnbounded: removedEntries.every((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type))
                 });
               }
               if (typeArgs.length === patternEntryCount) {
@@ -64770,25 +64966,25 @@ var require_protocols = __commonJS({
     var maxProtocolCompatibilityCacheEntries = 64;
     function assignClassToProtocol(evaluator, destType, srcType, diag, constraints, flags, recursionCount) {
       (0, debug_1.assert)((0, types_1.isInstantiableClass)(destType) && types_1.ClassType.isProtocolClass(destType));
+      if (srcType.priv.literalValue !== void 0) {
+        srcType = evaluator.stripLiteralValue(srcType);
+      }
       const enforceInvariance = (flags & 1) !== 0;
       if (protocolAssignmentStack.some((entry) => {
         return (0, types_1.isTypeSame)(entry.srcType, srcType) && (0, types_1.isTypeSame)(entry.destType, destType);
       })) {
         return !enforceInvariance;
       }
-      if (!enforceInvariance) {
-        const compatibility = getProtocolCompatibility(destType, srcType, flags, constraints);
-        if (compatibility !== void 0) {
-          if (compatibility) {
-            if (!constraints || !(0, typeUtils_1.requiresSpecialization)(destType)) {
-              return true;
-            }
-          }
-          if (!compatibility) {
-            if (!diag || diag.getNestLevel() > diagnostic_1.defaultMaxDiagnosticDepth) {
-              return false;
-            }
+      const compat = getProtocolCompatibility(destType, srcType, flags, constraints);
+      if (compat !== void 0) {
+        if (compat.isCompatible) {
+          if (compat.postConstraints) {
+            constraints === null || constraints === void 0 ? void 0 : constraints.copyFromClone(compat.postConstraints);
           }
+          return true;
+        }
+        if (!diag || diag.getNestLevel() > diagnostic_1.defaultMaxDiagnosticDepth) {
+          return false;
         }
       }
       protocolAssignmentStack.push({ srcType, destType });
@@ -64801,7 +64997,9 @@ var require_protocols = __commonJS({
         throw e;
       }
       protocolAssignmentStack.pop();
-      setProtocolCompatibility(destType, srcType, flags, clonedConstraints, isCompatible);
+      if (!compat) {
+        setProtocolCompatibility(evaluator, destType, srcType, flags, clonedConstraints, constraints === null || constraints === void 0 ? void 0 : constraints.clone(), isCompatible, recursionCount);
+      }
       return isCompatible;
     }
     function assignModuleToProtocol(evaluator, destType, srcType, diag, constraints, flags, recursionCount) {
@@ -64856,12 +65054,23 @@ var require_protocols = __commonJS({
       if (entries === void 0) {
         return void 0;
       }
-      const entry = entries.find((entry2) => {
-        return (0, types_1.isTypeSame)(entry2.destType, destType) && (0, types_1.isTypeSame)(entry2.srcType, srcType) && entry2.flags === flags && isConstraintTrackerSame(constraints, entry2.constraints);
-      });
-      return entry === null || entry === void 0 ? void 0 : entry.isCompatible;
+      for (const entry of entries) {
+        if (entry.flags !== flags) {
+          continue;
+        }
+        if (entry.srcType === void 0) {
+          if (types_1.ClassType.isSameGenericClass(entry.destType, destType)) {
+            return entry;
+          }
+          continue;
+        }
+        if ((0, types_1.isTypeSame)(entry.destType, destType, { honorIsTypeArgExplicit: true, honorTypeForm: true }) && (0, types_1.isTypeSame)(entry.srcType, srcType, { honorIsTypeArgExplicit: true, honorTypeForm: true }) && isConstraintTrackerSame(constraints, entry.preConstraints)) {
+          return entry;
+        }
+      }
+      return void 0;
     }
-    function setProtocolCompatibility(destType, srcType, flags, constraints, isCompatible) {
+    function setProtocolCompatibility(evaluator, destType, srcType, flags, preConstraints, postConstraints, isCompatible, recursionCount) {
       let map = srcType.shared.protocolCompatibility;
       if (!map) {
         map = /* @__PURE__ */ new Map();
@@ -64872,13 +65081,33 @@ var require_protocols = __commonJS({
         entries = [];
         map.set(destType.shared.fullName, entries);
       }
-      entries.push({
+      let isAlwaysIncompatible = false;
+      if (!isCompatible && !entries.some((entry) => entry.flags === flags && types_1.ClassType.isSameGenericClass(entry.destType, destType))) {
+        const genericDestType = (0, typeUtils_1.requiresTypeArgs)(destType) ? (0, typeUtils_1.selfSpecializeClass)(destType, { overrideTypeArgs: true }) : destType;
+        const genericSrcType = (0, typeUtils_1.requiresTypeArgs)(srcType) ? (0, typeUtils_1.selfSpecializeClass)(srcType, { overrideTypeArgs: true }) : srcType;
+        if (!assignToProtocolInternal(
+          evaluator,
+          genericDestType,
+          genericSrcType,
+          /* diag */
+          void 0,
+          /* constraints */
+          void 0,
+          flags,
+          recursionCount
+        )) {
+          isAlwaysIncompatible = true;
+        }
+      }
+      const newEntry = {
         destType,
-        srcType,
+        srcType: isAlwaysIncompatible ? void 0 : srcType,
         flags,
-        constraints,
+        preConstraints,
+        postConstraints,
         isCompatible
-      });
+      };
+      entries.push(newEntry);
       if (entries.length > maxProtocolCompatibilityCacheEntries) {
         entries.shift();
       }
@@ -66779,7 +67008,7 @@ var require_codeFlowEngine = __commonJS({
                 } else {
                   const callResult = evaluator2.validateOverloadedArgTypes(
                     node,
-                    node.d.args.map((arg) => (0, typeUtils_1.convertNodeToArg)(arg)),
+                    node.d.args.map((arg) => evaluator2.convertNodeToArg(arg)),
                     { type: callSubtype, isIncomplete: callTypeResult.isIncomplete },
                     /* constraints */
                     void 0,
@@ -68372,12 +68601,163 @@ var require_tuples = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/tuples.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.makeTupleObject = makeTupleObject;
+    exports2.getTypeOfTuple = getTypeOfTuple;
+    exports2.getTypeOfTupleWithContext = getTypeOfTupleWithContext;
+    exports2.getTypeOfTupleInferred = getTypeOfTupleInferred;
     exports2.assignTupleTypeArgs = assignTupleTypeArgs;
     exports2.adjustTupleTypeArgs = adjustTupleTypeArgs;
     exports2.getSlicedTupleType = getSlicedTupleType;
+    var diagnostic_1 = require_diagnostic();
+    var diagnosticRules_1 = require_diagnosticRules();
     var localize_1 = require_localize();
+    var constraintSolver_1 = require_constraintSolver();
+    var constraintTracker_1 = require_constraintTracker();
+    var parseTreeUtils_1 = require_parseTreeUtils();
+    var typeEvaluatorTypes_1 = require_typeEvaluatorTypes();
     var types_1 = require_types();
     var typeUtils_1 = require_typeUtils();
+    var maxInferredTupleEntryCount = 256;
+    function makeTupleObject(evaluator, typeArgs, isUnpacked = false) {
+      const tupleClass = evaluator.getTupleClassType();
+      if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
+        return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(
+          tupleClass,
+          typeArgs,
+          /* isTypeArgExplicit */
+          true,
+          isUnpacked
+        ));
+      }
+      return types_1.UnknownType.create();
+    }
+    function getTypeOfTuple(evaluator, node, flags, inferenceContext) {
+      var _a;
+      if ((flags & 256) !== 0 && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1) {
+        const diag = new diagnostic_1.DiagnosticAddendum();
+        diag.addMessage(localize_1.LocAddendum.useTupleInstead());
+        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
+        return { type: types_1.UnknownType.create() };
+      }
+      if ((flags & 128) !== 0 && node.d.items.length === 0 && !inferenceContext) {
+        return { type: makeTupleObject(evaluator, []), isEmptyTupleShorthand: true };
+      }
+      flags &= ~(256 | 8 | 128);
+      let expectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
+      let expectedTypeContainsAny = inferenceContext && (0, types_1.isAny)(inferenceContext.expectedType);
+      if (inferenceContext && (0, types_1.isUnion)(inferenceContext.expectedType)) {
+        let matchingSubtype;
+        (0, typeUtils_1.doForEachSubtype)(
+          inferenceContext.expectedType,
+          (subtype) => {
+            if ((0, types_1.isAny)(subtype)) {
+              expectedTypeContainsAny = true;
+            }
+            if (!matchingSubtype) {
+              const subtypeResult = evaluator.useSpeculativeMode(node, () => {
+                return getTypeOfTupleWithContext(evaluator, node, flags, (0, typeUtils_1.makeInferenceContext)(subtype));
+              });
+              if (subtypeResult && evaluator.assignType(subtype, subtypeResult.type)) {
+                matchingSubtype = subtype;
+              }
+            }
+          },
+          /* sortSubtypes */
+          true
+        );
+        expectedType = matchingSubtype;
+      }
+      let expectedTypeDiagAddendum;
+      if (expectedType) {
+        const result = getTypeOfTupleWithContext(evaluator, node, flags, (0, typeUtils_1.makeInferenceContext)(expectedType));
+        if (result && !result.typeErrors) {
+          return result;
+        }
+        expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
+      }
+      const typeResult = getTypeOfTupleInferred(evaluator, node, flags);
+      if (expectedTypeContainsAny) {
+        typeResult.type = types_1.AnyType.create();
+      }
+      return { ...typeResult, expectedTypeDiagAddendum };
+    }
+    function getTypeOfTupleWithContext(evaluator, node, flags, inferenceContext) {
+      inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
+      if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
+        return void 0;
+      }
+      const tupleClass = evaluator.getTupleClassType();
+      if (!tupleClass || !(0, types_1.isInstantiableClass)(tupleClass)) {
+        return void 0;
+      }
+      let expectedTypes = [];
+      if ((0, typeUtils_1.isTupleClass)(inferenceContext.expectedType) && inferenceContext.expectedType.priv.tupleTypeArgs) {
+        expectedTypes = inferenceContext.expectedType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(t.type));
+        const unboundedIndex = inferenceContext.expectedType.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded);
+        if (unboundedIndex >= 0) {
+          if (expectedTypes.length > node.d.items.length) {
+            expectedTypes.splice(unboundedIndex, 1);
+          } else {
+            while (expectedTypes.length < node.d.items.length) {
+              expectedTypes.splice(unboundedIndex, 0, expectedTypes[unboundedIndex]);
+            }
+          }
+        }
+      } else {
+        const tupleConstraints = new constraintTracker_1.ConstraintTracker();
+        if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleConstraints, (0, parseTreeUtils_1.getTypeVarScopesForNode)(node), node.start)) {
+          return void 0;
+        }
+        const specializedTuple = evaluator.solveAndApplyConstraints(tupleClass, tupleConstraints);
+        if (!specializedTuple.priv.typeArgs || specializedTuple.priv.typeArgs.length !== 1) {
+          return void 0;
+        }
+        const homogenousType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(specializedTuple.priv.typeArgs[0]);
+        for (let i = 0; i < node.d.items.length; i++) {
+          expectedTypes.push(homogenousType);
+        }
+      }
+      const entryTypeResults = node.d.items.map((expr, index) => evaluator.getTypeOfExpression(expr, flags | 268435456, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : void 0, inferenceContext.isTypeIncomplete)));
+      const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
+      let expectedTypeDiagAddendum;
+      if (entryTypeResults.some((result) => result.expectedTypeDiagAddendum)) {
+        expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
+        entryTypeResults.forEach((result) => {
+          if (result.expectedTypeDiagAddendum) {
+            expectedTypeDiagAddendum.addAddendum(result.expectedTypeDiagAddendum);
+          }
+        });
+      }
+      let type;
+      if (node.d.items.length > maxInferredTupleEntryCount && entryTypeResults.some((result) => result.typeErrors)) {
+        type = makeTupleObject(evaluator, [{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+      } else {
+        type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(
+          entryTypeResults,
+          /* stripLiterals */
+          false
+        ));
+      }
+      return { type, expectedTypeDiagAddendum, isIncomplete };
+    }
+    function getTypeOfTupleInferred(evaluator, node, flags) {
+      const entryTypeResults = node.d.items.map((expr) => evaluator.getTypeOfExpression(
+        expr,
+        flags | 268435456
+        /* EvalFlags.StripTupleLiterals */
+      ));
+      const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
+      if (node.d.items.length > maxInferredTupleEntryCount) {
+        return { type: makeTupleObject(evaluator, [{ type: types_1.UnknownType.create(), isUnbounded: true }]) };
+      }
+      const type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(entryTypeResults, (flags & 268435456) !== 0));
+      if (isIncomplete) {
+        if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
+          return { type: types_1.UnknownType.create() };
+        }
+      }
+      return { type, isIncomplete };
+    }
     function assignTupleTypeArgs(evaluator, destType, srcType, diag, constraints, flags, recursionCount) {
       var _a, _b;
       const destTypeArgs = [...(_a = destType.priv.tupleTypeArgs) !== null && _a !== void 0 ? _a : []];
@@ -68429,9 +68809,9 @@ var require_tuples = __commonJS({
       return true;
     }
     function adjustTupleTypeArgs(evaluator, destTypeArgs, srcTypeArgs, flags) {
-      const destUnboundedOrVariadicIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isTypeVarTuple)(t.type));
+      const destUnboundedOrVariadicIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
       const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
-      const srcVariadicIndex = srcTypeArgs.findIndex((t) => (0, types_1.isTypeVarTuple)(t.type));
+      const srcVariadicIndex = srcTypeArgs.findIndex((t) => (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
       if (srcUnboundedIndex >= 0) {
         if ((0, types_1.isAnyOrUnknown)(srcTypeArgs[srcUnboundedIndex].type)) {
           const typeToReplicate = srcTypeArgs.length > 0 ? srcTypeArgs[srcUnboundedIndex].type : types_1.AnyType.create();
@@ -68858,6 +69238,7 @@ var require_typePrinter = __commonJS({
       PrintTypeFlags2[PrintTypeFlags2["ExpandTypedDictArgs"] = 1024] = "ExpandTypedDictArgs";
       PrintTypeFlags2[PrintTypeFlags2["PrintTypeVarVariance"] = 2048] = "PrintTypeVarVariance";
       PrintTypeFlags2[PrintTypeFlags2["UseFullyQualifiedNames"] = 4096] = "UseFullyQualifiedNames";
+      PrintTypeFlags2[PrintTypeFlags2["OmitTypeVarScopes"] = 8192] = "OmitTypeVarScopes";
     })(PrintTypeFlags || (exports2.PrintTypeFlags = PrintTypeFlags = {}));
     function printType(type, printTypeFlags, returnTypeCallback) {
       const uniqueNameMap = new UniqueNameMap(printTypeFlags, returnTypeCallback);
@@ -69107,10 +69488,10 @@ var require_typePrinter = __commonJS({
               if (types_1.TypeVarType.isSelf(type) && type.shared.boundType) {
                 let boundTypeString = printTypeInternal(type.shared.boundType, printTypeFlags & ~32, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                 if (!(0, types_1.isAnyOrUnknown)(type.shared.boundType)) {
-                  if (printTypeFlags & 256) {
-                    boundTypeString = `Self`;
-                  } else {
+                  if ((printTypeFlags & 256) === 0 && (printTypeFlags & 8192) === 0) {
                     boundTypeString = `Self@${boundTypeString}`;
+                  } else {
+                    boundTypeString = `Self`;
                   }
                 }
                 if (types_1.TypeBase.isInstantiable(type)) {
@@ -69121,20 +69502,18 @@ var require_typePrinter = __commonJS({
               return (printTypeFlags & (1 | 256)) !== 0 ? "Any" : "Unknown";
             }
             if ((0, types_1.isParamSpec)(type)) {
-              const paramSpecText = _getReadableTypeVarName(type, (printTypeFlags & 256) !== 0);
+              const paramSpecText = _getReadableTypeVarName(type, (printTypeFlags & 256) === 0 && (printTypeFlags & 8192) === 0);
               if (type.priv.paramSpecAccess) {
                 return `${paramSpecText}.${type.priv.paramSpecAccess}`;
               }
               return paramSpecText;
             }
-            let typeVarName = _getReadableTypeVarName(type, (printTypeFlags & 256) !== 0);
-            if ((0, types_1.isTypeVarTuple)(type)) {
-              if (type.priv.isUnpacked) {
-                typeVarName = _printUnpack(typeVarName, printTypeFlags);
-              }
-              if (type.priv.isInUnion) {
-                typeVarName = `Union[${typeVarName}]`;
-              }
+            let typeVarName = _getReadableTypeVarName(type, (printTypeFlags & 256) === 0 && (printTypeFlags & 8192) === 0);
+            if (type.priv.isUnpacked) {
+              typeVarName = _printUnpack(typeVarName, printTypeFlags);
+            }
+            if ((0, types_1.isTypeVarTuple)(type) && type.priv.isInUnion) {
+              typeVarName = `Union[${typeVarName}]`;
             }
             if (types_1.TypeBase.isInstantiable(type)) {
               typeVarName = `${_printNestedInstantiable(type, typeVarName)}`;
@@ -69539,11 +69918,8 @@ var require_typePrinter = __commonJS({
       }
       return textToWrap;
     }
-    function _getReadableTypeVarName(type, usePythonSyntax) {
-      if (usePythonSyntax) {
-        return type.shared.name;
-      }
-      return types_1.TypeVarType.getReadableName(type);
+    function _getReadableTypeVarName(type, includeScope) {
+      return types_1.TypeVarType.getReadableName(type, includeScope);
     }
     function _getTypeVarVarianceText(type) {
       var _a;
@@ -69794,9 +70170,8 @@ var require_typeEvaluator = __commonJS({
     var maxEffectiveTypeEvaluationAttempts = 16;
     var maxOverloadUnionExpansionCount = 64;
     var maxInferFunctionReturnRecursionCount = 12;
-    var maxInferredContainerDepth = 8;
-    var maxInferredTupleEntryCount = 256;
     var maxRecursiveTypeAliasRecursionCount = 10;
+    var maxTypedDeclsPerSymbol = 16;
     var verifyTypeCacheEvaluatorFlags = false;
     var printExpressionTypes = false;
     exports2.maxCodeComplexity = 768;
@@ -70209,7 +70584,7 @@ var require_typeEvaluator = __commonJS({
             break;
           }
           case 52: {
-            typeResult = getTypeOfTuple(node, flags, inferenceContext);
+            typeResult = (0, tuples_1.getTypeOfTuple)(evaluatorInterface, node, flags, inferenceContext);
             break;
           }
           case 14: {
@@ -70433,8 +70808,13 @@ var require_typeEvaluator = __commonJS({
             true
           ) };
         } else {
-          const ellipsisType = (_b = (_a = getBuiltInObject(node, "EllipsisType")) !== null && _a !== void 0 ? _a : getBuiltInObject(node, "ellipsis")) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
-          typeResult = { type: ellipsisType };
+          if ((flags & 256) !== 0 && (flags & 65536) === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), node);
+            typeResult = { type: types_1.UnknownType.create() };
+          } else {
+            const ellipsisType = (_b = (_a = getBuiltInObject(node, "EllipsisType")) !== null && _a !== void 0 ? _a : getBuiltInObject(node, "ellipsis")) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
+            typeResult = { type: ellipsisType };
+          }
         }
         return typeResult;
       }
@@ -70462,7 +70842,7 @@ var require_typeEvaluator = __commonJS({
         const iterType = iterTypeResult.type;
         if ((flags & 64) === 0 && (0, types_1.isTypeVarTuple)(iterType) && !iterType.priv.isUnpacked) {
           typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
-        } else if ((flags & 2097152) !== 0 && (0, types_1.isInstantiableClass)(iterType) && types_1.ClassType.isBuiltIn(iterType, "tuple")) {
+        } else if ((flags & 4194304) !== 0 && (0, types_1.isInstantiableClass)(iterType) && types_1.ClassType.isBuiltIn(iterType, "tuple")) {
           typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
         } else if ((flags & 256) !== 0) {
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackInAnnotation(), node, node.d.starToken);
@@ -70561,7 +70941,7 @@ var require_typeEvaluator = __commonJS({
         const reportTypeErrors = (flags & 8) !== 0;
         let updatedFlags = flags | 4 | 128;
         let typeResult;
-        if ((flags & 8388608) === 0) {
+        if ((flags & 16777216) === 0) {
           updatedFlags |= 524288;
         }
         updatedFlags &= ~1073741824;
@@ -70660,7 +71040,6 @@ var require_typeEvaluator = __commonJS({
           }
         }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-          var _a2;
           if ((0, types_1.isClass)(subtype)) {
             if (subtype.priv.literalValue !== void 0) {
               subtype = types_1.ClassType.cloneWithLiteral(
@@ -70672,9 +71051,7 @@ var require_typeEvaluator = __commonJS({
             if (types_1.ClassType.isBuiltIn(subtype, "LiteralString")) {
               if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
                 let strInstance = types_1.ClassType.cloneAsInstance(strClass);
-                if ((_a2 = subtype.props) === null || _a2 === void 0 ? void 0 : _a2.condition) {
-                  strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
-                }
+                strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
                 return strInstance;
               }
             }
@@ -71021,10 +71398,6 @@ var require_typeEvaluator = __commonJS({
         return void 0;
       }
       function getBoundMagicMethod(classType, memberName, selfType, diag, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-          return void 0;
-        }
-        recursionCount++;
         const boundMethodResult = getTypeOfBoundMember(
           /* errorNode */
           void 0,
@@ -71044,6 +71417,10 @@ var require_typeEvaluator = __commonJS({
           return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
+          if (recursionCount > types_1.maxTypeRecursionCount) {
+            return void 0;
+          }
+          recursionCount++;
           return getBoundMagicMethod(boundMethodResult.type, "__call__", selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), diag, recursionCount);
         }
         if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
@@ -71799,7 +72176,10 @@ var require_typeEvaluator = __commonJS({
         const isTypeAlias = !!declaredType && (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, "TypeAlias");
         if (declaredType && !isTypeAlias) {
           let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-          if (!assignType(declaredType, typeResult.type, diagAddendum)) {
+          const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(nameNode);
+          const boundDeclaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveScopeIds);
+          const srcType = (0, typeUtils_1.makeTypeVarsBound)(typeResult.type, liveScopeIds);
+          if (!assignType(boundDeclaredType, srcType, diagAddendum)) {
             if (expectedTypeDiagAddendum) {
               diagAddendum = expectedTypeDiagAddendum;
             }
@@ -72039,12 +72419,7 @@ var require_typeEvaluator = __commonJS({
           var _a, _b;
           const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
           if (tupleType && tupleType.priv.tupleTypeArgs) {
-            const sourceEntryTypes = tupleType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.addConditionToType)(
-              t.type,
-              (0, typeUtils_1.getTypeCondition)(subtype),
-              /* skipSelfCondition */
-              true
-            ));
+            const sourceEntryTypes = tupleType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype), { skipSelfCondition: true }));
             const unboundedIndex = tupleType.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded);
             if (unboundedIndex >= 0) {
               if (sourceEntryTypes.length < targetTypes.length) {
@@ -72150,7 +72525,7 @@ var require_typeEvaluator = __commonJS({
           var _a;
           if ((0, types_1.isParamSpec)(subtype)) {
             if (subtype.priv.paramSpecAccess === "args") {
-              return makeTupleObject([{ type: getObjectType(), isUnbounded: true }]);
+              return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: getObjectType(), isUnbounded: true }]);
             } else if (subtype.priv.paramSpecAccess === "kwargs") {
               if (dictClass && (0, types_1.isInstantiableClass)(dictClass) && strClass && (0, types_1.isInstantiableClass)(strClass)) {
                 return types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(dictClass, [(0, typeUtils_1.convertToInstance)(strClass), getObjectType()]));
@@ -72175,7 +72550,8 @@ var require_typeEvaluator = __commonJS({
               }
               return types_1.AnyType.create();
             }
-            return makeTupleObject(
+            return (0, tuples_1.makeTupleObject)(
+              evaluatorInterface,
               [{ type: getObjectType(), isUnbounded: true }],
               /* isUnpacked */
               true
@@ -72211,6 +72587,9 @@ var require_typeEvaluator = __commonJS({
                 useBoundTypeVars: types_1.TypeVarType.isBound(subtype)
               });
             }
+            if (subtype.priv.isUnpacked && (0, types_1.isClass)(boundType)) {
+              boundType = types_1.ClassType.cloneForUnpacked(boundType);
+            }
             boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
             return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
           }
@@ -72381,11 +72760,15 @@ var require_typeEvaluator = __commonJS({
             break;
           }
           case 54: {
-            const annotationType = getTypeOfAnnotation(target.d.annotation, {
+            let annotationType = getTypeOfAnnotation(target.d.annotation, {
               varTypeAnnotation: true,
               allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(target.d.valueExpr),
               allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(target.d.valueExpr)
             });
+            if (annotationType) {
+              const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(target);
+              annotationType = (0, typeUtils_1.makeTypeVarsBound)(annotationType, liveScopeIds);
+            }
             const isBareFinalOrClassVar = (0, types_1.isClassInstance)(annotationType) && (types_1.ClassType.isBuiltIn(annotationType, "Final") || types_1.ClassType.isBuiltIn(annotationType, "ClassVar"));
             if (!isBareFinalOrClassVar) {
               const isTypeAliasAnnotation = (0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, "TypeAlias");
@@ -72657,6 +73040,9 @@ var require_typeEvaluator = __commonJS({
           if ((flags & 256) !== 0) {
             type = validateSymbolIsTypeExpression(node, type, !!effectiveTypeInfo.includesVariableDecl);
           }
+          if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
+            type = validateTypeVarUsage(node, type, flags);
+          }
           type = addTypeFormForSymbol(node, type, flags, !!effectiveTypeInfo.includesVariableDecl);
         } else {
           if (name === "reveal_type" || name === "reveal_locals") {
@@ -72666,7 +73052,7 @@ var require_typeEvaluator = __commonJS({
             type = types_1.UnknownType.create();
           }
         }
-        if ((0, types_1.isParamSpec)(type)) {
+        if ((0, types_1.isParamSpec)(type) && type.priv.scopeId) {
           if (flags & 32) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), node);
             type = types_1.UnknownType.create();
@@ -72683,9 +73069,6 @@ var require_typeEvaluator = __commonJS({
             }
           }
         }
-        if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
-          type = validateTypeVarUsage(node, type, flags);
-        }
         return { type, isIncomplete };
       }
       function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
@@ -72736,7 +73119,7 @@ var require_typeEvaluator = __commonJS({
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
           return true;
         }
-        if ((0, types_1.isTypeVar)(type) && !type.priv.scopeId) {
+        if ((0, types_1.isTypeVar)(type)) {
           return true;
         }
         if ((0, types_1.isClass)(type) && !type.priv.includeSubclasses && types_1.ClassType.isValidTypeAliasClass(type)) {
@@ -72926,7 +73309,7 @@ var require_typeEvaluator = __commonJS({
           if (type.priv.scopeId && !scopedTypeVarInfo.foundInterveningClass) {
             return type;
           }
-          if (!type.shared.isSynthesized) {
+          if (!type.shared.isSynthesized && (flags & 128) !== 0) {
             const message = (0, types_1.isParamSpec)(type) ? localize_1.LocMessage.paramSpecNotUsedByOuterScope() : localize_1.LocMessage.typeVarNotUsedByOuterScope();
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name: type.shared.name }), node);
           }
@@ -72982,7 +73365,7 @@ var require_typeEvaluator = __commonJS({
         return type;
       }
       function findScopedTypeVar(node, type) {
-        var _a;
+        var _a, _b;
         let curNode = node;
         let nestedClassCount = 0;
         (0, debug_1.assert)(types_1.TypeBase.isInstantiable(type));
@@ -73047,13 +73430,13 @@ var require_typeEvaluator = __commonJS({
           }
           if (leftType && scopeNode) {
             if (leftType && (0, types_1.isTypeVar)(leftType) && leftType.shared.recursiveAlias) {
-              if (typeAliasNode && !type.shared.isTypeParamSyntax) {
+              if (typeAliasNode && !type.shared.isTypeParamSyntax && !((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeParameterNotDeclared().format({
                   name: type.shared.name,
                   container: typeAliasNode.d.name.d.value
                 }), node);
               } else {
-                const allowedTypeParams = (_a = leftType.shared.recursiveAlias) === null || _a === void 0 ? void 0 : _a.typeParams;
+                const allowedTypeParams = (_b = leftType.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.typeParams;
                 if (allowedTypeParams) {
                   if (!allowedTypeParams.some((param) => param.shared.name === type.shared.name)) {
                     return { type, scopeNode, foundInterveningClass: false };
@@ -73296,12 +73679,10 @@ var require_typeEvaluator = __commonJS({
             }
             if (typeResult) {
               if (!typeResult.typeErrors) {
-                type = (0, typeUtils_1.addConditionToType)(
-                  typeResult.type,
-                  (0, typeUtils_1.getTypeCondition)(baseType),
-                  /* skipSelfCondition */
-                  true
-                );
+                type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), {
+                  skipSelfCondition: true,
+                  skipBoundTypeVars: true
+                });
               } else {
                 typeErrors = true;
               }
@@ -73312,12 +73693,7 @@ var require_typeEvaluator = __commonJS({
                 isIncomplete = true;
               }
               if (typeResult.narrowedTypeForSet) {
-                narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(
-                  typeResult.narrowedTypeForSet,
-                  (0, typeUtils_1.getTypeCondition)(baseType),
-                  /* skipSelfCondition */
-                  true
-                );
+                narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(typeResult.narrowedTypeForSet, (0, typeUtils_1.getTypeCondition)(baseType), { skipSelfCondition: true, skipBoundTypeVars: true });
               }
               if (typeResult.memberAccessDeprecationInfo) {
                 memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
@@ -73403,7 +73779,9 @@ var require_typeEvaluator = __commonJS({
                 (0, debug_1.assert)((0, types_1.isClassInstance)(subtype));
                 const typeResult2 = getTypeOfBoundMember(node.d.member, subtype, memberName, usage, diag);
                 if (typeResult2 && !typeResult2.typeErrors) {
-                  type = (0, typeUtils_1.addConditionToType)(typeResult2.type, (0, typeUtils_1.getTypeCondition)(baseType));
+                  type = (0, typeUtils_1.addConditionToType)(typeResult2.type, (0, typeUtils_1.getTypeCondition)(baseType), {
+                    skipBoundTypeVars: true
+                  });
                   if (typeResult2.isIncomplete) {
                     isIncomplete = true;
                   }
@@ -74176,7 +74554,8 @@ var require_typeEvaluator = __commonJS({
                   }
                 });
               }
-              const tupleObject = makeTupleObject(
+              const tupleObject = (0, tuples_1.makeTupleObject)(
+                evaluatorInterface,
                 variadicTypes,
                 /* isUnpacked */
                 true
@@ -74190,7 +74569,8 @@ var require_typeEvaluator = __commonJS({
           } else if (!variadicTypeVar.shared.isDefaultExplicit) {
             typeArgs.push({
               node: errorNode,
-              type: makeTupleObject(
+              type: (0, tuples_1.makeTupleObject)(
+                evaluatorInterface,
                 [],
                 /* isUnpacked */
                 true
@@ -74235,7 +74615,8 @@ var require_typeEvaluator = __commonJS({
               }
             });
           } else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
-            defaultType = makeTupleObject(
+            defaultType = (0, tuples_1.makeTupleObject)(
+              evaluatorInterface,
               [{ type: types_1.UnknownType.create(), isUnbounded: true }],
               /* isUnpacked */
               true
@@ -74278,18 +74659,13 @@ var require_typeEvaluator = __commonJS({
         }
         inferVarianceForTypeAlias(baseType);
         const typeParams = aliasInfo.shared.typeParams;
-        let typeArgs = adjustTypeArgsForTypeVarTuple(getTypeArgs(node, flags), typeParams, node);
+        let typeArgs;
+        typeArgs = adjustTypeArgsForTypeVarTuple(getTypeArgs(node, flags), typeParams, node);
         let reportedError = false;
-        if (typeParams.length === 1 && (0, types_1.isParamSpec)(typeParams[0]) && typeArgs) {
-          if (typeArgs.every((typeArg) => !(0, typeUtils_1.isEllipsisType)(typeArg.type) && !typeArg.typeList && !(0, types_1.isParamSpec)(typeArg.type))) {
-            typeArgs = [
-              {
-                type: types_1.UnknownType.create(),
-                node: typeArgs.length > 0 ? typeArgs[0].node : node,
-                typeList: typeArgs
-              }
-            ];
-          }
+        typeArgs = transformTypeArgsForParamSpec(typeParams, typeArgs, node);
+        if (!typeArgs) {
+          typeArgs = [];
+          reportedError = true;
         }
         let minTypeArgCount = typeParams.length;
         const firstDefaultParamIndex = typeParams.findIndex((param) => !!param.shared.isDefaultExplicit);
@@ -74326,8 +74702,12 @@ var require_typeEvaluator = __commonJS({
                 65536
                 /* FunctionTypeFlags.ParamSpecValue */
               );
-              typeList.forEach((paramType, paramIndex) => {
-                types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(0, (0, typeUtils_1.convertToInstance)(paramType.type), types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${paramIndex}`));
+              typeList.forEach((paramTypeResult, paramIndex) => {
+                let paramType = paramTypeResult.type;
+                if (!validateTypeArg(paramTypeResult)) {
+                  paramType = types_1.UnknownType.create();
+                }
+                types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(0, (0, typeUtils_1.convertToInstance)(paramType), types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${paramIndex}`));
               });
               if (typeList.length > 0) {
                 types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
@@ -74659,13 +75039,14 @@ var require_typeEvaluator = __commonJS({
         );
         return usageVariances;
       }
-      function updateUsageVariancesRecursive(type, typeAliasTypeParams, usageVariances, varianceContext, recursionCount = 0) {
+      function updateUsageVariancesRecursive(type, typeAliasTypeParams, usageVariances, varianceContext, pendingTypes = [], recursionCount = 0) {
         if (recursionCount > types_1.maxTypeRecursionCount) {
           return;
         }
         const transformedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
         if (transformedType !== type) {
-          if (recursionCount > maxRecursiveTypeAliasRecursionCount) {
+          const pendingOverlaps = pendingTypes.filter((pendingType) => (0, types_1.isTypeSame)(pendingType, type));
+          if (pendingOverlaps.length > 1) {
             return;
           }
         }
@@ -74676,7 +75057,9 @@ var require_typeEvaluator = __commonJS({
             if (typeParamIndex >= 0) {
               usageVariances[typeParamIndex] = (0, typeUtils_1.combineVariances)(usageVariances[typeParamIndex], variance);
             } else {
-              updateUsageVariancesRecursive(subtype, typeAliasTypeParams, usageVariances, variance, recursionCount);
+              pendingTypes.push(type2);
+              updateUsageVariancesRecursive(subtype, typeAliasTypeParams, usageVariances, variance, pendingTypes, recursionCount);
+              pendingTypes.pop();
             }
           });
         }
@@ -74717,18 +75100,6 @@ var require_typeEvaluator = __commonJS({
           }
         });
       }
-      function makeTupleObject(typeArgs, isUnpacked = false) {
-        if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
-          return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(
-            tupleClass,
-            typeArgs,
-            /* isTypeArgExplicit */
-            true,
-            isUnpacked
-          ));
-        }
-        return types_1.UnknownType.create();
-      }
       function getIndexAccessMagicMethodName(usage) {
         if (usage.method === "get") {
           return "__getitem__";
@@ -74802,7 +75173,7 @@ var require_typeEvaluator = __commonJS({
             isPositionalIndexTypeIncomplete = true;
           }
         } else if (positionalArgs.length === 0 && unpackedListArgs.length === 0) {
-          positionalIndexType = makeTupleObject([]);
+          positionalIndexType = (0, tuples_1.makeTupleObject)(evaluatorInterface, []);
         } else {
           const tupleTypeArgs = [];
           positionalArgs.forEach((arg) => {
@@ -74826,7 +75197,7 @@ var require_typeEvaluator = __commonJS({
             )) === null || _a2 === void 0 ? void 0 : _a2.type) !== null && _b2 !== void 0 ? _b2 : types_1.UnknownType.create();
             tupleTypeArgs.push({ type: iterableType, isUnbounded: true });
           });
-          positionalIndexType = makeTupleObject(tupleTypeArgs);
+          positionalIndexType = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs);
         }
         const argList = [
           {
@@ -74917,7 +75288,7 @@ var require_typeEvaluator = __commonJS({
           if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
             adjFlags |= 131072 | 16;
           }
-          adjFlags |= 2097152 | 134217728;
+          adjFlags |= 4194304 | 134217728;
         }
         const getTypeArgTypeResult = (expr, argIndex) => {
           let typeResult;
@@ -74946,32 +75317,65 @@ var require_typeEvaluator = __commonJS({
             typeArgs.push(getTypeArgTypeResult(item, index));
           });
           setTypeResultForNode(node.d.items[0].d.valueExpr, { type: types_1.UnknownType.create() });
-        } else {
-          node.d.items.forEach((arg, index) => {
-            const typeResult = getTypeArgTypeResult(arg.d.valueExpr, index);
-            if (arg.d.argCategory !== 0) {
-              if (arg.d.argCategory === 1) {
-                if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass) || index === 0) {
-                  if ((0, types_1.isTypeVarTuple)(typeResult.type) && !typeResult.type.priv.isUnpacked) {
-                    typeResult.type = types_1.TypeVarType.cloneForUnpacked(typeResult.type);
-                  } else if ((0, types_1.isInstantiableClass)(typeResult.type) && !typeResult.type.priv.includeSubclasses && (0, typeUtils_1.isTupleClass)(typeResult.type)) {
-                    typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
-                  } else {
+          return typeArgs;
+        }
+        node.d.items.forEach((arg, index) => {
+          const typeResult = getTypeArgTypeResult(arg.d.valueExpr, index);
+          if (arg.d.argCategory !== 0) {
+            if (arg.d.argCategory === 1) {
+              if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass) || index === 0) {
+                const unpackedType = applyUnpackToTupleLike(typeResult.type);
+                if (unpackedType) {
+                  typeResult.type = unpackedType;
+                } else {
+                  if ((flags & 256) !== 0) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackNotAllowed(), arg.d.valueExpr);
+                    typeResult.typeErrors = true;
+                  } else {
+                    typeResult.type = types_1.UnknownType.create();
                   }
                 }
               }
             }
-            if (arg.d.name) {
+          }
+          if (arg.d.name) {
+            if ((flags & 256) !== 0) {
               addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), arg.d.valueExpr);
+              typeResult.typeErrors = true;
+            } else {
+              typeResult.type = types_1.UnknownType.create();
             }
-            if (arg.d.valueExpr.nodeType !== 0 || arg.d.valueExpr.d.category !== 3) {
-              typeArgs.push(typeResult);
-            }
-          });
-        }
+          }
+          if (arg.d.valueExpr.nodeType !== 0 || arg.d.valueExpr.d.category !== 3) {
+            typeArgs.push(typeResult);
+          }
+        });
         return typeArgs;
       }
+      function applyUnpackToTupleLike(type) {
+        if ((0, types_1.isTypeVarTuple)(type)) {
+          if (!type.priv.isUnpacked) {
+            return types_1.TypeVarType.cloneForUnpacked(type);
+          }
+          return void 0;
+        }
+        if ((0, types_1.isParamSpec)(type)) {
+          return void 0;
+        }
+        if ((0, types_1.isTypeVar)(type)) {
+          const upperBound = type.shared.boundType;
+          if (upperBound && (0, types_1.isClassInstance)(upperBound) && (0, typeUtils_1.isTupleClass)(upperBound)) {
+            return types_1.TypeVarType.cloneForUnpacked(type);
+          }
+          return void 0;
+        }
+        if ((0, types_1.isInstantiableClass)(type) && !type.priv.includeSubclasses) {
+          if ((0, typeUtils_1.isTupleClass)(type)) {
+            return types_1.ClassType.cloneForUnpacked(type);
+          }
+        }
+        return void 0;
+      }
       function getTypeArg(node, flags) {
         let typeResult;
         let adjustedFlags = flags | 128 | 1 | 8;
@@ -75001,132 +75405,6 @@ var require_typeEvaluator = __commonJS({
         }
         return typeResult;
       }
-      function getTypeOfTuple(node, flags, inferenceContext) {
-        var _a;
-        if ((flags & 256) !== 0 && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1) {
-          const diag = new diagnostic_1.DiagnosticAddendum();
-          diag.addMessage(localize_1.LocAddendum.useTupleInstead());
-          addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
-          return { type: types_1.UnknownType.create() };
-        }
-        if ((flags & 128) !== 0 && node.d.items.length === 0 && !inferenceContext) {
-          return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
-        }
-        flags &= ~(256 | 8 | 128);
-        let expectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
-        let expectedTypeContainsAny = inferenceContext && (0, types_1.isAny)(inferenceContext.expectedType);
-        if (inferenceContext && (0, types_1.isUnion)(inferenceContext.expectedType)) {
-          let matchingSubtype;
-          (0, typeUtils_1.doForEachSubtype)(
-            inferenceContext.expectedType,
-            (subtype) => {
-              if ((0, types_1.isAny)(subtype)) {
-                expectedTypeContainsAny = true;
-              }
-              if (!matchingSubtype) {
-                const subtypeResult = useSpeculativeMode(node, () => {
-                  return getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(subtype));
-                });
-                if (subtypeResult && assignType(subtype, subtypeResult.type)) {
-                  matchingSubtype = subtype;
-                }
-              }
-            },
-            /* sortSubtypes */
-            true
-          );
-          expectedType = matchingSubtype;
-        }
-        let expectedTypeDiagAddendum;
-        if (expectedType) {
-          const result = getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(expectedType));
-          if (result && !result.typeErrors) {
-            return result;
-          }
-          expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
-        }
-        const typeResult = getTypeOfTupleInferred(node, flags);
-        if (expectedTypeContainsAny) {
-          typeResult.type = types_1.AnyType.create();
-        }
-        return { ...typeResult, expectedTypeDiagAddendum };
-      }
-      function getTypeOfTupleWithContext(node, flags, inferenceContext) {
-        inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
-        if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
-          return void 0;
-        }
-        if (!tupleClass || !(0, types_1.isInstantiableClass)(tupleClass)) {
-          return void 0;
-        }
-        let expectedTypes = [];
-        if ((0, typeUtils_1.isTupleClass)(inferenceContext.expectedType) && inferenceContext.expectedType.priv.tupleTypeArgs) {
-          expectedTypes = inferenceContext.expectedType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(t.type));
-          const unboundedIndex = inferenceContext.expectedType.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded);
-          if (unboundedIndex >= 0) {
-            if (expectedTypes.length > node.d.items.length) {
-              expectedTypes.splice(unboundedIndex, 1);
-            } else {
-              while (expectedTypes.length < node.d.items.length) {
-                expectedTypes.splice(unboundedIndex, 0, expectedTypes[unboundedIndex]);
-              }
-            }
-          }
-        } else {
-          const tupleConstraints = new constraintTracker_1.ConstraintTracker();
-          if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleConstraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
-            return void 0;
-          }
-          const specializedTuple = solveAndApplyConstraints(tupleClass, tupleConstraints);
-          if (!specializedTuple.priv.typeArgs || specializedTuple.priv.typeArgs.length !== 1) {
-            return void 0;
-          }
-          const homogenousType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(specializedTuple.priv.typeArgs[0]);
-          for (let i = 0; i < node.d.items.length; i++) {
-            expectedTypes.push(homogenousType);
-          }
-        }
-        const entryTypeResults = node.d.items.map((expr, index) => getTypeOfExpression(expr, flags | 268435456, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : void 0, inferenceContext.isTypeIncomplete)));
-        const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        let expectedTypeDiagAddendum;
-        if (entryTypeResults.some((result) => result.expectedTypeDiagAddendum)) {
-          expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
-          entryTypeResults.forEach((result) => {
-            if (result.expectedTypeDiagAddendum) {
-              expectedTypeDiagAddendum.addAddendum(result.expectedTypeDiagAddendum);
-            }
-          });
-        }
-        let type;
-        if (node.d.items.length > maxInferredTupleEntryCount && entryTypeResults.some((result) => result.typeErrors)) {
-          type = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
-        } else {
-          type = makeTupleObject(buildTupleTypesList(
-            entryTypeResults,
-            /* stripLiterals */
-            false
-          ));
-        }
-        return { type, expectedTypeDiagAddendum, isIncomplete };
-      }
-      function getTypeOfTupleInferred(node, flags) {
-        const entryTypeResults = node.d.items.map((expr) => getTypeOfExpression(
-          expr,
-          flags | 268435456
-          /* EvalFlags.StripTupleLiterals */
-        ));
-        const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        if (node.d.items.length > maxInferredTupleEntryCount) {
-          return { type: makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]) };
-        }
-        const type = makeTupleObject(buildTupleTypesList(entryTypeResults, (flags & 268435456) !== 0));
-        if (isIncomplete) {
-          if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
-            return { type: types_1.UnknownType.create() };
-          }
-        }
-        return { type, isIncomplete };
-      }
       function buildTupleTypesList(entryTypeResults, stripLiterals) {
         const entryTypes = [];
         for (const typeResult of entryTypeResults) {
@@ -75291,7 +75569,7 @@ var require_typeEvaluator = __commonJS({
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeFormArgs(), node);
           return { type: types_1.UnknownType.create() };
         }
-        const typeFormResult = getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(node.d.args[0]), {
+        const typeFormResult = getTypeOfArgExpectingType(convertNodeToArg(node.d.args[0]), {
           typeFormArg: isTypeFormSupported(node),
           noNonTypeSpecialForms: true,
           typeExpression: true
@@ -75318,13 +75596,14 @@ var require_typeEvaluator = __commonJS({
             true
           ), isIncomplete: true };
         }
-        const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(node.d.args[1]), {
+        const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType(convertNodeToArg(node.d.args[1]), {
           typeExpression: true
         }).type);
         const arg0Type = stripTypeGuard(arg0TypeResult.type);
         if (!(0, types_1.isTypeSame)(assertedType, arg0Type, {
           treatAnySameAsUnknown: true,
-          ignorePseudoGeneric: true
+          ignorePseudoGeneric: true,
+          ignoreConditions: true
         })) {
           const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
@@ -75334,6 +75613,13 @@ var require_typeEvaluator = __commonJS({
         }
         return { type: arg0TypeResult.type };
       }
+      function convertNodeToArg(node) {
+        return {
+          argCategory: node.d.argCategory,
+          name: node.d.name,
+          valueExpression: node.d.valueExpr
+        };
+      }
       function getTypeOfRevealType(node, inferenceContext) {
         let arg0Value;
         let expectedRevealTypeNode;
@@ -75357,7 +75643,7 @@ var require_typeEvaluator = __commonJS({
             }
           } else if (arg.d.name.d.value === "expected_type") {
             expectedRevealTypeNode = arg.d.valueExpr;
-            expectedRevealType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(arg), {
+            expectedRevealType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType(convertNodeToArg(arg), {
               typeExpression: true
             }).type);
           }
@@ -76462,7 +76748,9 @@ var require_typeEvaluator = __commonJS({
       }
       function evaluateCastCall(argList, errorNode) {
         var _a;
-        const castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        let castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        castToType = (0, typeUtils_1.makeTypeVarsBound)(castToType, liveScopeIds);
         let castFromType = getTypeOfArg(
           argList[1],
           /* inferenceContext */
@@ -76503,7 +76791,7 @@ var require_typeEvaluator = __commonJS({
                       argCategory: 1,
                       valueExpression: void 0,
                       typeResult: {
-                        type: makeTupleObject([tupleTypeArg])
+                        type: (0, tuples_1.makeTupleObject)(evaluatorInterface, [tupleTypeArg])
                       }
                     });
                   } else {
@@ -76669,7 +76957,7 @@ var require_typeEvaluator = __commonJS({
           const paramInfo = paramDetails.params[paramIndex];
           const paramType = paramInfo.type;
           const paramName = paramInfo.param.name;
-          const isParamVariadic = paramInfo.param.category === 1 && (0, types_1.isTypeVarTuple)(paramType);
+          const isParamVariadic = paramInfo.param.category === 1 && (0, types_1.isUnpacked)(paramType);
           if (argList[argIndex].argCategory === 1) {
             let isArgCompatibleWithVariadic = false;
             const argTypeResult = getTypeOfArg(
@@ -76773,7 +77061,7 @@ var require_typeEvaluator = __commonJS({
               if ((0, types_1.isUnpackedClass)(paramType) && paramType.priv.tupleTypeArgs && paramType.priv.tupleTypeArgs.length > 0) {
                 effectiveParamType = paramType.priv.tupleTypeArgs[0].type;
               }
-              paramCategory = (0, types_1.isTypeVarTuple)(effectiveParamType) ? 1 : 0;
+              paramCategory = (0, types_1.isUnpacked)(effectiveParamType) ? 1 : 0;
               if (remainingArgCount <= remainingParamCount) {
                 if (remainingArgCount < remainingParamCount) {
                   if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -77162,7 +77450,7 @@ var require_typeEvaluator = __commonJS({
           if (paramDetails.argsIndex !== void 0 && paramDetails.argsIndex >= 0 && types_1.FunctionParam.isTypeDeclared(paramDetails.params[paramDetails.argsIndex].param) && !isTypeVarTupleFullyMatched) {
             const paramType = paramDetails.params[paramDetails.argsIndex].type;
             const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
-            if ((0, types_1.isTypeVarTuple)(paramType) && !paramType.priv.isInUnion) {
+            if ((0, types_1.isUnpacked)(paramType) && (!(0, types_1.isTypeVarTuple)(paramType) || !paramType.priv.isInUnion)) {
               const tupleTypeArgs = variadicArgs.map((argParam) => {
                 var _a2;
                 const argType = getTypeOfArg(
@@ -77183,18 +77471,23 @@ var require_typeEvaluator = __commonJS({
                 };
               });
               let specializedTuple;
-              if (tupleTypeArgs.length === 1 && !tupleTypeArgs[0].isUnbounded && ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isTypeVarTuple)(tupleTypeArgs[0].type))) {
-                specializedTuple = tupleTypeArgs[0].type;
-              } else {
-                specializedTuple = makeTupleObject(
+              if (tupleTypeArgs.length === 1 && !tupleTypeArgs[0].isUnbounded) {
+                const entryType = tupleTypeArgs[0].type;
+                if ((0, types_1.isUnpacked)(entryType)) {
+                  specializedTuple = (0, typeUtils_1.makePacked)(entryType);
+                }
+              }
+              if (!specializedTuple) {
+                specializedTuple = (0, tuples_1.makeTupleObject)(
+                  evaluatorInterface,
                   tupleTypeArgs,
                   /* isUnpacked */
-                  true
+                  false
                 );
               }
               const combinedArg = {
-                paramCategory: 1,
-                paramType,
+                paramCategory: 0,
+                paramType: (0, typeUtils_1.makePacked)(paramType),
                 requiresTypeVarMatching: true,
                 argument: {
                   argCategory: 0,
@@ -77482,7 +77775,7 @@ var require_typeEvaluator = __commonJS({
             eliminateUnsolvedInUnions
           }
         });
-        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition);
+        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition, { skipBoundTypeVars: true });
         if (paramSpecConstraints.length > 0) {
           paramSpecConstraints.forEach((paramSpecConstraints2) => {
             if (paramSpecConstraints2) {
@@ -77492,11 +77785,7 @@ var require_typeEvaluator = __commonJS({
           });
         }
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
-          specializedReturnType = types_1.ClassType.cloneForUnpacked(
-            specializedReturnType,
-            /* isUnpacked */
-            false
-          );
+          specializedReturnType = types_1.ClassType.cloneForPacked(specializedReturnType);
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
@@ -77997,7 +78286,9 @@ var require_typeEvaluator = __commonJS({
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
         const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, types_1.TypeVarKind.TypeVarTuple), types_1.ClassType.cloneAsInstance(classType));
-        typeVar.shared.defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+        typeVar.shared.defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [
+          { type: types_1.UnknownType.create(), isUnbounded: true }
+        ]);
         for (let i = 1; i < argList.length; i++) {
           const paramNameNode = argList[i].name;
           const paramName = paramNameNode ? paramNameNode.d.value : void 0;
@@ -78122,6 +78413,7 @@ var require_typeEvaluator = __commonJS({
           const typeResult = getTypeOfExpressionExpectingType(node, {
             allowParamSpec: true,
             allowTypeVarsWithoutScopeId: true,
+            allowEllipsis: true,
             typeExpression: true
           });
           if (typeResult.typeErrors) {
@@ -78702,7 +78994,7 @@ var require_typeEvaluator = __commonJS({
           isEmptyContainer
         )) : types_1.UnknownType.create();
         if (isIncomplete) {
-          if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+          if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
             return { type: types_1.UnknownType.create() };
           }
         }
@@ -79085,7 +79377,7 @@ var require_typeEvaluator = __commonJS({
           isEmptyContainer
         )) : types_1.UnknownType.create();
         if (isIncomplete) {
-          if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+          if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
             return { type: types_1.UnknownType.create() };
           }
         }
@@ -79472,7 +79764,7 @@ var require_typeEvaluator = __commonJS({
           if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
             valueType = stripLiteralValue(valueType);
           }
-          type = makeTupleObject([
+          type = (0, tuples_1.makeTupleObject)(evaluatorInterface, [
             { type: keyType, isUnbounded: false },
             { type: valueType, isUnbounded: false }
           ]);
@@ -79715,15 +80007,22 @@ var require_typeEvaluator = __commonJS({
           return types_1.UnknownType.create();
         }
         const literalTypes = [];
+        let isValidTypeForm = true;
         for (const item of node.d.items) {
           let type;
           const itemExpr = item.d.valueExpr;
           if (item.d.argCategory !== 0) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
-            type = types_1.UnknownType.create();
+            if ((flags & 256) !== 0) {
+              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
+              type = types_1.UnknownType.create();
+              isValidTypeForm = false;
+            }
           } else if (item.d.name) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
-            type = types_1.UnknownType.create();
+            if ((flags & 256) !== 0) {
+              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
+              type = types_1.UnknownType.create();
+              isValidTypeForm = false;
+            }
           } else if (itemExpr.nodeType === 48) {
             const isBytes = (itemExpr.d.strings[0].d.token.flags & 32) !== 0;
             const value = itemExpr.d.strings.map((s) => s.d.value).join("");
@@ -79732,11 +80031,14 @@ var require_typeEvaluator = __commonJS({
             } else {
               type = cloneBuiltinClassWithLiteral(node, classType, "str", value);
             }
-            itemExpr.d.strings.forEach((stringNode) => {
-              if ((stringNode.d.token.flags & 512) !== 0) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
-              }
-            });
+            if ((flags & 256) !== 0) {
+              itemExpr.d.strings.forEach((stringNode) => {
+                if ((stringNode.d.token.flags & 512) !== 0) {
+                  addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
+                  isValidTypeForm = false;
+                }
+              });
+            }
           } else if (itemExpr.nodeType === 40) {
             if (!itemExpr.d.isImaginary && itemExpr.d.isInteger) {
               type = cloneBuiltinClassWithLiteral(node, classType, "int", itemExpr.d.value);
@@ -79784,6 +80086,7 @@ var require_typeEvaluator = __commonJS({
             if ((flags & 256) !== 0) {
               addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
               type = types_1.UnknownType.create();
+              isValidTypeForm = false;
             } else {
               return types_1.ClassType.cloneAsInstance(classType);
             }
@@ -79794,7 +80097,7 @@ var require_typeEvaluator = __commonJS({
         if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
           result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
-        if (isTypeFormSupported(node)) {
+        if (isTypeFormSupported(node) && isValidTypeForm) {
           result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
         }
         return result;
@@ -79950,18 +80253,21 @@ var require_typeEvaluator = __commonJS({
             isUsageLegal = true;
           }
         }
-        if ((flags & 1048576) !== 0) {
-          isUsageLegal = true;
-        }
         let isReadOnly = typeArgs[0].isReadOnly;
         let isRequired = typeArgs[0].isRequired;
         let isNotRequired = typeArgs[0].isNotRequired;
         if (classType.shared.name === "ReadOnly") {
+          if ((flags & 2097152) !== 0) {
+            isUsageLegal = true;
+          }
           if (typeArgs[0].isReadOnly) {
             isUsageLegal = false;
           }
           isReadOnly = true;
         } else {
+          if ((flags & 1048576) !== 0) {
+            isUsageLegal = true;
+          }
           if (typeArgs[0].isRequired || typeArgs[0].isNotRequired) {
             isUsageLegal = false;
           }
@@ -79983,16 +80289,11 @@ var require_typeEvaluator = __commonJS({
           }
           return classType;
         }
-        let typeArgType = typeArgs[0].type;
-        if ((0, types_1.isUnion)(typeArgType) && typeArgType.priv.subtypes.length === 1) {
-          typeArgType = typeArgType.priv.subtypes[0];
-        }
-        if ((flags & 2097152) !== 0) {
-          if ((0, types_1.isInstantiableClass)(typeArgType) && !typeArgType.priv.includeSubclasses && (0, typeUtils_1.isTupleClass)(typeArgType)) {
-            return types_1.ClassType.cloneForUnpacked(typeArgType);
-          }
-          if ((0, types_1.isTypeVarTuple)(typeArgType) && !typeArgType.priv.isUnpacked) {
-            return types_1.TypeVarType.cloneForUnpacked(typeArgType);
+        const typeArgType = typeArgs[0].type;
+        if ((flags & 4194304) !== 0) {
+          const unpackedType = applyUnpackToTupleLike(typeArgType);
+          if (unpackedType) {
+            return unpackedType;
           }
           if ((flags & 256) === 0) {
             return classType;
@@ -80000,7 +80301,7 @@ var require_typeEvaluator = __commonJS({
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
           return types_1.UnknownType.create();
         }
-        if ((flags & 4194304) !== 0) {
+        if ((flags & 8388608) !== 0) {
           if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isTypedDictClass(typeArgType)) {
             return types_1.ClassType.cloneForUnpacked(typeArgType);
           }
@@ -80105,51 +80406,7 @@ var require_typeEvaluator = __commonJS({
         return baseType;
       }
       function validateTypeMetadata(errorNode, baseType, metaArg) {
-        var _a;
-        if (!AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-          return true;
-        }
-        if (!(0, types_1.isClass)(metaArg.type)) {
-          return true;
-        }
-        const supportsTypeMethod = (_a = getTypeOfBoundMember(
-          /* errorNode */
-          void 0,
-          metaArg.type,
-          "__supports_type__"
-        )) === null || _a === void 0 ? void 0 : _a.type;
-        if (!supportsTypeMethod) {
-          return true;
-        }
-        const callResult = useSpeculativeMode(errorNode, () => validateCallArgs(
-          errorNode,
-          [
-            {
-              argCategory: 0,
-              typeResult: { type: (0, typeUtils_1.convertToInstance)(baseType) }
-            }
-          ],
-          { type: supportsTypeMethod },
-          /* constraints */
-          void 0,
-          /* skipUnknownArgCheck */
-          true,
-          /* inferenceContext */
-          void 0
-        ));
-        if (!callResult.returnType) {
-          return true;
-        }
-        if (!callResult.argumentErrors && canBeTruthy(callResult.returnType)) {
-          return true;
-        }
-        if (!callResult.isTypeIncomplete) {
-          addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.annotatedMetadataInconsistent().format({
-            metadataType: printType(metaArg.type),
-            type: printType((0, typeUtils_1.convertToInstance)(baseType))
-          }), metaArg.node);
-        }
-        return false;
+        return true;
       }
       function createSpecialType(classType, typeArgs, paramLimit, allowParamSpec = false, isSpecialForm = true) {
         const isTupleTypeParam = types_1.ClassType.isTupleClass(classType);
@@ -80281,7 +80538,9 @@ var require_typeEvaluator = __commonJS({
           types2.push(typeArgType);
         }
         if (types2.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types2[0])) {
-          addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+          if ((flags & 256) !== 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+          }
           isValidTypeForm = false;
         }
         let unionType = (0, types_1.combineTypes)(types2, { skipElideRedundantLiterals: true });
@@ -80335,9 +80594,6 @@ var require_typeEvaluator = __commonJS({
       }
       function transformTypeForTypeAlias(type, errorNode, typeAliasPlaceholder, isPep695TypeVarType, typeParamNodes) {
         var _a;
-        if (!types_1.TypeBase.isInstantiable(type)) {
-          return type;
-        }
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
           return type;
         }
@@ -80391,6 +80647,9 @@ var require_typeEvaluator = __commonJS({
             }), errorNode);
           }
         }
+        if (!types_1.TypeBase.isInstantiable(type)) {
+          return type;
+        }
         sharedInfo.typeParams = typeParams.length > 0 ? typeParams : void 0;
         let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, {
           shared: sharedInfo,
@@ -80645,7 +80904,6 @@ var require_typeEvaluator = __commonJS({
           }
         }
         if (!rightHandType) {
-          const declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: "set" });
           let typeAliasNameNode;
           let typeAliasPlaceholder;
           let isSpeculativeTypeAlias = false;
@@ -80706,6 +80964,11 @@ var require_typeEvaluator = __commonJS({
               );
             }
           }
+          let declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: "set" });
+          if (declaredType) {
+            const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+            declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
+          }
           const srcTypeResult = getTypeOfExpression(node.d.rightExpr, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
           rightHandType = srcTypeResult.type;
           expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
@@ -81140,6 +81403,17 @@ var require_typeEvaluator = __commonJS({
                 } else if (arg.d.name.d.value === "closed" && constArgValue) {
                   if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
                     classType.shared.flags |= 8 | 16;
+                    if (classType.shared.typedDictExtraItemsExpr) {
+                      addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
+                    }
+                  }
+                }
+              } else if (arg.d.name.d.value === "extra_items") {
+                if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                  classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
+                  classType.shared.flags |= 16;
+                  if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                   }
                 }
               } else {
@@ -82187,20 +82461,16 @@ var require_typeEvaluator = __commonJS({
               return type;
             }
             if ((0, types_1.isUnpackedClass)(type)) {
-              return types_1.ClassType.cloneForUnpacked(
-                type,
-                /* isUnpacked */
-                false
-              );
+              return types_1.ClassType.cloneForPacked(type);
             }
-            return makeTupleObject([{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
+            return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
           }
           case 2: {
             if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
               return type;
             }
             if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isTypedDictClass(type) && type.priv.isUnpacked) {
-              return type;
+              return types_1.ClassType.cloneForPacked(type);
             }
             const dictType = getBuiltInType(node, "dict");
             const strType = getBuiltInObject(node, "str");
@@ -82217,7 +82487,7 @@ var require_typeEvaluator = __commonJS({
         if (functionType.shared.declaredReturnType) {
           awaitableFunctionType.shared.declaredReturnType = createAwaitableReturnType(node, functionType.shared.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         } else {
-          awaitableFunctionType.priv.inferredReturnType = createAwaitableReturnType(node, getFunctionInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
+          awaitableFunctionType.priv.inferredReturnType = createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
         }
         return awaitableFunctionType;
       }
@@ -83622,29 +83892,9 @@ var require_typeEvaluator = __commonJS({
         }
         let typeArgTypes = [];
         const fullTypeParams = types_1.ClassType.getTypeParams(classType);
-        if (fullTypeParams.length === 1 && (0, types_1.isParamSpec)(fullTypeParams[0]) && typeArgs) {
-          if (typeArgs.every((typeArg) => !(0, typeUtils_1.isEllipsisType)(typeArg.type) && !typeArg.typeList && !(0, types_1.isParamSpec)(typeArg.type))) {
-            if (typeArgs.length !== 1 || !(0, types_1.isInstantiableClass)(typeArgs[0].type) || !types_1.ClassType.isBuiltIn(typeArgs[0].type, "Concatenate")) {
-              typeArgs = typeArgs.length > 0 ? [
-                {
-                  type: types_1.UnknownType.create(),
-                  node: typeArgs[0].node,
-                  typeList: typeArgs
-                }
-              ] : [];
-            }
-          } else if (typeArgs.length > 1) {
-            const paramSpecTypeArg = typeArgs.find((typeArg) => (0, types_1.isParamSpec)(typeArg.type));
-            if (paramSpecTypeArg) {
-              isValidTypeForm = false;
-              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), paramSpecTypeArg.node);
-            }
-            const listTypeArg = typeArgs.find((typeArg) => !!typeArg.typeList);
-            if (listTypeArg) {
-              isValidTypeForm = false;
-              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), listTypeArg.node);
-            }
-          }
+        typeArgs = transformTypeArgsForParamSpec(fullTypeParams, typeArgs, errorNode);
+        if (!typeArgs) {
+          isValidTypeForm = false;
         }
         const constraints = new constraintTracker_1.ConstraintTracker();
         fullTypeParams.forEach((typeParam, index) => {
@@ -83747,6 +83997,50 @@ var require_typeEvaluator = __commonJS({
         }
         return { type: specializedClass };
       }
+      function transformTypeArgsForParamSpec(typeParams, typeArgs, errorNode) {
+        if (typeParams.length !== 1 || !(0, types_1.isParamSpec)(typeParams[0]) || !typeArgs) {
+          return typeArgs;
+        }
+        if (typeArgs.length > 1) {
+          for (const typeArg of typeArgs) {
+            if ((0, types_1.isParamSpec)(typeArg.type)) {
+              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), typeArg.node);
+              return void 0;
+            }
+            if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
+              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), typeArg.node);
+              return void 0;
+            }
+            if ((0, types_1.isInstantiableClass)(typeArg.type) && types_1.ClassType.isBuiltIn(typeArg.type, "Concatenate")) {
+              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), typeArg.node);
+              return void 0;
+            }
+            if (typeArg.typeList) {
+              addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArg.node);
+              return void 0;
+            }
+          }
+        }
+        if (typeArgs.length === 1) {
+          if (typeArgs[0].typeList) {
+            return typeArgs;
+          }
+          const typeArgType = typeArgs[0].type;
+          if ((0, types_1.isParamSpec)(typeArgType) || (0, typeUtils_1.isEllipsisType)(typeArgType)) {
+            return typeArgs;
+          }
+          if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isBuiltIn(typeArgType, "Concatenate")) {
+            return typeArgs;
+          }
+        }
+        return [
+          {
+            type: types_1.UnknownType.create(),
+            node: typeArgs.length > 0 ? typeArgs[0].node : errorNode,
+            typeList: typeArgs
+          }
+        ];
+      }
       function getTypeOfArg(arg, inferenceContext) {
         var _a, _b;
         if (arg.typeResult) {
@@ -83785,7 +84079,7 @@ var require_typeEvaluator = __commonJS({
         if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(fileInfo) || (options === null || options === void 0 ? void 0 : options.forwardRefs)) {
           flags |= 4;
         } else if (options === null || options === void 0 ? void 0 : options.parsesStringLiteral) {
-          flags |= 8388608;
+          flags |= 16777216;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowFinal)) {
           flags |= 16;
@@ -83793,13 +84087,16 @@ var require_typeEvaluator = __commonJS({
         if (options === null || options === void 0 ? void 0 : options.allowRequired) {
           flags |= 1048576 | 256;
         }
+        if (options === null || options === void 0 ? void 0 : options.allowReadOnly) {
+          flags |= 2097152 | 256;
+        }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTuple) {
-          flags |= 2097152;
+          flags |= 4194304;
         } else {
           flags |= 64;
         }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
-          flags |= 4194304;
+          flags |= 8388608;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
           flags |= 32;
@@ -83810,6 +84107,9 @@ var require_typeEvaluator = __commonJS({
         if (options === null || options === void 0 ? void 0 : options.convertEllipsisToAny) {
           flags |= 1;
         }
+        if (options === null || options === void 0 ? void 0 : options.allowEllipsis) {
+          flags |= 65536;
+        }
         if (options === null || options === void 0 ? void 0 : options.noNonTypeSpecialForms) {
           flags |= 67108864;
         }
@@ -84171,7 +84471,7 @@ var require_typeEvaluator = __commonJS({
                   const paramDecl = getDeclarationFromKeywordParam(initMethodType, paramName);
                   if (paramDecl) {
                     declarations.push(paramDecl);
-                  } else if (types_1.ClassType.isDataClass(baseType) || types_1.ClassType.isTypedDictClass(baseType)) {
+                  } else if (types_1.ClassType.isDataClass(baseType) || types_1.ClassType.isTypedDictClass(baseType) || types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
                     const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
                     if (lookupResults) {
                       (0, collectionUtils_1.appendArray)(declarations, lookupResults.symbol.getDeclarations());
@@ -84296,7 +84596,8 @@ var require_typeEvaluator = __commonJS({
               if (declaration.isRuntimeTypeExpression) {
                 declaredType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(typeAnnotationNode, {
                   allowFinal: true,
-                  allowRequired: true
+                  allowRequired: true,
+                  allowReadOnly: true
                 }).type);
               } else {
                 const declNode = declaration.isDefinedByMemberAccess && ((_c = declaration.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 35 ? declaration.node.parent : declaration.node;
@@ -84305,6 +84606,7 @@ var require_typeEvaluator = __commonJS({
                   allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode),
                   allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode),
                   allowRequired: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
+                  allowReadOnly: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
                   enforceClassTypeVarScope: declaration.isDefinedByMemberAccess
                 });
               }
@@ -84424,7 +84726,9 @@ var require_typeEvaluator = __commonJS({
             typeVar.shared.defaultType = defaultType;
             typeVar.shared.isDefaultExplicit = true;
           } else {
-            typeVar.shared.defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+            typeVar.shared.defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [
+              { type: types_1.UnknownType.create(), isUnbounded: true }
+            ]);
           }
         } else {
           const defaultType = node.d.defaultExpr ? (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.d.defaultExpr, {
@@ -84446,7 +84750,7 @@ var require_typeEvaluator = __commonJS({
           let scopeType;
           if (scopeNode.nodeType === 10) {
             scopeType = 0;
-            typeVar.shared.declaredVariance = 0;
+            typeVar.shared.declaredVariance = (0, types_1.isParamSpec)(typeVar) || (0, types_1.isTypeVarTuple)(typeVar) ? 2 : 0;
           } else if (scopeNode.nodeType === 31) {
             scopeType = 1;
           } else {
@@ -84455,7 +84759,7 @@ var require_typeEvaluator = __commonJS({
               /* ParseNodeType.TypeAlias */
             );
             scopeType = 2;
-            typeVar.shared.declaredVariance = 0;
+            typeVar.shared.declaredVariance = (0, types_1.isParamSpec)(typeVar) || (0, types_1.isTypeVarTuple)(typeVar) ? 2 : 0;
           }
           typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(scopeNode.nodeType === 77 ? scopeNode.d.name : scopeNode), scopeNode.d.name.d.value, scopeType);
         }
@@ -84890,27 +85194,31 @@ var require_typeEvaluator = __commonJS({
           return { type: void 0 };
         }
         if (usageNode && typedDecls.length > 1) {
-          const filteredTypedDecls = typedDecls.filter((decl) => {
-            if (decl.type !== 8) {
-              const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
-              const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
-              if (usageScope === declScope) {
-                if (!isFlowPathBetweenNodes(
-                  decl.node,
-                  usageNode,
-                  /* allowSelf */
-                  false
-                )) {
-                  return false;
+          if (typedDecls.length > maxTypedDeclsPerSymbol) {
+            typedDecls = [typedDecls[typedDecls.length - 1]];
+          } else {
+            const filteredTypedDecls = typedDecls.filter((decl) => {
+              if (decl.type !== 8) {
+                const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
+                const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
+                if (usageScope === declScope) {
+                  if (!isFlowPathBetweenNodes(
+                    decl.node,
+                    usageNode,
+                    /* allowSelf */
+                    false
+                  )) {
+                    return false;
+                  }
                 }
               }
+              return true;
+            });
+            if (filteredTypedDecls.length === 0) {
+              return { type: types_1.UnboundType.create() };
             }
-            return true;
-          });
-          if (filteredTypedDecls.length === 0) {
-            return { type: types_1.UnboundType.create() };
+            typedDecls = filteredTypedDecls;
           }
-          typedDecls = filteredTypedDecls;
         }
         let declIndex = typedDecls.length - 1;
         while (declIndex >= 0) {
@@ -84959,7 +85267,7 @@ var require_typeEvaluator = __commonJS({
           return specializedReturnType;
         }
         if (!(options === null || options === void 0 ? void 0 : options.skipInferReturnType)) {
-          return getFunctionInferredReturnType(type, options === null || options === void 0 ? void 0 : options.callSiteInfo);
+          return getInferredReturnType(type, options === null || options === void 0 ? void 0 : options.callSiteInfo);
         }
         return types_1.UnknownType.create();
       }
@@ -85457,7 +85765,8 @@ var require_typeEvaluator = __commonJS({
             const typeParam = destType.shared.typeParams[i];
             const variance = types_1.TypeVarType.getVariance(typeParam);
             if (curSrcType.priv.tupleTypeArgs) {
-              typeArgType = (0, typeUtils_1.convertToInstance)(makeTupleObject(
+              typeArgType = (0, typeUtils_1.convertToInstance)((0, tuples_1.makeTupleObject)(
+                evaluatorInterface,
                 curSrcType.priv.tupleTypeArgs,
                 /* isUnpacked */
                 true
@@ -85844,6 +86153,9 @@ var require_typeEvaluator = __commonJS({
           }
           let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
           if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
+            if (!destType.priv.isUnpacked && concreteSrcType.priv.isUnpacked && concreteSrcType.priv.tupleTypeArgs) {
+              return assignType(destType, (0, typeUtils_1.combineTupleTypeArgs)(concreteSrcType.priv.tupleTypeArgs), diag, constraints, flags, recursionCount);
+            }
             if (types_1.ClassType.isEnumClass(concreteSrcType) && concreteSrcType.priv.literalValue instanceof types_1.EnumLiteral && concreteSrcType.shared.mro.some((base) => (0, types_1.isClass)(base) && types_1.ClassType.isBuiltIn(base, ["int", "str", "bytes"])) && (0, types_1.isClassInstance)(concreteSrcType.priv.literalValue.itemType) && (0, typeUtils_1.isLiteralType)(concreteSrcType.priv.literalValue.itemType) && assignType(destType, concreteSrcType.priv.literalValue.itemType)) {
               return true;
             }
@@ -86669,7 +86981,8 @@ var require_typeEvaluator = __commonJS({
           }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isTypeVarTuple)(srcTupleTypes[0].type)) {
-          const srcPositionalsType = makeTupleObject(
+          const srcPositionalsType = (0, tuples_1.makeTupleObject)(
+            evaluatorInterface,
             srcTupleTypes,
             /* isUnpacked */
             true
@@ -86737,9 +87050,9 @@ var require_typeEvaluator = __commonJS({
           const destParamName = (_c = destParam.param.name) !== null && _c !== void 0 ? _c : "";
           const srcParamName = (_d = srcParam.param.name) !== null && _d !== void 0 ? _d : "";
           if (destParamName) {
-            const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional;
+            const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional || destParam.kind === parameterUtils_1.ParamKind.ExpandedArgs;
             if (!isDestPositionalOnly && destParam.param.category !== 1 && srcParam.param.category !== 1) {
-              if (srcParam.kind === parameterUtils_1.ParamKind.Positional) {
+              if (srcParam.kind === parameterUtils_1.ParamKind.Positional || srcParam.kind === parameterUtils_1.ParamKind.ExpandedArgs) {
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamPositionOnly().format({
                   name: destParamName
                 }));
@@ -86775,7 +87088,7 @@ var require_typeEvaluator = __commonJS({
             if ((flags & 512) === 0 || !(0, types_1.isTypeVar)(srcParamType) || !srcParamType.shared.isSynthesized) {
               canAssign = false;
             }
-          } else if (destParam.kind !== parameterUtils_1.ParamKind.Positional && srcParam.kind === parameterUtils_1.ParamKind.Positional && srcParamDetails.kwargsIndex === void 0 && !srcParamDetails.params.some((p) => p.kind === parameterUtils_1.ParamKind.Keyword && p.param.category === 0 && p.param.name === destParam.param.name)) {
+          } else if (destParam.kind !== parameterUtils_1.ParamKind.Positional && destParam.kind !== parameterUtils_1.ParamKind.ExpandedArgs && srcParam.kind === parameterUtils_1.ParamKind.Positional && srcParamDetails.kwargsIndex === void 0 && !srcParamDetails.params.some((p) => p.kind === parameterUtils_1.ParamKind.Keyword && p.param.category === 0 && p.param.name === destParam.param.name)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
               name: (_e = destParam.param.name) !== null && _e !== void 0 ? _e : ""
             }));
@@ -86842,7 +87155,8 @@ var require_typeEvaluator = __commonJS({
                 if (!assignParam(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                   canAssign = false;
                 }
-                if (destParamDetails.params[paramIndex].kind !== parameterUtils_1.ParamKind.Positional && srcParamDetails.kwargsIndex === void 0) {
+                const destParamKind = destParamDetails.params[paramIndex].kind;
+                if (destParamKind !== parameterUtils_1.ParamKind.Positional && destParamKind !== parameterUtils_1.ParamKind.ExpandedArgs && srcParamDetails.kwargsIndex === void 0) {
                   diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
                     name: (_g = destParamDetails.params[paramIndex].param.name) !== null && _g !== void 0 ? _g : ""
                   }));
@@ -86873,14 +87187,16 @@ var require_typeEvaluator = __commonJS({
           let destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
           let srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
           if (!(0, types_1.isUnpacked)(destArgsType)) {
-            destArgsType = makeTupleObject(
+            destArgsType = (0, tuples_1.makeTupleObject)(
+              evaluatorInterface,
               [{ type: destArgsType, isUnbounded: true }],
               /* isUnpacked */
               true
             );
           }
           if (!(0, types_1.isUnpacked)(srcArgsType)) {
-            srcArgsType = makeTupleObject(
+            srcArgsType = (0, tuples_1.makeTupleObject)(
+              evaluatorInterface,
               [{ type: srcArgsType, isUnbounded: true }],
               /* isUnpacked */
               true
@@ -86901,7 +87217,7 @@ var require_typeEvaluator = __commonJS({
           if (destParamDetails.firstKeywordOnlyIndex !== void 0) {
             destParamDetails.params.forEach((param, index) => {
               if (index >= destParamDetails.firstKeywordOnlyIndex) {
-                if (param.param.name && param.param.category === 0 && param.kind !== parameterUtils_1.ParamKind.Positional) {
+                if (param.param.name && param.param.category === 0 && param.kind !== parameterUtils_1.ParamKind.Positional && param.kind !== parameterUtils_1.ParamKind.ExpandedArgs) {
                   destParamMap.set(param.param.name, param);
                 }
               }
@@ -87172,7 +87488,7 @@ var require_typeEvaluator = __commonJS({
                 }
                 return assignedSubtype;
               }
-              if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype)) {
+              if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype) && !types_1.TypeVarType.isBound(assignedSubtype)) {
                 return declaredSubtype;
               }
               if ((0, typeUtils_1.containsAnyRecursive)(
@@ -87394,7 +87710,7 @@ var require_typeEvaluator = __commonJS({
                 }
               }
             } else if (i < overrideParamDetails.positionOnlyParamCount && i >= baseParamDetails.positionOnlyParamCount) {
-              if (!types_1.FunctionParam.isNameSynthesized(baseParam) && baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.Positional) {
+              if (!types_1.FunctionParam.isNameSynthesized(baseParam) && baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.Positional && baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.ExpandedArgs) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                   index: i + 1,
                   baseName: baseParam.name || "*"
@@ -87974,7 +88290,7 @@ var require_typeEvaluator = __commonJS({
       function printControlFlowGraph(flowNode, reference, callName, logger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
       }
-      const getFunctionInferredReturnType = wrapWithLogger(_getInferredReturnType);
+      const getInferredReturnType = wrapWithLogger(_getInferredReturnType);
       const evaluatorInterface = {
         runWithCancellationToken,
         getType,
@@ -88020,6 +88336,8 @@ var require_typeEvaluator = __commonJS({
         getTypeOfIterator,
         getGetterTypeFromProperty,
         getTypeOfArg,
+        convertNodeToArg,
+        buildTupleTypesList,
         markNamesAccessed,
         expandPromotionTypes,
         makeTopLevelTypeVarsConcrete,
@@ -88031,8 +88349,8 @@ var require_typeEvaluator = __commonJS({
         getEffectiveTypeOfSymbolForUsage,
         getInferredTypeOfDeclaration,
         getDeclaredTypeForExpression,
-        getFunctionDeclaredReturnType: getDeclaredReturnType,
-        getFunctionInferredReturnType,
+        getDeclaredReturnType,
+        getInferredReturnType,
         getBestOverloadForArgs,
         getBuiltInType,
         getTypeOfMember,
@@ -88584,7 +88902,7 @@ var require_checker = __commonJS({
         let returnTypeResult;
         let returnType;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-        let declaredReturnType = enclosingFunctionNode ? this._evaluator.getFunctionDeclaredReturnType(enclosingFunctionNode) : void 0;
+        let declaredReturnType = enclosingFunctionNode ? this._evaluator.getDeclaredReturnType(enclosingFunctionNode) : void 0;
         if (node.d.expr) {
           returnTypeResult = (_a = this._evaluator.getTypeResult(node.d.expr)) !== null && _a !== void 0 ? _a : { type: types_1.UnknownType.create() };
         } else {
@@ -88803,10 +89121,6 @@ var require_checker = __commonJS({
         return true;
       }
       visitBinaryOperation(node) {
-        if (node.d.operator === 36 || node.d.operator === 37) {
-          this._validateConditionalIsBool(node.d.leftExpr);
-          this._validateConditionalIsBool(node.d.rightExpr);
-        }
         if (node.d.operator === 12 || node.d.operator === 28) {
           if (!ParseTreeUtils.isWithinAssertExpression(node)) {
             this._validateComparisonTypes(node);
@@ -89809,8 +90123,8 @@ var require_checker = __commonJS({
           64 | 2 | 512
           /* AssignTypeFlags.SkipSelfClsTypeCheck */
         );
-        const overloadReturnType = this._evaluator.solveAndApplyConstraints((_d = types_1.FunctionType.getEffectiveReturnType(overloadBound)) !== null && _d !== void 0 ? _d : this._evaluator.getFunctionInferredReturnType(overloadBound), constraints);
-        const implReturnType = this._evaluator.solveAndApplyConstraints((_e = types_1.FunctionType.getEffectiveReturnType(implBound)) !== null && _e !== void 0 ? _e : this._evaluator.getFunctionInferredReturnType(implBound), constraints);
+        const overloadReturnType = this._evaluator.solveAndApplyConstraints((_d = types_1.FunctionType.getEffectiveReturnType(overloadBound)) !== null && _d !== void 0 ? _d : this._evaluator.getInferredReturnType(overloadBound), constraints);
+        const implReturnType = this._evaluator.solveAndApplyConstraints((_e = types_1.FunctionType.getEffectiveReturnType(implBound)) !== null && _e !== void 0 ? _e : this._evaluator.getInferredReturnType(implBound), constraints);
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) && !this._evaluator.assignType(
           implReturnType,
@@ -90295,14 +90609,14 @@ var require_checker = __commonJS({
             const primaryType = (_a = this._evaluator.getTypeForDeclaration(primaryDecl)) === null || _a === void 0 ? void 0 : _a.type;
             let duplicateIsOk = false;
             if (primaryType && (0, types_1.isFunction)(primaryType)) {
-              this._evaluator.getFunctionInferredReturnType(primaryType);
+              this._evaluator.getInferredReturnType(primaryType);
             }
             const otherType = (_b = this._evaluator.getTypeForDeclaration(otherDecl)) === null || _b === void 0 ? void 0 : _b.type;
             const suite1 = ParseTreeUtils.getEnclosingSuite(primaryDecl.node);
             const suite2 = ParseTreeUtils.getEnclosingSuite(otherDecl.node);
             const isInSameStatementList = suite1 === suite2;
             if (otherType && (0, types_1.isFunction)(otherType)) {
-              this._evaluator.getFunctionInferredReturnType(otherType);
+              this._evaluator.getInferredReturnType(otherType);
             }
             if (!isInSameStatementList && primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
               duplicateIsOk = true;
@@ -91088,7 +91402,7 @@ var require_checker = __commonJS({
               this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMustReturnNone(), returnAnnotation);
             }
           } else {
-            const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
+            const inferredReturnType = this._evaluator.getInferredReturnType(functionType);
             if (!(0, types_1.isNever)(inferredReturnType) && !(0, typeUtils_1.isNoneInstance)(inferredReturnType) && !(0, types_1.isAnyOrUnknown)(inferredReturnType)) {
               this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMustReturnNone(), node.d.name);
             }
@@ -91132,7 +91446,7 @@ var require_checker = __commonJS({
             }
           }
         } else {
-          const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
+          const inferredReturnType = this._evaluator.getInferredReturnType(functionType);
           this._reportUnknownReturnResult(node, inferredReturnType);
           this._validateReturnTypeIsNotContravariant(inferredReturnType, node.d.name);
         }
@@ -92126,7 +92440,7 @@ var require_checker = __commonJS({
               /* AssignTypeFlags.Default */
             )) {
               diag.addMessage(localize_1.LocAddendum.typedDictClosedExtraTypeMismatch().format({
-                name: "__extra_items__",
+                name: "extra_items",
                 type: this._evaluator.printType(typedDictEntries.extraItems.valueType)
               }));
             }
@@ -92381,12 +92695,7 @@ var require_checker = __commonJS({
                   }
                 }
                 if (childClassType.shared.typedDictEntries) {
-                  if (types_1.ClassType.isTypedDictMarkedClosed(childClassType) && memberName === "__extra_items__") {
-                    overrideTDEntry = overriddenTDEntry;
-                    overrideType = baseType;
-                  } else {
-                    overrideTDEntry = (_g = (_f = childClassType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _f !== void 0 ? _f : childClassType.shared.typedDictEntries.extraItems) !== null && _g !== void 0 ? _g : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
-                  }
+                  overrideTDEntry = (_g = (_f = childClassType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _f !== void 0 ? _f : childClassType.shared.typedDictEntries.extraItems) !== null && _g !== void 0 ? _g : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
                 }
               }
               let diagAddendum = new diagnostic_1.DiagnosticAddendum();