coc-pyright 1.1.398 → 1.1.400

package/lib/index.js

@@ -16099,8 +16099,8 @@ var require_serviceProviderExtensions = __commonJS({
       return result;
     };
     var DefaultSourceFileFactory = {
-      createSourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, isModulePrivate, editMode, console2, logTracker, ipythonMode) {
-        return new sourceFile_1.SourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, isModulePrivate, editMode, console2, logTracker, ipythonMode);
+      createSourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, editMode, console2, logTracker, ipythonMode) {
+        return new sourceFile_1.SourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, editMode, console2, logTracker, ipythonMode);
       }
     };
   }
@@ -16943,6 +16943,7 @@ var require_package_nls_cs = __commonJS({
         kwargsParamMissing: "Parametr \u201E**{paramName}\u201C nem\xE1 \u017E\xE1dn\xFD odpov\xEDdaj\xEDc\xED parametr",
         listAssignmentMismatch: "Typ {type} nen\xED kompatibiln\xED s c\xEDlov\xFDm seznamem",
         literalAssignmentMismatch: "{sourceType} se ned\xE1 p\u0159i\u0159adit k typu {destType}.",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: "Pokud nen\xED zam\xFD\u0161leno vy\u010Derp\xE1vaj\xEDc\xED zpracov\xE1n\xED, p\u0159idejte case _: pass",
         matchIsNotExhaustiveType: "Nezpracovan\xFD typ: {type}",
         memberAssignment: "V\xFDraz typu {type} nelze p\u0159i\u0159adit k atributu {name} t\u0159\xEDdy {classType}.",
@@ -17784,6 +17785,7 @@ var require_package_nls_de = __commonJS({
         kwargsParamMissing: 'Der Parameter "**{paramName}" weist keinen entsprechenden Parameter auf.',
         listAssignmentMismatch: 'Der Typ "{type}" ist nicht mit der Zielliste kompatibel.',
         literalAssignmentMismatch: "\u201E{sourceType}\u201C kann dem Typ \u201E{destType}\u201C nicht zugewiesen werden.",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Wenn keine ausf\xFChrliche Behandlung beabsichtigt ist, f\xFCgen Sie "case _: pass" hinzu.',
         matchIsNotExhaustiveType: 'Unbehandelter Typ: "{type}"',
         memberAssignment: "Ein Ausdruck vom Typ \u201E{type}\u201C kann dem Attribut \u201E{name}\u201C der Klasse \u201E{classType}\u201C nicht zugewiesen werden",
@@ -18407,6 +18409,18 @@ var require_package_nls_en_us = __commonJS({
           message: 'A "Final" variable cannot be assigned within a loop',
           comment: "{Locked='Final'}"
         },
+        finallyBreak: {
+          message: 'A "break" cannot be used to exit a "finally" block',
+          comment: "{Locked='break', 'finally'}"
+        },
+        finallyContinue: {
+          message: 'A "continue" cannot be used to exit a "finally" block',
+          comment: "{Locked='continue', 'finally'}"
+        },
+        finallyReturn: {
+          message: 'A "return" cannot be used to exit a "finally" block',
+          comment: "{Locked='return', 'finally'}"
+        },
         finalMethodOverride: {
           message: 'Method "{name}" cannot override final method defined in class "{className}"',
           comment: "{Locked='final'}"
@@ -18684,6 +18698,10 @@ var require_package_nls_en_us = __commonJS({
           message: 'Cannot override "{name}" because parent class "{className}" is a named tuple',
           comment: "{Locked='tuple'}"
         },
+        namedTupleFieldUnderscore: {
+          message: "Named tuple field names cannot start with an underscore",
+          comment: "{Locked='Named','tuple'}"
+        },
         namedTupleFirstArg: {
           message: "Expected named tuple class name as first argument",
           comment: "{Locked='tuple'}"
@@ -18703,7 +18721,7 @@ var require_package_nls_en_us = __commonJS({
         },
         namedTupleNoTypes: {
           message: '"namedtuple" provides no types for tuple entries; use "NamedTuple" instead',
-          comment: `{Locked='namedtuple";'tuple','NamedTuple'}`
+          comment: "{Locked='namedtuple','tuple','NamedTuple'}"
         },
         namedTupleSecondArg: {
           message: "Expected named tuple entry list as second argument",
@@ -19765,6 +19783,10 @@ var require_package_nls_en_us = __commonJS({
         kwargsParamMissing: 'Parameter "**{paramName}" has no corresponding parameter',
         listAssignmentMismatch: 'Type "{type}" is incompatible with target list',
         literalAssignmentMismatch: '"{sourceType}" is not assignable to type "{destType}"',
+        literalNotAllowed: {
+          message: '"Literal" special form cannot be used with instance and class checks',
+          comment: "{Locked='Literal'}"
+        },
         matchIsNotExhaustiveHint: {
           message: 'If exhaustive handling is not intended, add "case _: pass"',
           comment: "{Locked='case _: pass'}"
@@ -20741,6 +20763,7 @@ var require_package_nls_es = __commonJS({
         kwargsParamMissing: 'El par\xE1metro "**{paramName}" no tiene ning\xFAn par\xE1metro correspondiente.',
         listAssignmentMismatch: 'El tipo "{type}" es incompatible con la lista de objetivos',
         literalAssignmentMismatch: '"{sourceType}" no se puede asignar al tipo "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Si no se pretende un tratamiento exhaustivo, agregue "case _: pass"',
         matchIsNotExhaustiveType: 'Tipo no manejado: "{type}"',
         memberAssignment: 'La expresi\xF3n de tipo "{type}" no se puede asignar al atributo "{name}" de la clase "{classType}"',
@@ -21582,6 +21605,7 @@ var require_package_nls_fr = __commonJS({
         kwargsParamMissing: `Le param\xE8tre "**{paramName}" n'a pas de param\xE8tre correspondant`,
         listAssignmentMismatch: "Le type \xAB\xA0{type}\xA0\xBB n\u2019est pas compatible avec la liste cible",
         literalAssignmentMismatch: "\xAB\xA0{sourceType}\xA0\xBB n\u2019est pas assignable au type \xAB\xA0{destType}\xA0\xBB",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: "Si la gestion exhaustive n\u2019est pas pr\xE9vue, ajoutez \xAB case _: pass \xBB",
         matchIsNotExhaustiveType: "Type non g\xE9r\xE9 : \xAB\xA0{type}\xA0\xBB",
         memberAssignment: "L'expression de type \xAB\xA0{type}\xA0\xBB ne peut pas \xEAtre attribu\xE9e \xE0 l\u2019attribut \xAB\xA0{name}\xA0\xBB de la classe \xAB\xA0{classType}\xA0\xBB",
@@ -22423,6 +22447,7 @@ var require_package_nls_it = __commonJS({
         kwargsParamMissing: 'Il parametro "**{paramName}" non ha un parametro corrispondente',
         listAssignmentMismatch: `Il tipo "{type}" non \xE8 compatibile con l'elenco di destinazione`,
         literalAssignmentMismatch: '"{sourceType}" non \xE8 assegnabile al tipo "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Se la gestione completa non \xE8 prevista, aggiungere "case _: pass"',
         matchIsNotExhaustiveType: 'Tipo non gestito: "{type}"',
         memberAssignment: `L'espressione di tipo "{type}" non pu\xF2 essere assegnata all'attributo "{name}" della classe "{classType}".`,
@@ -23264,6 +23289,7 @@ var require_package_nls_ja = __commonJS({
         kwargsParamMissing: '\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC "**{paramName}" \u306B\u5BFE\u5FDC\u3059\u308B\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u304C\u3042\u308A\u307E\u305B\u3093',
         listAssignmentMismatch: '\u578B "{type}" \u306F\u30BF\u30FC\u30B2\u30C3\u30C8 \u30EA\u30B9\u30C8\u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093',
         literalAssignmentMismatch: '"{sourceType}" \u306F\u578B "{destType}" \u306B\u5272\u308A\u5F53\u3066\u3067\u304D\u307E\u305B\u3093',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u5B8C\u5168\u306A\u51E6\u7406\u304C\u610F\u56F3\u3055\u308C\u3066\u3044\u306A\u3044\u5834\u5408\u306F\u3001"case _: pass" \u3092\u8FFD\u52A0\u3057\u307E\u3059',
         matchIsNotExhaustiveType: '\u30CF\u30F3\u30C9\u30EB\u3055\u308C\u306A\u3044\u578B: "{type}"',
         memberAssignment: '\u578B "{type}" \u306E\u5F0F\u3092\u30AF\u30E9\u30B9 "{classType}" \u306E\u5C5E\u6027 "{name}" \u306B\u5272\u308A\u5F53\u3066\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
@@ -24105,6 +24131,7 @@ var require_package_nls_ko = __commonJS({
         kwargsParamMissing: "\u2018**{paramName}\u2019 \uB9E4\uAC1C \uBCC0\uC218\uC5D0 \uD574\uB2F9\uD558\uB294 \uB9E4\uAC1C \uBCC0\uC218\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.",
         listAssignmentMismatch: '"{type}" \uD615\uC2DD\uC774 \uB300\uC0C1 \uBAA9\uB85D\uACFC \uD638\uD658\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
         literalAssignmentMismatch: '"{sourceType}"\uC740 \uD615\uC2DD "{destType}"\uC5D0 \uD560\uB2F9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\uC804\uCCB4 \uCC98\uB9AC\uAC00 \uC758\uB3C4\uB418\uC9C0 \uC54A\uC740 \uACBD\uC6B0 "case _: pass"\uB97C \uCD94\uAC00\uD569\uB2C8\uB2E4.',
         matchIsNotExhaustiveType: '\uCC98\uB9AC\uB418\uC9C0 \uC54A\uC740 \uD615\uC2DD: "{type}"',
         memberAssignment: '"{type}" \uD615\uC2DD\uC758 \uC2DD\uC744 "{classType}" \uD074\uB798\uC2A4\uC758 "{name}" \uD2B9\uC131\uC5D0 \uD560\uB2F9\uD560 \uC218 \uC5C6\uC74C',
@@ -24946,6 +24973,7 @@ var require_package_nls_pl = __commonJS({
         kwargsParamMissing: "Parametr \u201E**{paramName}\u201D nie ma odpowiadaj\u0105cego mu parametru",
         listAssignmentMismatch: "Typ \u201E{type}\u201D jest niezgodny z list\u0105 docelow\u0105",
         literalAssignmentMismatch: "Nie mo\u017Cna przypisa\u0107 typu \u201E{sourceType}\u201D do typu \u201E{destType}\u201D",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: "Je\u015Bli kompleksowa obs\u0142uga nie jest zamierzona, dodaj \u201Ecase _: pass\u201D",
         matchIsNotExhaustiveType: "Nieobs\u0142ugiwany typ: \u201E{type}\u201D",
         memberAssignment: "Wyra\u017Cenia typu \u201E{type}\u201D nie mo\u017Cna przypisa\u0107 do atrybutu \u201E{name}\u201D klasy \u201E{classType}\u201D",
@@ -25787,6 +25815,7 @@ var require_package_nls_pt_br = __commonJS({
         kwargsParamMissing: 'O par\xE2metro "**{paramName}" n\xE3o tem nenhum par\xE2metro correspondente',
         listAssignmentMismatch: 'O tipo "{type}" \xE9 incompat\xEDvel com a lista de destino',
         literalAssignmentMismatch: '"{sourceType}" n\xE3o pode ser atribu\xEDdo a o tipo"{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Se n\xE3o pretende usar a manipula\xE7\xE3o exaustiva, adicione "case _: pass"',
         matchIsNotExhaustiveType: 'Tipo sem tratamento: "{type}"',
         memberAssignment: 'A express\xE3o do tipo "{type}" n\xE3o pode ser atribu\xEDda ao atributo "{name}" da classe "{classType}"',
@@ -26628,6 +26657,7 @@ var require_package_nls_qps_ploc = __commonJS({
         kwargsParamMissing: '[KHgb2][\u0E19\u0E31\u0E49P\xE6r\xE6m\xEBt\xEBr "**{p\xE6r\xE6m\xD1\xE6m\xEB}" h\xE6s \xF1\xF8 \xE7\xF8rr\xEBsp\xF8\xF1\xF0\xEF\xF1g 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]',
         listAssignmentMismatch: '[fERKI][\u0E19\u0E31\u0E49T\xFFp\xEB "{t\xFFp\xEB}" \xEFs \xEF\xF1\xE7\xF8mp\xE6t\xEF\xFEl\xEB w\xEFth t\xE6rg\xEBt l\xEFst\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         literalAssignmentMismatch: '[17LiQ][\u0E19\u0E31\u0E49"{s\xF8\xB5r\xE7\xEBT\xFFp\xEB}" \xEFs \xF1\xF8t \xE6ss\xEFg\xF1\xE6\xFEl\xEB t\xF8 t\xFFp\xEB "{\xF0\xEBstT\xFFp\xEB}"\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]',
+        literalNotAllowed: '[kRsub][\u0E19\u0E31\u0E49"Literal" sp\xEB\xE7\xEF\xE6l f\xF8rm \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xB5s\xEB\xF0 w\xEFth \xEF\xF1st\xE6\xF1\xE7\xEB \xE6\xF1\xF0 \xE7l\xE6ss \xE7h\xEB\xE7ks\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]',
         matchIsNotExhaustiveHint: '[3NR39][\u0E19\u0E31\u0E49\xCFf \xEBxh\xE6\xB5st\xEFv\xEB h\xE6\xF1\xF0l\xEF\xF1g \xEFs \xF1\xF8t \xEF\xF1t\xEB\xF1\xF0\xEB\xF0, \xE6\xF0\xF0 "case _: pass"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         matchIsNotExhaustiveType: '[9RN1P][\u0E19\u0E31\u0E49\xDC\xF1h\xE6\xF1\xF0l\xEB\xF0 t\xFFp\xEB: "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         memberAssignment: '[1WFCt][\u0E19\u0E31\u0E49\xCBxpr\xEBss\xEF\xF8\xF1 \xF8f t\xFFp\xEB "{t\xFFp\xEB}" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xE6ss\xEFg\xF1\xEB\xF0 t\xF8 \xE6ttr\xEF\xFE\xB5t\xEB "{\xF1\xE6m\xEB}" \xF8f \xE7l\xE6ss "{\xE7l\xE6ssT\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\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -27469,6 +27499,7 @@ var require_package_nls_ru = __commonJS({
         kwargsParamMissing: '\u0423 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430 "**{paramName}" \u043D\u0435\u0442 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044E\u0449\u0435\u0433\u043E \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430',
         listAssignmentMismatch: '\u0422\u0438\u043F "{type}" \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C \u0441 \u0446\u0435\u043B\u0435\u0432\u044B\u043C \u0441\u043F\u0438\u0441\u043A\u043E\u043C',
         literalAssignmentMismatch: '"{sourceType}" \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043D\u0430\u0437\u043D\u0430\u0447\u0438\u0442\u044C \u0442\u0438\u043F "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u0415\u0441\u043B\u0438 \u043D\u0435 \u043F\u0440\u0435\u0434\u043F\u043E\u043B\u0430\u0433\u0430\u0435\u0442\u0441\u044F \u0438\u0441\u0447\u0435\u0440\u043F\u044B\u0432\u0430\u044E\u0449\u0430\u044F \u043E\u0431\u0440\u0430\u0431\u043E\u0442\u043A\u0430, \u0434\u043E\u0431\u0430\u0432\u044C\u0442\u0435 "case _: pass"',
         matchIsNotExhaustiveType: '\u0422\u0438\u043F "{type}" \u043D\u0435 \u043E\u0431\u0440\u0430\u0431\u0430\u0442\u044B\u0432\u0430\u0435\u0442\u0441\u044F',
         memberAssignment: '\u0412\u044B\u0440\u0430\u0436\u0435\u043D\u0438\u0435 \u0442\u0438\u043F\u0430 "{type}" \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D\u043E \u0430\u0442\u0440\u0438\u0431\u0443\u0442\u0443 "{name}" \u043A\u043B\u0430\u0441\u0441\u0430 "{classType}"',
@@ -28310,6 +28341,7 @@ var require_package_nls_tr = __commonJS({
         kwargsParamMissing: '"**{paramName}" parametresine kar\u015F\u0131l\u0131k gelen bir parametre yok',
         listAssignmentMismatch: '"{type}" t\xFCr\xFC hedef listeyle uyumsuz',
         literalAssignmentMismatch: '"{sourceType}" "{destType}" t\xFCr\xFCne atanamaz',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'T\xFCmlemeli i\u015Fleme ama\xE7lanmad\u0131ysa "case _: pass" ekleyin',
         matchIsNotExhaustiveType: '"{type}" t\xFCr\xFC i\u015Flenmemi\u015F',
         memberAssignment: '"{type}" t\xFCr\xFCndeki ifade, "{classType}" s\u0131n\u0131f\u0131n\u0131n "{name}" \xF6zniteli\u011Fine atanamaz',
@@ -29151,6 +29183,7 @@ var require_package_nls_zh_cn = __commonJS({
         kwargsParamMissing: "\u53C2\u6570\u201C**{paramName}\u201D\u6CA1\u6709\u76F8\u5E94\u7684\u53C2\u6570",
         listAssignmentMismatch: "\u7C7B\u578B\u201C{type}\u201D\u4E0E\u76EE\u6807\u5217\u8868\u4E0D\u517C\u5BB9",
         literalAssignmentMismatch: "\u201C{sourceType}\u201D\u4E0D\u53EF\u5206\u914D\u7ED9\u7C7B\u578B\u201C{destType}\u201D",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u5982\u679C\u672A\u8FDB\u884C\u8BE6\u5C3D\u5904\u7406\uFF0C\u8BF7\u6DFB\u52A0"case _: pass"',
         matchIsNotExhaustiveType: '\u672A\u5904\u7406\u7684\u7C7B\u578B: "{type}"',
         memberAssignment: "\u65E0\u6CD5\u5C06\u7C7B\u578B\u201C{type}\u201D\u7684\u8868\u8FBE\u5F0F\u5206\u914D\u7ED9\u7C7B\u201C{classType}\u201D\u7684\u5C5E\u6027\u201C{name}\u201D",
@@ -29992,6 +30025,7 @@ var require_package_nls_zh_tw = __commonJS({
         kwargsParamMissing: '\u53C3\u6578 "**{paramName}" \u6C92\u6709\u5C0D\u61C9\u7684\u53C3\u6578',
         listAssignmentMismatch: '\u985E\u578B "{type}" \u8207\u76EE\u6A19\u6E05\u55AE\u4E0D\u76F8\u5BB9',
         literalAssignmentMismatch: '"{sourceType}" \u7121\u6CD5\u6307\u6D3E\u7D66\u578B\u5225 "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u5982\u679C\u4E0D\u9700\u8981\u5FB9\u5E95\u8655\u7406\uFF0C\u8ACB\u65B0\u589E "case _: pass"',
         matchIsNotExhaustiveType: '\u672A\u8655\u7406\u7684\u985E\u578B: "{type}"',
         memberAssignment: '\u7121\u6CD5\u5C07\u578B\u5225 "{type}" \u7684\u904B\u7B97\u5F0F\u6307\u6D3E\u7D66\u985E\u5225 "{classType}" \u7684\u5C6C\u6027 "{name}"',
@@ -30489,6 +30523,9 @@ var require_localize = __commonJS({
         Diagnostic4.finalClassIsAbstract = () => new ParameterizedString(getRawString("Diagnostic.finalClassIsAbstract"));
         Diagnostic4.finalContext = () => getRawString("Diagnostic.finalContext");
         Diagnostic4.finalInLoop = () => getRawString("Diagnostic.finalInLoop");
+        Diagnostic4.finallyBreak = () => getRawString("Diagnostic.finallyBreak");
+        Diagnostic4.finallyContinue = () => getRawString("Diagnostic.finallyContinue");
+        Diagnostic4.finallyReturn = () => getRawString("Diagnostic.finallyReturn");
         Diagnostic4.finalMethodOverride = () => new ParameterizedString(getRawString("Diagnostic.finalMethodOverride"));
         Diagnostic4.finalNonMethod = () => new ParameterizedString(getRawString("Diagnostic.finalNonMethod"));
         Diagnostic4.finalReassigned = () => new ParameterizedString(getRawString("Diagnostic.finalReassigned"));
@@ -30589,6 +30626,7 @@ var require_localize = __commonJS({
         Diagnostic4.namedParamAfterParamSpecArgs = () => new ParameterizedString(getRawString("Diagnostic.namedParamAfterParamSpecArgs"));
         Diagnostic4.namedTupleEmptyName = () => getRawString("Diagnostic.namedTupleEmptyName");
         Diagnostic4.namedTupleEntryRedeclared = () => new ParameterizedString(getRawString("Diagnostic.namedTupleEntryRedeclared"));
+        Diagnostic4.namedTupleFieldUnderscore = () => getRawString("Diagnostic.namedTupleFieldUnderscore");
         Diagnostic4.namedTupleFirstArg = () => getRawString("Diagnostic.namedTupleFirstArg");
         Diagnostic4.namedTupleMultipleInheritance = () => getRawString("Diagnostic.namedTupleMultipleInheritance");
         Diagnostic4.namedTupleNameKeyword = () => getRawString("Diagnostic.namedTupleNameKeyword");
@@ -30974,6 +31012,7 @@ var require_localize = __commonJS({
         DiagnosticAddendum2.kwargsParamMissing = () => new ParameterizedString(getRawString("DiagnosticAddendum.kwargsParamMissing"));
         DiagnosticAddendum2.listAssignmentMismatch = () => new ParameterizedString(getRawString("DiagnosticAddendum.listAssignmentMismatch"));
         DiagnosticAddendum2.literalAssignmentMismatch = () => new ParameterizedString(getRawString("DiagnosticAddendum.literalAssignmentMismatch"));
+        DiagnosticAddendum2.literalNotAllowed = () => getRawString("DiagnosticAddendum.literalNotAllowed");
         DiagnosticAddendum2.matchIsNotExhaustiveType = () => new ParameterizedString(getRawString("DiagnosticAddendum.matchIsNotExhaustiveType"));
         DiagnosticAddendum2.matchIsNotExhaustiveHint = () => getRawString("DiagnosticAddendum.matchIsNotExhaustiveHint");
         DiagnosticAddendum2.memberAssignment = () => new ParameterizedString(getRawString("DiagnosticAddendum.memberAssignment"));
@@ -35061,12 +35100,22 @@ var require_parseTreeUtils = __commonJS({
       walker.walk(node);
       return foundAwait;
     }
-    function isMatchingExpression(reference, expression) {
+    function isMatchingExpression(reference, expression, compareName) {
       if (reference.nodeType === 38) {
+        let nameToCompare;
         if (expression.nodeType === 38) {
-          return reference.d.value === expression.d.value;
+          nameToCompare = expression;
         } else if (expression.nodeType === 4) {
-          return reference.d.value === expression.d.name.d.value;
+          nameToCompare = expression.d.name;
+        }
+        if (nameToCompare) {
+          if (reference.d.value !== nameToCompare.d.value) {
+            return false;
+          }
+          if (compareName) {
+            return compareName(reference, nameToCompare);
+          }
+          return true;
         }
         return false;
       } else if (reference.nodeType === 35 && expression.nodeType === 35) {
@@ -42460,8 +42509,6 @@ var require_tokenizer = __commonJS({
           switch (prefix) {
             case "rf":
             case "fr":
-            case "ur":
-            case "ru":
             case "br":
             case "rb":
               return 2;
@@ -43674,7 +43721,7 @@ var require_binder = __commonJS({
         var _a;
         const isBuiltInModule = this._fileInfo.builtinsScope === void 0;
         this._addTypingImportAliasesFromBuiltinsScope();
-        const moduleScope = this._createNewScope(
+        this._createNewScope(
           isBuiltInModule ? 5 : 4,
           this._fileInfo.builtinsScope,
           /* proxyScope */
@@ -43701,22 +43748,16 @@ var require_binder = __commonJS({
           }
         );
         this._bindDeferred();
-        if (this._fileInfo.isModulePrivate) {
-          moduleScope.symbolTable.forEach((symbol) => {
-            symbol.setPrivatePyTypedImport();
-          });
-        } else {
-          this._potentialHiddenSymbols.forEach((symbol, name) => {
-            var _a2;
-            if (!((_a2 = this._dunderAllNames) == null ? void 0 : _a2.some((sym) => sym === name))) {
-              if (this._fileInfo.isStubFile) {
-                symbol.setIsExternallyHidden();
-              } else {
-                symbol.setPrivatePyTypedImport();
-              }
+        this._potentialHiddenSymbols.forEach((symbol, name) => {
+          var _a2;
+          if (!((_a2 = this._dunderAllNames) == null ? void 0 : _a2.some((sym) => sym === name))) {
+            if (this._fileInfo.isStubFile) {
+              symbol.setIsExternallyHidden();
+            } else {
+              symbol.setPrivatePyTypedImport();
             }
-          });
-        }
+          }
+        });
         this._potentialPrivateSymbols.forEach((symbol, name) => {
           var _a2;
           if (!((_a2 = this._dunderAllNames) == null ? void 0 : _a2.some((sym) => sym === name))) {
@@ -44409,6 +44450,7 @@ var require_binder = __commonJS({
           this._targetFunctionDeclaration.returnStatements.push(node);
         }
         if (node.d.expr) {
+          AnalyzerNodeInfo.setFlowNode(node.d.expr, this._currentFlowNode);
           this.walk(node.d.expr);
         }
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
@@ -46836,6 +46878,7 @@ var require_types = __commonJS({
     exports2.isUnpacked = isUnpacked;
     exports2.isFunction = isFunction;
     exports2.isOverloaded = isOverloaded;
+    exports2.isFunctionOrOverloaded = isFunctionOrOverloaded;
     exports2.getTypeAliasInfo = getTypeAliasInfo;
     exports2.isTypeSame = isTypeSame;
     exports2.removeUnknownFromUnion = removeUnknownFromUnion;
@@ -48814,6 +48857,9 @@ var require_types = __commonJS({
     function isOverloaded(type) {
       return type.category === 5;
     }
+    function isFunctionOrOverloaded(type) {
+      return type.category === 4 || type.category === 5;
+    }
     function getTypeAliasInfo(type) {
       var _a, _b;
       if ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) {
@@ -50215,7 +50261,10 @@ var require_typeUtils = __commonJS({
         if (type === typeAliasPlaceholder) {
           return true;
         }
-        return (0, types_1.isUnbound)(type) && ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) && type.props.typeAliasInfo.shared.name === ((_b = typeAliasPlaceholder.shared.recursiveAlias) == null ? void 0 : _b.name);
+        if (!(0, types_1.isUnbound)(type) && !isTypeAliasPlaceholder(type)) {
+          return false;
+        }
+        return ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) && type.props.typeAliasInfo.shared.name === ((_b = typeAliasPlaceholder.shared.recursiveAlias) == null ? void 0 : _b.name);
       }
       return (0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeVar)(subtype) && subtype.shared === typeAliasPlaceholder.shared) !== void 0;
     }
@@ -50464,7 +50513,7 @@ var require_typeUtils = __commonJS({
       return (0, types_1.isClassInstance)(type) && types_1.ClassType.isPropertyClass(type);
     }
     function isCallableType(type) {
-      if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type) || (0, types_1.isAnyOrUnknown)(type)) {
+      if ((0, types_1.isFunctionOrOverloaded)(type) || (0, types_1.isAnyOrUnknown)(type)) {
         return true;
       }
       if (isEffectivelyInstantiable(type)) {
@@ -52319,7 +52368,7 @@ var require_typeUtils = __commonJS({
               }
             });
             updatedSourceType = applySolvedTypeVars(sourceType, solution);
-            (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloaded)(updatedSourceType));
+            (0, debug_1.assert)((0, types_1.isFunctionOrOverloaded)(updatedSourceType));
           }
         }
         this._signatureTracker.addSignature(sourceType, this._expressionOffset);
@@ -56965,7 +57014,7 @@ var require_constructors = __commonJS({
         0
         /* MemberAccessFlags.Default */
       )) == null ? void 0 : _a.type;
-      if (!newMethodType || !(0, types_1.isFunction)(newMethodType) && !(0, types_1.isOverloaded)(newMethodType)) {
+      if (!newMethodType || !(0, types_1.isFunctionOrOverloaded)(newMethodType)) {
         return { returnType: (0, typeUtils_1.convertToInstance)(type) };
       }
       return validateNewMethod(
@@ -57104,7 +57153,7 @@ var require_constructors = __commonJS({
         return void 0;
       }
       const callType = evaluator.getTypeOfMember(callInfo);
-      if (!(0, types_1.isFunction)(callType) && !(0, types_1.isOverloaded)(callType)) {
+      if (!(0, types_1.isFunctionOrOverloaded)(callType)) {
         return void 0;
       }
       const boundCallType = evaluator.bindFunctionToClassOrObject(
@@ -57487,6 +57536,10 @@ var require_namedTuples = __commonJS({
             entries.forEach((entryName, index) => {
               entryName = entryName.trim();
               if (entryName) {
+                if (entryName.startsWith("_")) {
+                  evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleFieldUnderscore(), entriesArg.valueExpression);
+                  return;
+                }
                 entryName = renameKeyword(evaluator, entryName, allowRename, entriesArg.valueExpression, index);
                 const entryType = types_1.UnknownType.create();
                 const paramInfo = types_1.FunctionParam.create(0, entryType, types_1.FunctionParamFlags.TypeDeclared, entryName, index >= firstParamWithDefaultIndex ? entryType : void 0);
@@ -57537,6 +57590,10 @@ var require_namedTuples = __commonJS({
                   if (!entryName) {
                     evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleEmptyName(), entryNameNode);
                   } else {
+                    if (entryName.startsWith("_")) {
+                      evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleFieldUnderscore(), entryNameNode);
+                      return;
+                    }
                     entryName = renameKeyword(evaluator, entryName, allowRename, entryNameNode, index);
                   }
                 } else {
@@ -57856,7 +57913,7 @@ var require_dataClasses = __commonJS({
             }
             hasDefault = true;
             defaultExpr = statement.d.rightExpr;
-            if (statement.d.rightExpr.nodeType === 9) {
+            if (!isNamedTuple && statement.d.rightExpr.nodeType === 9) {
               const callTypeResult = evaluator.getTypeOfExpression(
                 statement.d.rightExpr.d.leftExpr,
                 2
@@ -57945,6 +58002,10 @@ var require_dataClasses = __commonJS({
           }
           if (variableNameNode && variableTypeEvaluator) {
             const variableName = variableNameNode.d.value;
+            if (isNamedTuple && variableName.startsWith("_")) {
+              evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleFieldUnderscore(), variableNameNode);
+              return;
+            }
             const variableSymbol = types_1.ClassType.getSymbolTable(classType).get(variableName);
             namedTupleEntries.add(variableName);
             if (variableSymbol == null ? void 0 : variableSymbol.isClassVar()) {
@@ -58026,7 +58087,7 @@ var require_dataClasses = __commonJS({
           if (!statement || statement.nodeType !== 3) {
             return;
           }
-          if (statement.d.rightExpr.nodeType === 9) {
+          if (!isNamedTuple && statement.d.rightExpr.nodeType === 9) {
             const callType = evaluator.getTypeOfExpression(
               statement.d.rightExpr.d.leftExpr,
               2
@@ -58246,7 +58307,7 @@ var require_dataClasses = __commonJS({
       targetFunction.shared.declaredReturnType = fieldType;
       types_1.FunctionType.addParam(targetFunction, types_1.FunctionParam.create(0, typeVar, types_1.FunctionParamFlags.TypeDeclared | types_1.FunctionParamFlags.NameSynthesized, "__input"));
       types_1.FunctionType.addPositionOnlyParamSeparator(targetFunction);
-      if ((0, types_1.isFunction)(converterType) || (0, types_1.isOverloaded)(converterType)) {
+      if ((0, types_1.isFunctionOrOverloaded)(converterType)) {
         const acceptedTypes = [];
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         (0, typeUtils_1.doForEachSignature)(converterType, (signature) => {
@@ -58292,7 +58353,7 @@ var require_dataClasses = __commonJS({
       return fieldType;
     }
     function getConverterAsFunction(evaluator, converterType) {
-      if ((0, types_1.isFunction)(converterType) || (0, types_1.isOverloaded)(converterType)) {
+      if ((0, types_1.isFunctionOrOverloaded)(converterType)) {
         return converterType;
       }
       if ((0, types_1.isClassInstance)(converterType)) {
@@ -58304,7 +58365,7 @@ var require_dataClasses = __commonJS({
           if ((0, types_1.isUnion)(fromConstructor)) {
             fromConstructor = fromConstructor.priv.subtypes[0];
           }
-          if ((0, types_1.isFunction)(fromConstructor) || (0, types_1.isOverloaded)(fromConstructor)) {
+          if ((0, types_1.isFunctionOrOverloaded)(fromConstructor)) {
             return fromConstructor;
           }
         }
@@ -58488,7 +58549,7 @@ var require_dataClasses = __commonJS({
           case "field_descriptors":
           case "field_specifiers": {
             const valueType = evaluator.getTypeOfExpression(arg.d.valueExpr).type;
-            if (!(0, types_1.isClassInstance)(valueType) || !types_1.ClassType.isBuiltIn(valueType, "tuple") || !valueType.priv.tupleTypeArgs || valueType.priv.tupleTypeArgs.some((entry) => !(0, types_1.isInstantiableClass)(entry.type) && !(0, types_1.isFunction)(entry.type) && !(0, types_1.isOverloaded)(entry.type))) {
+            if (!(0, types_1.isClassInstance)(valueType) || !types_1.ClassType.isBuiltIn(valueType, "tuple") || !valueType.priv.tupleTypeArgs || valueType.priv.tupleTypeArgs.some((entry) => !(0, types_1.isInstantiableClass)(entry.type) && !(0, types_1.isFunctionOrOverloaded)(entry.type))) {
               evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformFieldSpecifier().format({
                 type: evaluator.printType(valueType)
               }), arg.d.valueExpr);
@@ -59076,12 +59137,12 @@ var require_typeGuards = __commonJS({
             if (leftExpression.nodeType === 4) {
               leftExpression = leftExpression.d.name;
             }
-            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               return (type) => {
                 return { type: narrowTypeForIsNone(evaluator, type, adjIsPositiveTest), isIncomplete: false };
               };
             }
-            if (leftExpression.nodeType === 27 && ParseTreeUtils.isMatchingExpression(reference, leftExpression.d.leftExpr) && leftExpression.d.items.length === 1 && !leftExpression.d.trailingComma && leftExpression.d.items[0].d.argCategory === 0 && !leftExpression.d.items[0].d.name && leftExpression.d.items[0].d.valueExpr.nodeType === 40 && leftExpression.d.items[0].d.valueExpr.d.isInteger && !leftExpression.d.items[0].d.valueExpr.d.isImaginary) {
+            if (leftExpression.nodeType === 27 && ParseTreeUtils.isMatchingExpression(reference, leftExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr)) && leftExpression.d.items.length === 1 && !leftExpression.d.trailingComma && leftExpression.d.items[0].d.argCategory === 0 && !leftExpression.d.items[0].d.name && leftExpression.d.items[0].d.valueExpr.nodeType === 40 && leftExpression.d.items[0].d.valueExpr.d.isInteger && !leftExpression.d.items[0].d.valueExpr.d.isImaginary) {
               const indexValue = leftExpression.d.items[0].d.valueExpr.d.value;
               if (typeof indexValue === "number") {
                 return (type) => {
@@ -59098,7 +59159,7 @@ var require_typeGuards = __commonJS({
             if (leftExpression.nodeType === 4) {
               leftExpression = leftExpression.d.name;
             }
-            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               return (type) => {
                 return {
                   type: narrowTypeForIsEllipsis(evaluator, testExpression, type, adjIsPositiveTest),
@@ -59110,20 +59171,34 @@ var require_typeGuards = __commonJS({
           if (testExpression.d.leftExpr.nodeType === 9) {
             if (testExpression.d.leftExpr.d.args.length === 1 && testExpression.d.leftExpr.d.args[0].d.argCategory === 0) {
               const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
-              if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+              if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
                 const callType = evaluator.getTypeOfExpression(
                   testExpression.d.leftExpr.d.leftExpr,
                   2
                   /* EvalFlags.CallBaseDefaults */
                 ).type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, "type")) {
-                  const classTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
-                  const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
-                  if ((0, types_1.isInstantiableClass)(classType)) {
+                  const rhsResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
+                  const classTypes = [];
+                  let isClassType = true;
+                  evaluator.mapSubtypesExpandTypeVars(
+                    rhsResult.type,
+                    /* options */
+                    void 0,
+                    (expandedSubtype) => {
+                      if ((0, types_1.isInstantiableClass)(expandedSubtype)) {
+                        classTypes.push(expandedSubtype);
+                      } else {
+                        isClassType = false;
+                      }
+                      return void 0;
+                    }
+                  );
+                  if (isClassType && classTypes.length > 0) {
                     return (type) => {
                       return {
-                        type: narrowTypeForTypeIs(evaluator, type, classType, adjIsPositiveTest),
-                        isIncomplete: !!classTypeResult.isIncomplete
+                        type: narrowTypeForTypeIs(evaluator, type, classTypes, adjIsPositiveTest),
+                        isIncomplete: !!rhsResult.isIncomplete
                       };
                     };
                   }
@@ -59132,7 +59207,7 @@ var require_typeGuards = __commonJS({
             }
           }
           if (isOrIsNotOperator) {
-            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
               const rightType = rightTypeResult.type;
               if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== void 0) {
@@ -59159,7 +59234,7 @@ var require_typeGuards = __commonJS({
                 };
               }
             }
-            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
               const indexType = indexTypeResult.type;
               if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
@@ -59198,7 +59273,7 @@ var require_typeGuards = __commonJS({
           }
           if (equalsOrNotEqualsOperator) {
             const adjIsPositiveTest2 = testExpression.d.operator === 12 ? isPositiveTest : !isPositiveTest;
-            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
               const rightType = rightTypeResult.type;
               if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== void 0) {
@@ -59217,7 +59292,7 @@ var require_typeGuards = __commonJS({
                 };
               }
             }
-            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
               const indexType = indexTypeResult.type;
               if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
@@ -59242,7 +59317,7 @@ var require_typeGuards = __commonJS({
               }
             }
           }
-          if (equalsOrNotEqualsOperator && testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+          if (equalsOrNotEqualsOperator && testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
             const rightType = rightTypeResult.type;
             const memberName = testExpression.d.leftExpr.d.member;
@@ -59257,7 +59332,7 @@ var require_typeGuards = __commonJS({
               }
             }
           }
-          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
             const rightType = rightTypeResult.type;
             const memberName = testExpression.d.leftExpr.d.member;
@@ -59270,7 +59345,7 @@ var require_typeGuards = __commonJS({
               };
             }
           }
-          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr) && testExpression.d.rightExpr.nodeType === 14 && testExpression.d.rightExpr.d.constType === 26) {
+          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr)) && testExpression.d.rightExpr.nodeType === 14 && testExpression.d.rightExpr.d.constType === 26) {
             const memberName = testExpression.d.leftExpr.d.member;
             return (type) => {
               return {
@@ -59282,7 +59357,7 @@ var require_typeGuards = __commonJS({
         }
         if (comparisonOperator && testExpression.d.leftExpr.nodeType === 9 && testExpression.d.leftExpr.d.args.length === 1) {
           const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
-          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const callTypeResult = evaluator.getTypeOfExpression(
               testExpression.d.leftExpr.d.leftExpr,
               2
@@ -59311,7 +59386,7 @@ var require_typeGuards = __commonJS({
           }
         }
         if (testExpression.d.operator === 41 || testExpression.d.operator === 42) {
-          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
             const rightType = rightTypeResult.type;
             const adjIsPositiveTest = testExpression.d.operator === 41 ? isPositiveTest : !isPositiveTest;
@@ -59322,7 +59397,7 @@ var require_typeGuards = __commonJS({
               };
             };
           }
-          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.rightExpr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.rightExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const leftTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr);
             const leftType = leftTypeResult.type;
             if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, "str") && (0, typeUtils_1.isLiteralType)(leftType)) {
@@ -59341,7 +59416,7 @@ var require_typeGuards = __commonJS({
         if (testExpression.d.args.length === 2) {
           const arg0Expr = testExpression.d.args[0].d.valueExpr;
           const arg1Expr = testExpression.d.args[1].d.valueExpr;
-          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const callTypeResult = evaluator.getTypeOfExpression(
               testExpression.d.leftExpr,
               2
@@ -59386,7 +59461,7 @@ var require_typeGuards = __commonJS({
           }
         }
         if (testExpression.d.args.length === 1 && !testExpression.d.args[0].d.name) {
-          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.args[0].d.valueExpr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.args[0].d.valueExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const callTypeResult = evaluator.getTypeOfExpression(
               testExpression.d.leftExpr,
               2
@@ -59405,7 +59480,7 @@ var require_typeGuards = __commonJS({
         }
         if (testExpression.d.args.length >= 1) {
           const arg0Expr = testExpression.d.args[0].d.valueExpr;
-          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             let isPossiblyTypeGuard = false;
             const isFunctionReturnTypeGuard = (type) => {
               return type.shared.declaredReturnType && (0, types_1.isClassInstance)(type.shared.declaredReturnType) && types_1.ClassType.isBuiltIn(type.shared.declaredReturnType, ["TypeGuard", "TypeIs"]);
@@ -59441,7 +59516,7 @@ var require_typeGuards = __commonJS({
           }
         }
       }
-      if (ParseTreeUtils.isMatchingExpression(reference, testExpression)) {
+      if (ParseTreeUtils.isMatchingExpression(reference, testExpression, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
         return (type) => {
           return {
             type: narrowTypeForTruthiness(evaluator, type, isPositiveTest),
@@ -60109,7 +60184,7 @@ var require_typeGuards = __commonJS({
         if ((0, types_1.isClass)(subtype)) {
           return (0, types_1.combineTypes)(filterClassType(unexpandedSubtype, types_1.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
         }
-        if ((0, types_1.isFunction)(subtype) || (0, types_1.isOverloaded)(subtype)) {
+        if ((0, types_1.isFunctionOrOverloaded)(subtype)) {
           return (0, types_1.combineTypes)(filterFunctionType(subtype, unexpandedSubtype));
         }
         return isPositiveTest ? void 0 : negativeFallback;
@@ -60467,37 +60542,48 @@ var require_typeGuards = __commonJS({
         return subtype;
       });
     }
-    function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
-      return evaluator.mapSubtypesExpandTypeVars(
-        type,
-        /* options */
-        void 0,
-        (subtype, unexpandedSubtype) => {
-          var _a;
-          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(types_1.ClassType.cloneAsInstantiable(subtype), classType)) {
-                  return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
+    function narrowTypeForTypeIs(evaluator, type, classTypes, isPositiveTest) {
+      if (!isPositiveTest && classTypes.length > 1) {
+        return type;
+      }
+      const typesToCombine = classTypes.map((classType) => {
+        return evaluator.mapSubtypesExpandTypeVars(
+          type,
+          /* options */
+          void 0,
+          (subtype, unexpandedSubtype) => {
+            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(types_1.ClassType.cloneAsInstantiable(subtype), classType)) {
+                    return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
+                  }
+                  return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_a = subtype.props) == null ? void 0 : _a.condition);
+                }
+                if (!classType.priv.includeSubclasses) {
+                  return void 0;
+                }
+                if (!(0, types_1.isTypeVar)(unexpandedSubtype) || !types_1.TypeVarType.isSelf(unexpandedSubtype)) {
+                  return (0, typeUtils_1.addConditionToType)(subtype, (_b = classType.props) == null ? void 0 : _b.condition);
                 }
-                return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_a = subtype.props) == null ? void 0 : _a.condition);
               }
               if (!classType.priv.includeSubclasses) {
-                return void 0;
-              }
-            } else if (!classType.priv.includeSubclasses) {
-              if (matches && types_1.ClassType.isFinal(subtype)) {
-                return void 0;
+                if (matches && types_1.ClassType.isFinal(subtype)) {
+                  return void 0;
+                }
+                return subtype;
               }
-              return subtype;
             }
-          } else if ((0, types_1.isAnyOrUnknown)(subtype)) {
-            return isPositiveTest ? types_1.ClassType.cloneAsInstance((0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(subtype))) : subtype;
+            if ((0, types_1.isAnyOrUnknown)(subtype)) {
+              return isPositiveTest ? types_1.ClassType.cloneAsInstance((0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(subtype))) : subtype;
+            }
+            return unexpandedSubtype;
           }
-          return unexpandedSubtype;
-        }
-      );
+        );
+      });
+      return (0, types_1.combineTypes)(typesToCombine);
     }
     function narrowTypeForClassComparison(evaluator, referenceType, classType, isPositiveTest) {
       return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
@@ -60632,6 +60718,29 @@ var require_typeGuards = __commonJS({
       }
       return void 0;
     }
+    function isNameSameScope(evaluator, reference, expression) {
+      const refSymbol = evaluator.lookUpSymbolRecursive(
+        reference,
+        reference.d.value,
+        /* honorCodeFlow */
+        false
+      );
+      const exprSymbol = evaluator.lookUpSymbolRecursive(
+        expression,
+        expression.d.value,
+        /* honorCodeFlow */
+        false
+      );
+      if (!refSymbol || !exprSymbol) {
+        return true;
+      }
+      const refScope = refSymbol.scope;
+      const exprScope = exprSymbol.scope;
+      if (refScope === exprScope) {
+        return true;
+      }
+      return (0, scopeUtils_1.isScopeContainedWithin)(refScope, exprScope);
+    }
   }
 });
 
@@ -60898,7 +61007,7 @@ var require_enums = __commonJS({
         if ((0, symbolNameUtils_1.isPrivateName)(memberName)) {
           return void 0;
         }
-        if (!(0, types_1.findSubtype)(valueType, (subtype) => !(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype))) {
+        if (!(0, types_1.findSubtype)(valueType, (subtype) => !(0, types_1.isFunctionOrOverloaded)(subtype))) {
           return void 0;
         }
         if (!assignedType && ((_f = nameNode.parent) == null ? void 0 : _f.nodeType) === 3 && nameNode.parent.d.leftExpr === nameNode) {
@@ -62357,7 +62466,6 @@ var require_importResolver = __commonJS({
           importType: 2,
           isStubFile: false,
           isNativeLib: false,
-          isModulePrivate: false,
           implicitImports: /* @__PURE__ */ new Map(),
           filteredImplicitImports: /* @__PURE__ */ new Map(),
           nonStubImportResult: void 0
@@ -62442,7 +62550,6 @@ var require_importResolver = __commonJS({
         let importType = 0;
         let isLocalTypingsFile = false;
         let isThirdPartyPyTypedPresent = false;
-        const isModulePrivate = false;
         let isTypeshedFile = false;
         const importFailureInfo = [];
         let moduleNameWithInvalidCharacters;
@@ -62461,8 +62568,7 @@ var require_importResolver = __commonJS({
                 importType,
                 isTypeshedFile: true,
                 isLocalTypingsFile,
-                isThirdPartyPyTypedPresent,
-                isModulePrivate
+                isThirdPartyPyTypedPresent
               };
             }
           }
@@ -62561,14 +62667,7 @@ var require_importResolver = __commonJS({
           }
         }
         if (moduleName) {
-          return {
-            moduleName,
-            importType,
-            isTypeshedFile,
-            isLocalTypingsFile,
-            isThirdPartyPyTypedPresent,
-            isModulePrivate
-          };
+          return { moduleName, importType, isTypeshedFile, isLocalTypingsFile, isThirdPartyPyTypedPresent };
         }
         if (allowInvalidModuleName && moduleNameWithInvalidCharacters) {
           return {
@@ -62576,8 +62675,7 @@ var require_importResolver = __commonJS({
             isTypeshedFile,
             importType,
             isLocalTypingsFile,
-            isThirdPartyPyTypedPresent,
-            isModulePrivate
+            isThirdPartyPyTypedPresent
           };
         }
         return {
@@ -62585,8 +62683,7 @@ var require_importResolver = __commonJS({
           isTypeshedFile,
           importType: 2,
           isLocalTypingsFile,
-          isThirdPartyPyTypedPresent,
-          isModulePrivate
+          isThirdPartyPyTypedPresent
         };
       }
       _invalidateFileSystemCache() {
@@ -62610,7 +62707,6 @@ var require_importResolver = __commonJS({
         let implicitImports = /* @__PURE__ */ new Map();
         let packageDirectory;
         let pyTypedInfo;
-        let isModulePrivate = false;
         if (moduleDescriptor.nameParts.length === 0) {
           const pyFilePath = dirPath.initPyUri;
           const pyiFilePath = dirPath.initPyiUri;
@@ -62631,11 +62727,7 @@ var require_importResolver = __commonJS({
           for (let i = 0; i < moduleDescriptor.nameParts.length; i++) {
             const isFirstPart = i === 0;
             const isLastPart = i === moduleDescriptor.nameParts.length - 1;
-            const namePart = moduleDescriptor.nameParts[i];
-            dirPath = dirPath.combinePaths(namePart);
-            if (SymbolNameUtils.isProtectedName(namePart)) {
-              isModulePrivate = true;
-            }
+            dirPath = dirPath.combinePaths(moduleDescriptor.nameParts[i]);
             if (useStubPackage && isFirstPart) {
               dirPath = dirPath.addPath(pathConsts_1.stubsSuffix);
               isStubPackage = true;
@@ -62716,9 +62808,6 @@ var require_importResolver = __commonJS({
         } else {
           importFound = resolvedPaths.length >= moduleDescriptor.nameParts.length;
         }
-        if (!isStubFile && !pyTypedInfo) {
-          isModulePrivate = false;
-        }
         return {
           importName,
           isRelative: false,
@@ -62735,7 +62824,6 @@ var require_importResolver = __commonJS({
           isNativeLib,
           implicitImports,
           pyTypedInfo,
-          isModulePrivate,
           filteredImplicitImports: implicitImports,
           packageDirectory
         };
@@ -65606,7 +65694,7 @@ var require_protocols = __commonJS({
             } else {
               srcMemberType = types_1.UnknownType.create();
             }
-            if ((0, types_1.isFunction)(srcMemberType) || (0, types_1.isOverloaded)(srcMemberType)) {
+            if ((0, types_1.isFunctionOrOverloaded)(srcMemberType)) {
               if (isMemberFromMetaclass || (0, types_1.isInstantiableClass)(srcMemberInfo.classType)) {
                 let isInstanceMember = !srcMemberInfo.symbol.isClassMember();
                 if (types_1.ClassType.isDataClass(srcType)) {
@@ -65651,7 +65739,7 @@ var require_protocols = __commonJS({
             srcMemberType = evaluator.getEffectiveTypeOfSymbol(srcSymbol);
           }
           destMemberType = (0, typeUtils_1.applySolvedTypeVars)(destMemberType, selfSolution);
-          if (!destSymbol.isInstanceMember() && ((0, types_1.isFunction)(destMemberType) || (0, types_1.isOverloaded)(destMemberType))) {
+          if (!destSymbol.isInstanceMember() && (0, types_1.isFunctionOrOverloaded)(destMemberType)) {
             let boundDeclaredType;
             isDestReadOnly = true;
             if ((0, types_1.isClass)(srcType)) {
@@ -67372,7 +67460,7 @@ var require_codeFlowEngine = __commonJS({
               }
               const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluator2, node, callSubtype);
               if (newMethodResult) {
-                if ((0, types_1.isFunction)(newMethodResult.type) || (0, types_1.isOverloaded)(newMethodResult.type)) {
+                if ((0, types_1.isFunctionOrOverloaded)(newMethodResult.type)) {
                   callSubtype = newMethodResult.type;
                 }
               }
@@ -68864,7 +68952,7 @@ var require_operations = __commonJS({
       return true;
     }
     function convertFunctionToObject(evaluator, type) {
-      if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type)) {
+      if ((0, types_1.isFunctionOrOverloaded)(type)) {
         return evaluator.getObjectType();
       }
       return type;
@@ -71260,9 +71348,10 @@ var require_typeEvaluator = __commonJS({
           false
         ) : void 0;
         const exprTypeResult = getTypeOfExpression(node.d.expr, flags, (0, typeUtils_1.makeInferenceContext)(expectedType));
+        const awaitableResult = getTypeOfAwaitable(exprTypeResult, node.d.expr);
         const typeResult = {
-          type: getTypeOfAwaitable(exprTypeResult.type, node.d.expr),
-          isIncomplete: exprTypeResult.isIncomplete,
+          type: awaitableResult.type,
+          isIncomplete: exprTypeResult.isIncomplete || awaitableResult.isIncomplete,
           typeErrors: exprTypeResult.typeErrors
         };
         if (exprTypeResult.isIncomplete) {
@@ -71895,7 +71984,7 @@ var require_typeEvaluator = __commonJS({
         if (!boundMethodResult || boundMethodResult.typeErrors) {
           return void 0;
         }
-        if ((0, types_1.isFunction)(boundMethodResult.type) || (0, types_1.isOverloaded)(boundMethodResult.type)) {
+        if ((0, types_1.isFunctionOrOverloaded)(boundMethodResult.type)) {
           return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
@@ -71995,7 +72084,7 @@ var require_typeEvaluator = __commonJS({
                 const constructorType = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, subtype);
                 if (constructorType) {
                   (0, typeUtils_1.doForEachSubtype)(constructorType, (subtype2) => {
-                    if ((0, types_1.isFunction)(subtype2) || (0, types_1.isOverloaded)(subtype2)) {
+                    if ((0, types_1.isFunctionOrOverloaded)(subtype2)) {
                       addFunctionToSignature(subtype2);
                     }
                   });
@@ -72120,29 +72209,36 @@ var require_typeEvaluator = __commonJS({
             ).type;
             const baseTypeConcrete = makeTopLevelTypeVarsConcrete(baseType);
             let classMemberInfo;
-            if ((0, types_1.isClassInstance)(baseTypeConcrete)) {
-              classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(
-                baseTypeConcrete,
-                expression.d.member.d.value,
-                64
-                /* MemberAccessFlags.DeclaredTypesOnly */
-              );
-              classOrObjectBase = baseTypeConcrete;
-              memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
-              if (classMemberInfo == null ? void 0 : classMemberInfo.isInstanceMember) {
-                bindFunction = false;
-              }
-              useDescriptorSetterType = true;
-            } else if ((0, types_1.isInstantiableClass)(baseTypeConcrete)) {
-              classMemberInfo = (0, typeUtils_1.lookUpClassMember)(
-                baseTypeConcrete,
-                expression.d.member.d.value,
-                16 | 64
-                /* MemberAccessFlags.DeclaredTypesOnly */
-              );
-              classOrObjectBase = baseTypeConcrete;
-              memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
-            }
+            (0, typeUtils_1.doForEachSubtype)(
+              baseTypeConcrete,
+              (baseSubtype) => {
+                if ((0, types_1.isClassInstance)(baseSubtype)) {
+                  classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(
+                    baseSubtype,
+                    expression.d.member.d.value,
+                    64
+                    /* MemberAccessFlags.DeclaredTypesOnly */
+                  );
+                  classOrObjectBase = baseSubtype;
+                  memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
+                  if (classMemberInfo == null ? void 0 : classMemberInfo.isInstanceMember) {
+                    bindFunction = false;
+                  }
+                  useDescriptorSetterType = true;
+                } else if ((0, types_1.isInstantiableClass)(baseSubtype)) {
+                  classMemberInfo = (0, typeUtils_1.lookUpClassMember)(
+                    baseSubtype,
+                    expression.d.member.d.value,
+                    16 | 64
+                    /* MemberAccessFlags.DeclaredTypesOnly */
+                  );
+                  classOrObjectBase = baseSubtype;
+                  memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
+                }
+              },
+              /* sortSubtypes */
+              true
+            );
             if ((0, types_1.isTypeVar)(baseType)) {
               selfType = baseType;
             }
@@ -72209,7 +72305,7 @@ var require_typeEvaluator = __commonJS({
               if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
                 declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType(), selfType);
               }
-              if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloaded)(declaredType)) {
+              if ((0, types_1.isFunctionOrOverloaded)(declaredType)) {
                 if (bindFunction) {
                   declaredType = bindFunctionToClassOrObject(
                     classOrObjectBase,
@@ -72228,12 +72324,13 @@ var require_typeEvaluator = __commonJS({
         }
         return void 0;
       }
-      function getTypeOfAwaitable(type, errorNode) {
+      function getTypeOfAwaitable(typeResult, errorNode) {
         if (!(prefetched == null ? void 0 : prefetched.awaitableClass) || !(0, types_1.isInstantiableClass)(prefetched.awaitableClass) || prefetched.awaitableClass.shared.typeParams.length !== 1) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create(), isIncomplete: typeResult.isIncomplete };
         }
         const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(prefetched.awaitableClass);
-        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        const isIncomplete = !!typeResult.isIncomplete;
+        const type = (0, typeUtils_1.mapSubtypes)(typeResult.type, (subtype) => {
           subtype = makeTopLevelTypeVarsConcrete(subtype);
           if ((0, types_1.isAnyOrUnknown)(subtype)) {
             return subtype;
@@ -72249,16 +72346,18 @@ var require_typeEvaluator = __commonJS({
               return types_1.UnknownType.create();
             }
           }
-          if (errorNode) {
+          if (errorNode && !typeResult.isIncomplete) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotAwaitable().format({ type: printType(subtype) }) + (diag == null ? void 0 : diag.getString()), errorNode);
           }
           return types_1.UnknownType.create();
         });
+        return { type, isIncomplete };
       }
       function getTypeOfIterator(typeResult, isAsync, errorNode, emitNotIterableError = true) {
         const iterMethodName = isAsync ? "__aiter__" : "__iter__";
         const nextMethodName = isAsync ? "__anext__" : "__next__";
         let isValidIterator = true;
+        let isIncomplete = typeResult.isIncomplete;
         let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
         type = makeTopLevelTypeVarsConcrete(type);
         type = (0, types_1.removeUnbound)(type);
@@ -72319,7 +72418,11 @@ var require_typeEvaluator = __commonJS({
                     if (!isAsync) {
                       return nextReturnType;
                     }
-                    return getTypeOfAwaitable(nextReturnType, errorNode);
+                    const awaitableResult = getTypeOfAwaitable({ type: nextReturnType, isIncomplete: typeResult.isIncomplete }, errorNode);
+                    if (awaitableResult.isIncomplete) {
+                      isIncomplete = true;
+                    }
+                    return awaitableResult.type;
                   }
                   return void 0;
                 }
@@ -72330,13 +72433,13 @@ var require_typeEvaluator = __commonJS({
               diag.addAddendum(iterReturnTypeDiag);
             }
           }
-          if (!typeResult.isIncomplete && emitNotIterableError) {
+          if (!isIncomplete && emitNotIterableError) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
           }
           isValidIterator = false;
           return void 0;
         });
-        return isValidIterator ? { type: iterableType, isIncomplete: typeResult.isIncomplete } : void 0;
+        return isValidIterator ? { type: iterableType, isIncomplete } : void 0;
       }
       function getTypeOfIterable(typeResult, isAsync, errorNode, emitNotIterableError = true) {
         const iterMethodName = isAsync ? "__aiter__" : "__iter__";
@@ -72725,7 +72828,7 @@ var require_typeEvaluator = __commonJS({
           }
         }
         if (!typeResult.isIncomplete) {
-          reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
+          reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, typeResult.type, nameNode, ignoreEmptyContainers);
         }
         writeTypeCache(
           nameNode,
@@ -73272,26 +73375,11 @@ var require_typeEvaluator = __commonJS({
             break;
           }
           case 54: {
-            let annotationType = getTypeOfAnnotation(target.d.annotation, {
+            getTypeOfAnnotation(target.d.annotation, {
               varTypeAnnotation: true,
               allowFinal: isFinalAllowedForAssignmentTarget(target.d.valueExpr),
               allowClassVar: 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");
-              if (!isTypeAliasAnnotation) {
-                if (assignType(annotationType, typeResult.type)) {
-                  if (!(0, types_1.isClassInstance)(typeResult.type) || !types_1.ClassType.isEnumClass(typeResult.type)) {
-                    typeResult = narrowTypeBasedOnAssignment(annotationType, typeResult);
-                  }
-                }
-              }
-            }
             assignTypeToExpression(target.d.valueExpr, typeResult, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
             break;
           }
@@ -74390,7 +74478,7 @@ var require_typeEvaluator = __commonJS({
             (0, debug_1.assertNever)(baseType);
         }
         if (!type) {
-          const isFunctionRule = (0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType) || (0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, "function");
+          const isFunctionRule = (0, types_1.isFunctionOrOverloaded)(baseType) || (0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, "function");
           if (!baseTypeResult.isIncomplete) {
             let diagMessage = localize_1.LocMessage.memberAccess();
             if (usage.method === "set") {
@@ -74398,7 +74486,7 @@ var require_typeEvaluator = __commonJS({
             } else if (usage.method === "del") {
               diagMessage = localize_1.LocMessage.memberDelete();
             }
-            if (usage.setExpectedTypeDiag) {
+            if (usage.setExpectedTypeDiag && !usage.setExpectedTypeDiag.isEmpty()) {
               diag = usage.setExpectedTypeDiag;
             }
             if ((0, types_1.isClass)(baseType) && baseType.shared.typedDictEntries) {
@@ -74560,7 +74648,7 @@ var require_typeEvaluator = __commonJS({
               isDescriptorApplied = true;
             }
             resultType = descResult.type;
-          } else if ((0, types_1.isFunction)(concreteSubtype) || (0, types_1.isOverloaded)(concreteSubtype)) {
+          } else if ((0, types_1.isFunctionOrOverloaded)(concreteSubtype) && types_1.TypeBase.isInstance(concreteSubtype)) {
             const typeResult = bindMethodForMemberAccess(subtype, concreteSubtype, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount);
             resultType = typeResult.type;
             if (typeResult.typeErrors) {
@@ -74589,7 +74677,7 @@ var require_typeEvaluator = __commonJS({
             isDescriptorError = true;
           }
           return resultType;
-        });
+        }, { retainTypeAlias: true });
         if (!isDescriptorError && usage.method === "set" && usage.setType) {
           if (errorNode && memberInfo.symbol.hasTypedDeclarations()) {
             narrowedTypeForSet = isDescriptorApplied ? usage.setType.type : narrowTypeBasedOnAssignment(type, usage.setType).type;
@@ -74666,7 +74754,7 @@ var require_typeEvaluator = __commonJS({
           }
           return { type: types_1.UnknownType.create(), typeErrors: true };
         }
-        if (!(0, types_1.isFunction)(methodType) && !(0, types_1.isOverloaded)(methodType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(methodType)) {
           if ((0, types_1.isAnyOrUnknown)(methodType)) {
             return { type: methodType };
           }
@@ -74698,7 +74786,7 @@ var require_typeEvaluator = __commonJS({
             );
             accessMethodClass = solveAndApplyConstraints(accessMethodClass, constraints);
             const specializedType = (0, typeUtils_1.partiallySpecializeType)(methodType, accessMethodClass, getTypeClassType(), selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : classType);
-            if ((0, types_1.isFunction)(specializedType) || (0, types_1.isOverloaded)(specializedType)) {
+            if ((0, types_1.isFunctionOrOverloaded)(specializedType)) {
               methodType = specializedType;
             }
           }
@@ -74951,7 +75039,7 @@ var require_typeEvaluator = __commonJS({
             }
           });
         }
-        if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloaded)(accessMemberType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(accessMemberType)) {
           if ((0, types_1.isAnyOrUnknown)(accessMemberType)) {
             return { type: accessMemberType };
           }
@@ -75054,13 +75142,25 @@ var require_typeEvaluator = __commonJS({
       function adjustTypeArgsForTypeVarTuple(typeArgs, typeParams, errorNode) {
         const variadicIndex = typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
         let srcUnboundedTupleType;
-        let srcUnboundedTupleIndex = typeArgs.findIndex((arg) => {
-          if ((0, types_1.isUnpackedClass)(arg.type) && arg.type.priv.tupleTypeArgs && arg.type.priv.tupleTypeArgs.length === 1 && arg.type.priv.tupleTypeArgs[0].isUnbounded) {
-            srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
-            return true;
+        const findUnboundedTupleIndex = (startArgIndex) => {
+          return typeArgs.findIndex((arg, index) => {
+            if (index < startArgIndex) {
+              return false;
+            }
+            if ((0, types_1.isUnpackedClass)(arg.type) && arg.type.priv.tupleTypeArgs && arg.type.priv.tupleTypeArgs.length === 1 && arg.type.priv.tupleTypeArgs[0].isUnbounded) {
+              srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
+              return true;
+            }
+            return false;
+          });
+        };
+        let srcUnboundedTupleIndex = findUnboundedTupleIndex(0);
+        if (srcUnboundedTupleIndex >= 0) {
+          const secondUnboundedTupleIndex = findUnboundedTupleIndex(srcUnboundedTupleIndex + 1);
+          if (secondUnboundedTupleIndex >= 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), typeArgs[secondUnboundedTupleIndex].node);
           }
-          return false;
-        });
+        }
         if (srcUnboundedTupleType && srcUnboundedTupleIndex >= 0 && variadicIndex >= 0 && typeArgs.length < typeParams.length) {
           while (variadicIndex > srcUnboundedTupleIndex) {
             typeArgs = [
@@ -78367,7 +78467,7 @@ var require_typeEvaluator = __commonJS({
           returnType = types_1.TypeBase.cloneForCondition(returnType, condition);
         }
         let eliminateUnsolvedInUnions = true;
-        if ((0, types_1.isFunction)(returnType) || (0, types_1.isOverloaded)(returnType)) {
+        if ((0, types_1.isFunctionOrOverloaded)(returnType)) {
           eliminateUnsolvedInUnions = false;
         }
         let specializedReturnType = solveAndApplyConstraints(returnType, constraints, {
@@ -81066,7 +81166,6 @@ var require_typeEvaluator = __commonJS({
             };
             let reportedUnpackedError = false;
             typeArgs.forEach((typeArg, index) => {
-              var _a;
               (0, debug_1.assert)(typeArgs !== void 0);
               if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                 if (!isTupleTypeParam) {
@@ -81089,7 +81188,7 @@ var require_typeEvaluator = __commonJS({
                 }
                 validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node);
               } else if (paramLimit === void 0 && (0, types_1.isUnpackedClass)(typeArg.type)) {
-                if ((_a = typeArg.type.priv.tupleTypeArgs) == null ? void 0 : _a.some((typeArg2) => (0, types_1.isTypeVarTuple)(typeArg2.type) || typeArg2.isUnbounded)) {
+                if ((0, typeUtils_1.isUnboundedTupleClass)(typeArg.type)) {
                   noteSawUnpacked(typeArg);
                 }
                 validateTypeArg(typeArg, { allowUnpackedTuples: true });
@@ -83078,7 +83177,7 @@ var require_typeEvaluator = __commonJS({
           inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
         } else {
           let skipInference = false;
-          if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloaded)(defaultValueType)) {
+          if ((0, types_1.isFunctionOrOverloaded)(defaultValueType)) {
             skipInference = true;
           } else if ((0, types_1.isClassInstance)(defaultValueType) && types_1.ClassType.isBuiltIn(defaultValueType, ["tuple", "list", "set", "dict"])) {
             skipInference = true;
@@ -83446,6 +83545,7 @@ var require_typeEvaluator = __commonJS({
           return;
         }
         const exprTypeResult = getTypeOfExpression(node.d.expr);
+        let isIncomplete = exprTypeResult.isIncomplete;
         let exprType = exprTypeResult.type;
         const isAsync = node.parent && node.parent.nodeType === 58 && !!node.parent.d.isAsync;
         if ((0, typeUtils_1.isOptionalType)(exprType)) {
@@ -83471,7 +83571,17 @@ var require_typeEvaluator = __commonJS({
               enterDiag.createAddendum()
             );
             if (enterTypeResult) {
-              return isAsync ? getTypeOfAwaitable(enterTypeResult.type, node.d.expr) : enterTypeResult.type;
+              if (isAsync) {
+                if (enterTypeResult.isIncomplete) {
+                  isIncomplete = true;
+                }
+                const asyncResult = getTypeOfAwaitable({ type: enterTypeResult.type }, node.d.expr);
+                if (asyncResult.isIncomplete) {
+                  isIncomplete = true;
+                }
+                return asyncResult.type;
+              }
+              return enterTypeResult.type;
             }
             if (!isAsync) {
               if ((_a = getTypeOfMagicMethodCall(
@@ -83509,18 +83619,28 @@ var require_typeEvaluator = __commonJS({
               exitDiag
             );
             if (exitTypeResult) {
-              return isAsync ? getTypeOfAwaitable(exitTypeResult.type, node.d.expr) : exitTypeResult.type;
+              if (exitTypeResult.isIncomplete) {
+                isIncomplete = true;
+              }
+              if (isAsync) {
+                const asyncResult = getTypeOfAwaitable({ type: exitTypeResult.type }, node.d.expr);
+                if (asyncResult.isIncomplete) {
+                  isIncomplete = true;
+                }
+                return asyncResult.type;
+              }
+              return exitTypeResult.type;
             }
           }
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotUsableWith().format({ type: printType(subtype), method: exitMethodName }) + exitDiag.getString(), node.d.expr);
           return types_1.UnknownType.create();
         });
         if (node.d.target) {
-          assignTypeToExpression(node.d.target, { type: scopedType, isIncomplete: exprTypeResult.isIncomplete }, node.d.target);
+          assignTypeToExpression(node.d.target, { type: scopedType, isIncomplete }, node.d.target);
         }
         writeTypeCache(
           node,
-          { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete },
+          { type: scopedType, isIncomplete },
           0
           /* EvalFlags.None */
         );
@@ -84466,7 +84586,7 @@ var require_typeEvaluator = __commonJS({
         if (fileInfo.isStubFile || pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_9) || (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(errorNode)) || (flags & 4) !== 0) {
           if (types_1.ClassType.isBuiltIn(classType, "type") && typeArgs) {
             if (typeArgs.length >= 1) {
-              if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloaded)(typeArgs[0].type)) {
+              if ((0, types_1.isFunctionOrOverloaded)(typeArgs[0].type)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
                 return { type: types_1.UnknownType.create() };
               }
@@ -84967,7 +85087,7 @@ var require_typeEvaluator = __commonJS({
         if (!tracker) {
           return type;
         }
-        if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type)) {
+        if ((0, types_1.isFunctionOrOverloaded)(type)) {
           return (0, typeUtils_1.ensureSignaturesAreUnique)(type, tracker, node.start);
         }
         return type;
@@ -86262,9 +86382,9 @@ var require_typeEvaluator = __commonJS({
           typeResult.type = validateSymbolIsTypeExpression(errorNode, typeResult.type, !!typeResult.includesVariableDecl);
         }
         inferReturnTypeIfNecessary(typeResult.type);
-        if (errorNode && selfClass && (0, types_1.isClass)(selfClass) && member.isInstanceMember && (0, types_1.isClass)(member.unspecializedClassType) && (flags & 1024) !== 0 && (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
+        if (errorNode && selfClass && (0, types_1.isClass)(selfClass) && !selfClass.priv.includeSubclasses && member.isInstanceMember && (0, types_1.isClass)(member.unspecializedClassType) && (flags & 1024) !== 0 && (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
           const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, getTypeClassType(), (0, typeUtils_1.selfSpecializeClass)(selfClass, { overrideTypeArgs: true }));
-          if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype) && (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
+          if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunctionOrOverloaded)(subtype) && (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
           }
         }
@@ -86951,7 +87071,7 @@ var require_typeEvaluator = __commonJS({
               return false;
             }
             return true;
-          } else if ((0, types_1.isFunction)(concreteSrcType) || (0, types_1.isOverloaded)(concreteSrcType)) {
+          } else if ((0, types_1.isFunctionOrOverloaded)(concreteSrcType)) {
             const destCallbackType = getCallbackProtocolType(destType, recursionCount);
             if (destCallbackType) {
               return assignType(destCallbackType, concreteSrcType, diag, constraints, flags, recursionCount);
@@ -86976,21 +87096,20 @@ var require_typeEvaluator = __commonJS({
             }
             const metaclass = concreteSrcType.shared.effectiveMetaclass;
             if (metaclass) {
-              if ((0, types_1.isAnyOrUnknown)(metaclass)) {
-                return true;
-              }
-              if (assignClass(
-                types_1.ClassType.cloneAsInstantiable(destType),
-                metaclass,
-                /* diag */
-                void 0,
-                constraints,
-                flags,
-                recursionCount,
-                /* reportErrorsUsingObjType */
-                true
-              )) {
-                return true;
+              if (!(0, types_1.isAnyOrUnknown)(metaclass)) {
+                if (assignClass(
+                  types_1.ClassType.cloneAsInstantiable(destType),
+                  metaclass,
+                  /* diag */
+                  void 0,
+                  constraints,
+                  flags,
+                  recursionCount,
+                  /* reportErrorsUsingObjType */
+                  true
+                )) {
+                  return true;
+                }
               }
             }
           } else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !((_j = concreteSrcType.props) == null ? void 0 : _j.specialForm)) {
@@ -87247,10 +87366,8 @@ var require_typeEvaluator = __commonJS({
                   }
                 }
               }
-              if ((0, types_1.isFunction)(srcSubtype) || (0, types_1.isOverloaded)(srcSubtype)) {
-                if ((0, types_1.isFunction)(destSubtype) || (0, types_1.isOverloaded)(destSubtype)) {
-                  return true;
-                }
+              if ((0, types_1.isFunctionOrOverloaded)(srcSubtype) && (0, types_1.isFunctionOrOverloaded)(destSubtype)) {
+                return true;
               }
               return false;
             });
@@ -87452,10 +87569,10 @@ var require_typeEvaluator = __commonJS({
         if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
           return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
         }
-        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
-        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
-        if (isLeftCallable !== isRightCallable) {
-          return false;
+        const isLeftCallable = (0, types_1.isFunctionOrOverloaded)(leftType);
+        const isRightCallable = (0, types_1.isFunctionOrOverloaded)(rightType);
+        if (isLeftCallable || isRightCallable) {
+          return true;
         }
         if ((0, types_1.isInstantiableClass)(leftType) || (0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, "type")) {
           if ((0, types_1.isInstantiableClass)(rightType) || (0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, "type")) {
@@ -88336,7 +88453,7 @@ var require_typeEvaluator = __commonJS({
                 return assignedSubtype;
               }
               if ((0, types_1.isClassInstance)(declaredSubtype) && types_1.ClassType.isProtocolClass(declaredSubtype)) {
-                if ((0, types_1.isFunction)(assignedSubtype) || (0, types_1.isOverloaded)(assignedSubtype)) {
+                if ((0, types_1.isFunctionOrOverloaded)(assignedSubtype)) {
                   return assignedSubtype;
                 }
               }
@@ -88357,7 +88474,7 @@ var require_typeEvaluator = __commonJS({
         return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
       }
       function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
-        if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloaded)(baseMethod)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(baseMethod)) {
           diag.addMessage(localize_1.LocAddendum.overrideType().format({ type: printType(baseMethod) }));
           return false;
         }
@@ -88884,7 +89001,7 @@ var require_typeEvaluator = __commonJS({
               constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType) ? (0, typeUtils_1.convertToInstance)(firstParamType) : firstParamType);
             } else {
               const subDiag = diag == null ? void 0 : diag.createAddendum();
-              if ((0, types_1.isFunction)(memberTypeFirstParamType) || (0, types_1.isOverloaded)(memberTypeFirstParamType)) {
+              if ((0, types_1.isFunctionOrOverloaded)(memberTypeFirstParamType)) {
                 if ((0, types_1.isClassInstance)(firstParamType) && types_1.ClassType.isProtocolClass(firstParamType)) {
                   if (subDiag) {
                     subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
@@ -90413,7 +90530,7 @@ var require_checker = __commonJS({
         let isCoroutine = true;
         (0, typeUtils_1.doForEachSubtype)(exprTypeResult.type, (subtype) => {
           subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-          if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype)) {
+          if (!(0, types_1.isFunctionOrOverloaded)(subtype)) {
             isExprFunction = false;
           }
           if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, ["Coroutine", "CoroutineType"])) {
@@ -91816,7 +91933,7 @@ var require_checker = __commonJS({
       _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {
         let isSupported = true;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-          var _a, _b;
+          var _a, _b, _c;
           subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
           subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
           if (((_a = subtype.props) == null ? void 0 : _a.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, "TypeAliasType")) {
@@ -91857,6 +91974,9 @@ var require_checker = __commonJS({
               } else if (((_b = subtype.props) == null ? void 0 : _b.specialForm) && (0, types_1.isClassInstance)(subtype.props.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, "Annotated")) {
                 diag.addMessage(localize_1.LocAddendum.annotatedNotAllowed());
                 isSupported = false;
+              } else if (((_c = subtype.props) == null ? void 0 : _c.specialForm) && (0, types_1.isInstantiableClass)(subtype.props.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, "Literal")) {
+                diag.addMessage(localize_1.LocAddendum.literalNotAllowed());
+                isSupported = false;
               }
               break;
             case 4:
@@ -92837,7 +92957,7 @@ var require_checker = __commonJS({
           return;
         }
         let newMemberType = newMethodResult.type;
-        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloaded)(newMemberType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(newMemberType)) {
           return;
         }
         if ((0, types_1.isOverloaded)(newMemberType)) {
@@ -92847,7 +92967,7 @@ var require_checker = __commonJS({
           }
         }
         let initMemberType = initMethodResult.type;
-        if (!(0, types_1.isFunction)(initMemberType) && !(0, types_1.isOverloaded)(initMemberType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(initMemberType)) {
           return;
         }
         if ((0, types_1.isOverloaded)(initMemberType)) {
@@ -93018,9 +93138,9 @@ var require_checker = __commonJS({
         let diag;
         const overrideDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideClassAndSymbol.symbol);
         const overriddenDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overriddenClassAndSymbol.symbol);
-        if ((0, types_1.isFunction)(overriddenType) || (0, types_1.isOverloaded)(overriddenType)) {
+        if ((0, types_1.isFunctionOrOverloaded)(overriddenType)) {
           const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-          if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloaded)(overrideType)) {
+          if ((0, types_1.isFunctionOrOverloaded)(overrideType)) {
             if (!this._evaluator.validateOverrideMethod(
               overriddenType,
               overrideType,
@@ -93475,15 +93595,15 @@ var require_checker = __commonJS({
           return;
         }
         const baseClass = baseClassAndSymbol.classType;
-        const baseClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(baseClass, { useBoundTypeVars: true }));
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType, { useBoundTypeVars: true }));
+        const baseClassSelf = types_1.ClassType.isProtocolClass(baseClass) ? childClassSelf : types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(baseClass, { useBoundTypeVars: true }));
         let baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), baseClassSelf);
         overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, this._evaluator.getTypeClassType(), childClassSelf);
         if (childClassType.shared.typeVarScopeId) {
           overrideType = (0, typeUtils_1.makeTypeVarsBound)(overrideType, [childClassType.shared.typeVarScopeId]);
           baseType = (0, typeUtils_1.makeTypeVarsBound)(baseType, [childClassType.shared.typeVarScopeId]);
         }
-        if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType)) {
+        if ((0, types_1.isFunctionOrOverloaded)(baseType)) {
           const diagAddendum = new diagnostic_1.DiagnosticAddendum();
           if (this._isFinalFunction(memberName, baseType)) {
             const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
@@ -93501,7 +93621,7 @@ var require_checker = __commonJS({
           if (this._isMethodExemptFromLsp(memberName) || SymbolNameUtils.isPrivateName(memberName) || types_1.ClassType.isTypedDictClass(childClassType)) {
             return;
           }
-          if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloaded)(overrideType)) {
+          if ((0, types_1.isFunctionOrOverloaded)(overrideType)) {
             const enforceParamNameMatch = !SymbolNameUtils.isDunderName(memberName);
             if (this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
               return;
@@ -94602,7 +94722,7 @@ var require_sourceFile = __commonJS({
       }
     };
     var SourceFile = class {
-      constructor(serviceProvider, uri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, isModulePrivate, editMode, console2, logTracker, ipythonMode) {
+      constructor(serviceProvider, uri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, editMode, console2, logTracker, ipythonMode) {
         this.serviceProvider = serviceProvider;
         this._diagnosticRuleSet = (0, configOptions_1.getBasicDiagnosticRuleSet)();
         this._ipythonMode = IPythonMode.None;
@@ -94616,7 +94736,6 @@ var require_sourceFile = __commonJS({
         this._isStubFile = uri.hasExtension(".pyi");
         this._isThirdPartyImport = isThirdPartyImport;
         this._isThirdPartyPyTypedPresent = isThirdPartyPyTypedPresent;
-        this._isModulePrivate = isModulePrivate;
         const fileName = uri.fileName;
         this._isTypingStubFile = this._isStubFile && (this._uri.pathEndsWith("stdlib/typing.pyi") || fileName === "typing_extensions.pyi");
         this._isTypingExtensionsStubFile = this._isStubFile && fileName === "typing_extensions.pyi";
@@ -94926,7 +95045,8 @@ var require_sourceFile = __commonJS({
               importedModules: [],
               futureImports: /* @__PURE__ */ new Set(),
               containsWildcardImport: false,
-              typingSymbolAliases: /* @__PURE__ */ new Map()
+              typingSymbolAliases: /* @__PURE__ */ new Map(),
+              hasTypeAnnotations: false
             };
             this._writableData.tokenizerLines = new textRangeCollection_1.TextRangeCollection([]);
             this._writableData.tokenizerOutput = {
@@ -95280,7 +95400,6 @@ var require_sourceFile = __commonJS({
           isTypeshedStubFile: this._isTypeshedStubFile,
           isBuiltInStubFile: this._isBuiltInStubFile,
           isInPyTypedPackage: this._isThirdPartyPyTypedPresent,
-          isModulePrivate: this._isModulePrivate,
           ipythonMode: this._ipythonMode,
           accessedSymbolSet: /* @__PURE__ */ new Set()
         };
@@ -95463,6 +95582,8 @@ var require_parser = __commonJS({
         this._isParsingTypeAnnotation = false;
         this._isParsingIndexTrailer = false;
         this._isParsingQuotedText = false;
+        this._isInFinallyBlock = false;
+        this._isInFinallyLoop = false;
         this._futureImports = /* @__PURE__ */ new Set();
         this._importedModules = [];
         this._containsWildcardImport = false;
@@ -95470,8 +95591,10 @@ var require_parser = __commonJS({
         this._typingImportAliases = [];
         this._typingSymbolAliases = /* @__PURE__ */ new Map();
         this._maxChildDepthMap = /* @__PURE__ */ new Map();
+        this._hasTypeAnnotations = false;
       }
       parseSourceFile(fileContents, parseOptions, diagSink) {
+        this._hasTypeAnnotations = false;
         timing_1.timingStats.tokenizeFileTime.timeOperation(() => {
           this._startNewParse(fileContents, 0, fileContents.length, parseOptions, diagSink);
         });
@@ -95513,7 +95636,8 @@ var require_parser = __commonJS({
             importedModules: this._importedModules,
             futureImports: this._futureImports,
             containsWildcardImport: this._containsWildcardImport,
-            typingSymbolAliases: this._typingSymbolAliases
+            typingSymbolAliases: this._typingSymbolAliases,
+            hasTypeAnnotations: this._hasTypeAnnotations
           },
           tokenizerOutput: this._tokenizerOutput
         };
@@ -96521,6 +96645,8 @@ var require_parser = __commonJS({
       _parseLoopSuite() {
         const wasInLoop = this._isInLoop;
         this._isInLoop = true;
+        const wasInFinallyLoop = this._isInFinallyLoop;
+        this._isInFinallyLoop = false;
         let typeComment;
         const suite = this._parseSuite(
           this._isInFunction,
@@ -96534,6 +96660,7 @@ var require_parser = __commonJS({
           }
         );
         this._isInLoop = wasInLoop;
+        this._isInFinallyLoop = wasInFinallyLoop;
         if (typeComment) {
           suite.d.typeComment = typeComment;
         }
@@ -96961,7 +97088,13 @@ var require_parser = __commonJS({
           16
           /* KeywordType.Finally */
         )) {
+          const wasInFinallyBlock = this._isInFinallyBlock;
+          const wasInFinallyLoop = this._isInFinallyLoop;
+          this._isInFinallyBlock = true;
+          this._isInFinallyLoop = this._isInLoop;
           tryNode.d.finallySuite = this._parseSuite(this._isInFunction);
+          this._isInFinallyBlock = wasInFinallyBlock;
+          this._isInFinallyLoop = wasInFinallyLoop;
           tryNode.d.finallySuite.parent = tryNode;
           (0, parseNodes_1.extendRange)(tryNode, tryNode.d.finallySuite);
         }
@@ -97023,6 +97156,10 @@ var require_parser = __commonJS({
         let functionTypeAnnotationToken;
         const wasInExceptionGroup = this._isInExceptionGroup;
         this._isInExceptionGroup = false;
+        const wasInFinallyBlock = this._isInFinallyBlock;
+        const wasInFinallyLoop = this._isInFinallyLoop;
+        this._isInFinallyBlock = false;
+        this._isInFinallyLoop = false;
         const suite = this._parseSuite(
           /* isFunction */
           true,
@@ -97034,6 +97171,8 @@ var require_parser = __commonJS({
           }
         );
         this._isInExceptionGroup = wasInExceptionGroup;
+        this._isInFinallyBlock = wasInFinallyBlock;
+        this._isInFinallyLoop = wasInFinallyLoop;
         const functionNode = parseNodes_1.FunctionNode.create(defToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
         if (asyncToken) {
           functionNode.d.isAsync = true;
@@ -97530,6 +97669,9 @@ var require_parser = __commonJS({
         } else if (this._isInExceptionGroup) {
           this._addSyntaxError(localize_1.LocMessage.breakInExceptionGroup(), breakToken);
         }
+        if (this._isInFinallyLoop && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
+          this._addSyntaxError(localize_1.LocMessage.finallyBreak(), breakToken);
+        }
         return parseNodes_1.BreakNode.create(breakToken);
       }
       _parseContinueStatement() {
@@ -97542,6 +97684,9 @@ var require_parser = __commonJS({
         } else if (this._isInExceptionGroup) {
           this._addSyntaxError(localize_1.LocMessage.continueInExceptionGroup(), continueToken);
         }
+        if (this._isInFinallyLoop && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
+          this._addSyntaxError(localize_1.LocMessage.finallyContinue(), continueToken);
+        }
         return parseNodes_1.ContinueNode.create(continueToken);
       }
       // return_stmt: 'return' [testlist]
@@ -97556,6 +97701,9 @@ var require_parser = __commonJS({
         } else if (this._isInExceptionGroup) {
           this._addSyntaxError(localize_1.LocMessage.returnInExceptionGroup(), returnToken);
         }
+        if (this._isInFinallyBlock && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
+          this._addSyntaxError(localize_1.LocMessage.finallyReturn(), returnToken);
+        }
         if (!this._isNextTokenNeverExpression()) {
           const returnExpr = this._parseTestOrStarListAsExpression(
             /* allowAssignmentExpression */
@@ -99548,6 +99696,7 @@ var require_parser = __commonJS({
           result = parseNodes_1.UnpackNode.create(startToken, result);
         }
         this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
+        this._hasTypeAnnotations = true;
         return result;
       }
       _reportStringTokenErrors(stringToken, unescapedResult) {