@zzzen/pyright-internal 1.2.0-dev.20231112 → 1.2.0-dev.20231126

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -42,6 +42,7 @@ export declare const enum EvaluatorFlags {
     AllowUnpackedTypedDict = 8388608,
     DisallowPep695TypeAlias = 16777216,
     SkipConvertParamSpecToRuntimeObject = 33554432,
+    DisallowNonTypeSpecialForms = 67108864,
     CallBaseDefaults = 16777218,
     IndexBaseDefaults = 2,
     MemberAccessBaseDefaults = 16777218
@@ -113,7 +114,7 @@ export interface FunctionArgumentWithType extends FunctionArgumentBase {
 export interface FunctionArgumentWithExpression extends FunctionArgumentBase {
     valueExpression: ExpressionNode;
 }
-export declare type FunctionArgument = FunctionArgumentWithType | FunctionArgumentWithExpression;
+export type FunctionArgument = FunctionArgumentWithType | FunctionArgumentWithExpression;
 export interface EffectiveTypeResult {
     type: Type;
     isIncomplete: boolean;
@@ -155,6 +156,7 @@ export interface ExpectedTypeOptions {
     allowForwardReference?: boolean;
     allowTypeVarsWithoutScopeId?: boolean;
     enforceTypeAnnotationRules?: boolean;
+    disallowProtocolAndTypedDict?: boolean;
 }
 export interface ExpectedTypeResult {
     type: Type;

package/dist/analyzer/typeEvaluatorTypes.js

@@ -81,11 +81,13 @@ var EvaluatorFlags;
     // If evaluation is a TypeVarType that is a ParamSpec, do
     // not convert it to its corresponding ParamSpec runtime object.
     EvaluatorFlags[EvaluatorFlags["SkipConvertParamSpecToRuntimeObject"] = 33554432] = "SkipConvertParamSpecToRuntimeObject";
+    // Protocol and TypedDict are not allowed in this context.
+    EvaluatorFlags[EvaluatorFlags["DisallowNonTypeSpecialForms"] = 67108864] = "DisallowNonTypeSpecialForms";
     // Defaults used for evaluating the LHS of a call expression.
     EvaluatorFlags[EvaluatorFlags["CallBaseDefaults"] = 16777218] = "CallBaseDefaults";
     // Defaults used for evaluating the LHS of a member access expression.
     EvaluatorFlags[EvaluatorFlags["IndexBaseDefaults"] = 2] = "IndexBaseDefaults";
     // Defaults used for evaluating the LHS of a member access expression.
     EvaluatorFlags[EvaluatorFlags["MemberAccessBaseDefaults"] = 16777218] = "MemberAccessBaseDefaults";
-})(EvaluatorFlags = exports.EvaluatorFlags || (exports.EvaluatorFlags = {}));
+})(EvaluatorFlags || (exports.EvaluatorFlags = EvaluatorFlags = {}));
 //# sourceMappingURL=typeEvaluatorTypes.js.map

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA8CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,cAsGjB;AAtGD,WAAkB,cAAc;IAC5B,mDAAQ,CAAA;IAER,uDAAuD;IACvD,mFAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yEAAwB,CAAA;IAExB,yDAAyD;IACzD,uFAA+B,CAAA;IAE/B,kCAAkC;IAClC,iGAAoC,CAAA;IAEpC,0CAA0C;IAC1C,sEAAsB,CAAA;IAEtB,6CAA6C;IAC7C,8EAA0B,CAAA;IAE1B,gDAAgD;IAChD,oFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,4BAA4B;IAC5B,+FAAkC,CAAA;IAElC,gEAAgE;IAChE,6DAA6D;IAC7D,qBAAqB;IACrB,2FAAgC,CAAA;IAEhC,qEAAqE;IACrE,qFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,wFAA+B,CAAA;IAE/B,8DAA8D;IAC9D,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,oEAAoE;IACpE,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,gHAA2C,CAAA;IAE3C,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,iHAA2C,CAAA;IAE3C,mDAAmD;IACnD,2FAAgC,CAAA;IAEhC,6CAA6C;IAC7C,gFAA0B,CAAA;IAE1B,mEAAmE;IACnE,wFAA8B,CAAA;IAE9B,iEAAiE;IACjE,iCAAiC;IACjC,4FAAgC,CAAA;IAEhC,wDAAwD;IACxD,2EAAuB,CAAA;IAEvB,uDAAuD;IACvD,iHAA0C,CAAA;IAE1C,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6GAAwC,CAAA;IAExC,yCAAyC;IACzC,6FAAgC,CAAA;IAEhC,yDAAyD;IACzD,gGAAiC,CAAA;IAEjC,yDAAyD;IACzD,gEAAgE;IAChE,wHAA6C,CAAA;IAE7C,6DAA6D;IAC7D,kFAA4D,CAAA;IAE5D,sEAAsE;IACtE,6EAAmC,CAAA;IAEnC,sEAAsE;IACtE,kGAAoE,CAAA;AACxE,CAAC,EAtGiB,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAsG/B"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA8CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,cAyGjB;AAzGD,WAAkB,cAAc;IAC5B,mDAAQ,CAAA;IAER,uDAAuD;IACvD,mFAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yEAAwB,CAAA;IAExB,yDAAyD;IACzD,uFAA+B,CAAA;IAE/B,kCAAkC;IAClC,iGAAoC,CAAA;IAEpC,0CAA0C;IAC1C,sEAAsB,CAAA;IAEtB,6CAA6C;IAC7C,8EAA0B,CAAA;IAE1B,gDAAgD;IAChD,oFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,4BAA4B;IAC5B,+FAAkC,CAAA;IAElC,gEAAgE;IAChE,6DAA6D;IAC7D,qBAAqB;IACrB,2FAAgC,CAAA;IAEhC,qEAAqE;IACrE,qFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,wFAA+B,CAAA;IAE/B,8DAA8D;IAC9D,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,oEAAoE;IACpE,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,gHAA2C,CAAA;IAE3C,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,iHAA2C,CAAA;IAE3C,mDAAmD;IACnD,2FAAgC,CAAA;IAEhC,6CAA6C;IAC7C,gFAA0B,CAAA;IAE1B,mEAAmE;IACnE,wFAA8B,CAAA;IAE9B,iEAAiE;IACjE,iCAAiC;IACjC,4FAAgC,CAAA;IAEhC,wDAAwD;IACxD,2EAAuB,CAAA;IAEvB,uDAAuD;IACvD,iHAA0C,CAAA;IAE1C,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6GAAwC,CAAA;IAExC,yCAAyC;IACzC,6FAAgC,CAAA;IAEhC,yDAAyD;IACzD,gGAAiC,CAAA;IAEjC,yDAAyD;IACzD,gEAAgE;IAChE,wHAA6C,CAAA;IAE7C,0DAA0D;IAC1D,wGAAqC,CAAA;IAErC,6DAA6D;IAC7D,kFAA4D,CAAA;IAE5D,sEAAsE;IACtE,6EAAmC,CAAA;IAEnC,sEAAsE;IACtE,kGAAoE,CAAA;AACxE,CAAC,EAzGiB,cAAc,8BAAd,cAAc,QAyG/B"}

package/dist/analyzer/typeGuards.d.ts

@@ -5,7 +5,7 @@ export interface TypeNarrowingResult {
     type: Type;
     isIncomplete: boolean;
 }
-export declare type TypeNarrowingCallback = (type: Type) => TypeNarrowingResult | undefined;
+export type TypeNarrowingCallback = (type: Type) => TypeNarrowingResult | undefined;
 export declare function getTypeNarrowingCallback(evaluator: TypeEvaluator, reference: ExpressionNode, testExpression: ExpressionNode, isPositiveTest: boolean, recursionCount?: number): TypeNarrowingCallback | undefined;
 export declare function isIsinstanceFilterSuperclass(evaluator: TypeEvaluator, varType: Type, concreteVarType: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
 export declare function isIsinstanceFilterSubclass(evaluator: TypeEvaluator, varType: ClassType, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;

package/dist/analyzer/typeGuards.js

@@ -11,7 +11,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -50,25 +54,25 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
         return undefined;
     }
     recursionCount++;
-    if (testExpression.nodeType === 4 /* AssignmentExpression */) {
+    if (testExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
         return getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount);
     }
-    if (testExpression.nodeType === 7 /* BinaryOperation */) {
-        const isOrIsNotOperator = testExpression.operator === 39 /* Is */ || testExpression.operator === 40 /* IsNot */;
-        const equalsOrNotEqualsOperator = testExpression.operator === 12 /* Equals */ || testExpression.operator === 28 /* NotEquals */;
+    if (testExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
+        const isOrIsNotOperator = testExpression.operator === 39 /* OperatorType.Is */ || testExpression.operator === 40 /* OperatorType.IsNot */;
+        const equalsOrNotEqualsOperator = testExpression.operator === 12 /* OperatorType.Equals */ || testExpression.operator === 28 /* OperatorType.NotEquals */;
         if (isOrIsNotOperator || equalsOrNotEqualsOperator) {
             // Invert the "isPositiveTest" value if this is an "is not" operation.
-            const adjIsPositiveTest = testExpression.operator === 39 /* Is */ || testExpression.operator === 12 /* Equals */
+            const adjIsPositiveTest = testExpression.operator === 39 /* OperatorType.Is */ || testExpression.operator === 12 /* OperatorType.Equals */
                 ? isPositiveTest
                 : !isPositiveTest;
             // Look for "X is None", "X is not None", "X == None", and "X != None".
             // These are commonly-used patterns used in control flow.
-            if (testExpression.rightExpression.nodeType === 11 /* Constant */ &&
-                testExpression.rightExpression.constType === 26 /* None */) {
+            if (testExpression.rightExpression.nodeType === 11 /* ParseNodeType.Constant */ &&
+                testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
                 // Allow the LHS to be either a simple expression or an assignment
                 // expression that assigns to a simple name.
                 let leftExpression = testExpression.leftExpression;
-                if (leftExpression.nodeType === 4 /* AssignmentExpression */) {
+                if (leftExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
                     leftExpression = leftExpression.name;
                 }
                 if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
@@ -76,13 +80,13 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         return { type: narrowTypeForIsNone(evaluator, type, adjIsPositiveTest), isIncomplete: false };
                     };
                 }
-                if (leftExpression.nodeType === 24 /* Index */ &&
+                if (leftExpression.nodeType === 24 /* ParseNodeType.Index */ &&
                     ParseTreeUtils.isMatchingExpression(reference, leftExpression.baseExpression) &&
                     leftExpression.items.length === 1 &&
                     !leftExpression.trailingComma &&
-                    leftExpression.items[0].argumentCategory === 0 /* Simple */ &&
+                    leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
                     !leftExpression.items[0].name &&
-                    leftExpression.items[0].valueExpression.nodeType === 40 /* Number */ &&
+                    leftExpression.items[0].valueExpression.nodeType === 40 /* ParseNodeType.Number */ &&
                     leftExpression.items[0].valueExpression.isInteger &&
                     !leftExpression.items[0].valueExpression.isImaginary) {
                     const indexValue = leftExpression.items[0].valueExpression.value;
@@ -97,11 +101,11 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
             // Look for "X is ...", "X is not ...", "X == ...", and "X != ...".
-            if (testExpression.rightExpression.nodeType === 18 /* Ellipsis */) {
+            if (testExpression.rightExpression.nodeType === 18 /* ParseNodeType.Ellipsis */) {
                 // Allow the LHS to be either a simple expression or an assignment
                 // expression that assigns to a simple name.
                 let leftExpression = testExpression.leftExpression;
-                if (leftExpression.nodeType === 4 /* AssignmentExpression */) {
+                if (leftExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
                     leftExpression = leftExpression.name;
                 }
                 if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
@@ -114,12 +118,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
             // Look for "type(X) is Y", "type(X) is not Y", "type(X) == Y" or "type(X) != Y".
-            if (testExpression.leftExpression.nodeType === 9 /* Call */) {
+            if (testExpression.leftExpression.nodeType === 9 /* ParseNodeType.Call */) {
                 if (testExpression.leftExpression.arguments.length === 1 &&
-                    testExpression.leftExpression.arguments[0].argumentCategory === 0 /* Simple */) {
+                    testExpression.leftExpression.arguments[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
                     const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
                     if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                        const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 16777218 /* CallBaseDefaults */).type;
+                        const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */).type;
                         if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type')) {
                             const classTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                             const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
@@ -162,10 +166,10 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     }
                 }
                 // Look for X[<literal>] is <literal> or X[<literal>] is not <literal>.
-                if (testExpression.leftExpression.nodeType === 24 /* Index */ &&
+                if (testExpression.leftExpression.nodeType === 24 /* ParseNodeType.Index */ &&
                     testExpression.leftExpression.items.length === 1 &&
                     !testExpression.leftExpression.trailingComma &&
-                    testExpression.leftExpression.items[0].argumentCategory === 0 /* Simple */ &&
+                    testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
                     ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
                     const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
                     const indexType = indexTypeResult.type;
@@ -208,7 +212,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             if (equalsOrNotEqualsOperator) {
                 // Look for X == <literal> or X != <literal>
-                const adjIsPositiveTest = testExpression.operator === 12 /* Equals */ ? isPositiveTest : !isPositiveTest;
+                const adjIsPositiveTest = testExpression.operator === 12 /* OperatorType.Equals */ ? isPositiveTest : !isPositiveTest;
                 if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
                     const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                     const rightType = rightTypeResult.type;
@@ -223,10 +227,10 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     }
                 }
                 // Look for X[<literal>] == <literal> or X[<literal>] != <literal>
-                if (testExpression.leftExpression.nodeType === 24 /* Index */ &&
+                if (testExpression.leftExpression.nodeType === 24 /* ParseNodeType.Index */ &&
                     testExpression.leftExpression.items.length === 1 &&
                     !testExpression.leftExpression.trailingComma &&
-                    testExpression.leftExpression.items[0].argumentCategory === 0 /* Simple */ &&
+                    testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
                     ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
                     const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
                     const indexType = indexTypeResult.type;
@@ -255,11 +259,11 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             // Look for len(x) == <literal> or len(x) != <literal>
             if (equalsOrNotEqualsOperator &&
-                testExpression.leftExpression.nodeType === 9 /* Call */ &&
+                testExpression.leftExpression.nodeType === 9 /* ParseNodeType.Call */ &&
                 testExpression.leftExpression.arguments.length === 1) {
                 const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
                 if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                    const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 16777218 /* CallBaseDefaults */);
+                    const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
                     const callType = callTypeResult.type;
                     if ((0, types_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
                         const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
@@ -280,7 +284,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             // Look for X.Y == <literal> or X.Y != <literal>
             if (equalsOrNotEqualsOperator &&
-                testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
+                testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                 ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
                 const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                 const rightType = rightTypeResult.type;
@@ -296,7 +300,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             // Look for X.Y is <literal> or X.Y is not <literal> where <literal> is
             // an enum or bool literal
-            if (testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
+            if (testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                 ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
                 const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                 const rightType = rightTypeResult.type;
@@ -314,10 +318,10 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             // Look for X.Y is None or X.Y is not None
             // These are commonly-used patterns used in control flow.
-            if (testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
+            if (testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                 ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression) &&
-                testExpression.rightExpression.nodeType === 11 /* Constant */ &&
-                testExpression.rightExpression.constType === 26 /* None */) {
+                testExpression.rightExpression.nodeType === 11 /* ParseNodeType.Constant */ &&
+                testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
                 const memberName = testExpression.leftExpression.memberName;
                 return (type) => {
                     return {
@@ -327,12 +331,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 };
             }
         }
-        if (testExpression.operator === 41 /* In */ || testExpression.operator === 42 /* NotIn */) {
+        if (testExpression.operator === 41 /* OperatorType.In */ || testExpression.operator === 42 /* OperatorType.NotIn */) {
             // Look for "x in y" or "x not in y" where y is one of several built-in types.
             if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
                 const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                 const rightType = rightTypeResult.type;
-                const adjIsPositiveTest = testExpression.operator === 41 /* In */ ? isPositiveTest : !isPositiveTest;
+                const adjIsPositiveTest = testExpression.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
                 return (type) => {
                     return {
                         type: narrowTypeForContainerType(evaluator, type, rightType, adjIsPositiveTest),
@@ -346,7 +350,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 const leftTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression);
                 const leftType = leftTypeResult.type;
                 if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
-                    const adjIsPositiveTest = testExpression.operator === 41 /* In */ ? isPositiveTest : !isPositiveTest;
+                    const adjIsPositiveTest = testExpression.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
                     return (type) => {
                         return {
                             type: narrowTypeForTypedDictKey(evaluator, type, types_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
@@ -357,7 +361,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
         }
     }
-    if (testExpression.nodeType === 9 /* Call */) {
+    if (testExpression.nodeType === 9 /* ParseNodeType.Call */) {
         // Look for "isinstance(X, Y)" or "issubclass(X, Y)".
         if (testExpression.arguments.length === 2) {
             // Make sure the first parameter is a supported expression type
@@ -366,15 +370,15 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             const arg0Expr = testExpression.arguments[0].valueExpression;
             const arg1Expr = testExpression.arguments[1].valueExpression;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) &&
                     (callType.details.builtInName === 'isinstance' || callType.details.builtInName === 'issubclass')) {
                     const isInstanceCheck = callType.details.builtInName === 'isinstance';
-                    const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 512 /* AllowMissingTypeArgs */ |
-                        8 /* EvaluateStringLiteralAsType */ |
-                        32 /* DisallowParamSpec */ |
-                        64 /* DisallowTypeVarTuple */);
+                    const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
+                        8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
+                        32 /* EvaluatorFlags.DisallowParamSpec */ |
+                        64 /* EvaluatorFlags.DisallowTypeVarTuple */);
                     const arg1Type = arg1TypeResult.type;
                     const classTypeList = getIsInstanceClassTypes(arg1Type);
                     const isIncomplete = !!callTypeResult.isIncomplete || !!arg1TypeResult.isIncomplete;
@@ -413,7 +417,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
         if (testExpression.arguments.length === 1) {
             const arg0Expr = testExpression.arguments[0].valueExpression;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && callType.details.builtInName === 'callable') {
                     return (type) => {
@@ -432,7 +436,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
         // Look for "bool(X)"
         if (testExpression.arguments.length === 1 && !testExpression.arguments[0].name) {
             if (ParseTreeUtils.isMatchingExpression(reference, testExpression.arguments[0].valueExpression)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
                     return (type) => {
@@ -455,7 +459,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         (0, types_1.isClassInstance)(type.details.declaredReturnType) &&
                         types_1.ClassType.isBuiltIn(type.details.declaredReturnType, 'TypeGuard'));
                 };
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
                     isPossiblyTypeGuard = true;
@@ -505,8 +509,8 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
     // We normally won't find a "not" operator here because they are stripped out
     // by the binder when it creates condition flow nodes, but we can find this
     // in the case of local variables type narrowing.
-    if (reference.nodeType === 38 /* Name */) {
-        if (testExpression.nodeType === 55 /* UnaryOperation */ && testExpression.operator === 38 /* Not */) {
+    if (reference.nodeType === 38 /* ParseNodeType.Name */) {
+        if (testExpression.nodeType === 55 /* ParseNodeType.UnaryOperation */ && testExpression.operator === 38 /* OperatorType.Not */) {
             return getTypeNarrowingCallback(evaluator, reference, testExpression.expression, !isPositiveTest, recursionCount);
         }
     }
@@ -514,8 +518,8 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
 }
 exports.getTypeNarrowingCallback = getTypeNarrowingCallback;
 function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
-    if (testExpression.nodeType !== 38 /* Name */ ||
-        reference.nodeType !== 38 /* Name */ ||
+    if (testExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
+        reference.nodeType !== 38 /* ParseNodeType.Name */ ||
         testExpression === reference) {
         return undefined;
     }
@@ -524,7 +528,7 @@ function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testE
     // we need to validate that it is not modified between the test expression
     // evaluation and the conditional check.
     const testExprDecl = getDeclsForLocalVar(evaluator, testExpression, testExpression);
-    if (!testExprDecl || testExprDecl.length !== 1 || testExprDecl[0].type !== 1 /* Variable */) {
+    if (!testExprDecl || testExprDecl.length !== 1 || testExprDecl[0].type !== 1 /* DeclarationType.Variable */) {
         return undefined;
     }
     const referenceDecls = getDeclsForLocalVar(evaluator, reference, testExpression);
@@ -565,7 +569,7 @@ function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testE
 // the current scope.
 function getDeclsForLocalVar(evaluator, name, reachableFrom) {
     const scope = (0, scopeUtils_1.getScopeForNode)(name);
-    if ((scope === null || scope === void 0 ? void 0 : scope.type) !== 1 /* Function */ && (scope === null || scope === void 0 ? void 0 : scope.type) !== 3 /* Module */) {
+    if ((scope === null || scope === void 0 ? void 0 : scope.type) !== 1 /* ScopeType.Function */ && (scope === null || scope === void 0 ? void 0 : scope.type) !== 3 /* ScopeType.Module */) {
         return undefined;
     }
     const symbol = scope.lookUpSymbol(name.value);
@@ -574,14 +578,14 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom) {
     }
     const decls = symbol.getDeclarations();
     if (decls.length === 0 ||
-        decls.some((decl) => decl.type !== 1 /* Variable */ && decl.type !== 2 /* Parameter */)) {
+        decls.some((decl) => decl.type !== 1 /* DeclarationType.Variable */ && decl.type !== 2 /* DeclarationType.Parameter */)) {
         return undefined;
     }
     // If there are any assignments within different scopes (e.g. via a "global" or
     // "nonlocal" reference), don't consider it a local variable.
     let prevDeclScope;
     if (decls.some((decl) => {
-        const nodeToConsider = decl.type === 2 /* Parameter */ ? decl.node.name : decl.node;
+        const nodeToConsider = decl.type === 2 /* DeclarationType.Parameter */ ? decl.node.name : decl.node;
         const declScopeNode = ParseTreeUtils.getExecutionScopeNode(nodeToConsider);
         if (prevDeclScope && declScopeNode !== prevDeclScope) {
             return true;
@@ -830,8 +834,8 @@ function getIsInstanceClassTypes(argType) {
             }
             else if ((0, types_1.isFunction)(subtype) &&
                 subtype.details.parameters.length === 2 &&
-                subtype.details.parameters[0].category === 1 /* ArgsList */ &&
-                subtype.details.parameters[1].category === 2 /* KwargsDict */) {
+                subtype.details.parameters[0].category === 1 /* ParameterCategory.ArgsList */ &&
+                subtype.details.parameters[1].category === 2 /* ParameterCategory.KwargsDict */) {
                 classTypeList.push(subtype);
             }
             else {
@@ -908,7 +912,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
     let expandedTypes = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
         return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
     });
-    expandedTypes = evaluator.expandPromotionTypes(errorNode, type);
+    expandedTypes = evaluator.expandPromotionTypes(errorNode, expandedTypes);
     // Filters the varType by the parameters of the isinstance
     // and returns the list of types the varType could be after
     // applying the filter.
@@ -946,13 +950,19 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                     if (filterIsSuperclass) {
                         // If the variable type is a subclass of the isinstance filter,
                         // we haven't learned anything new about the variable type.
-                        filteredTypes.push((0, typeUtils_1.addConditionToType)(concreteVarType, conditions));
+                        // If the varType is a Self or type[Self], retain the unnarrowedType.
+                        if ((0, types_1.isTypeVar)(varType) && varType.details.isSynthesizedSelf) {
+                            filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, conditions));
+                        }
+                        else {
+                            filteredTypes.push((0, typeUtils_1.addConditionToType)(concreteVarType, conditions));
+                        }
                     }
                     else if (filterIsSubclass) {
                         if (evaluator.assignType(concreteVarType, concreteFilterType, 
                         /* diag */ undefined, 
                         /* destTypeVarContext */ undefined, 
-                        /* srcTypeVarContext */ undefined, 512 /* IgnoreTypeVarScope */ | 4096 /* IgnoreProtocolAssignmentCheck */)) {
+                        /* srcTypeVarContext */ undefined, 512 /* AssignTypeFlags.IgnoreTypeVarScope */ | 4096 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */)) {
                             // If the variable type is a superclass of the isinstance
                             // filter, we can narrow the type to the subclass.
                             let specializedFilterType = filterType;
@@ -993,7 +1003,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                                 effectiveMetaclass = concreteFilterType.details.effectiveMetaclass;
                             }
                         }
-                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
                         /* declaredMetaclass */ undefined, effectiveMetaclass, concreteVarType.details.docString);
                         newClassType.details.baseClasses = [
                             types_1.ClassType.cloneAsInstantiable(concreteVarType),
@@ -1075,7 +1085,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                             isCallable = true;
                         }
                         else {
-                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(concreteVarType, '__call__', 16 /* SkipInstanceMembers */);
+                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(concreteVarType, '__call__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
                         }
                     }
                     if (isCallable) {
@@ -1124,7 +1134,16 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
                 const filterMetaclass = concreteFilterType.details.effectiveMetaclass;
                 if (filterMetaclass && (0, types_1.isInstantiableClass)(filterMetaclass)) {
-                    const isMetaclassOverlap = evaluator.assignType(metaclassType, types_1.ClassType.cloneAsInstance(filterMetaclass));
+                    let isMetaclassOverlap = evaluator.assignType(metaclassType, types_1.ClassType.cloneAsInstance(filterMetaclass));
+                    // Handle the special case where the metaclass for the filter is type.
+                    // This will normally be treated as type[Any], which is compatible with
+                    // any metaclass, but we specifically want to treat type as the class
+                    // type[object] in this case.
+                    if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.isTypeArgumentExplicit) {
+                        if (!types_1.ClassType.isBuiltIn(metaclassType, 'type')) {
+                            isMetaclassOverlap = false;
+                        }
+                    }
                     if (isMetaclassOverlap) {
                         if (isPositiveTest) {
                             filteredTypes.push(filterType);
@@ -1167,7 +1186,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                 if (evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType), 
                 /* diag */ undefined, 
                 /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 512 /* IgnoreTypeVarScope */)) {
+                /* srcTypeVarContext */ undefined, 512 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
                     // If the filter type is a Callable, use the original type. If the
                     // filter type is a callback protocol, use the filter type.
                     if ((0, types_1.isFunction)(filterType)) {
@@ -1445,6 +1464,14 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
             canNarrow = false;
             return referenceType;
         }
+        // Handle the special case where the reference type is a dict or Mapping and
+        // the element type is a TypedDict. In this case, we can't say whether there
+        // is a type overlap, so don't apply narrowing.
+        if ((0, types_1.isClassInstance)(referenceType) && types_1.ClassType.isBuiltIn(referenceType, ['dict', 'Mapping'])) {
+            if ((0, types_1.isClassInstance)(concreteElementType) && types_1.ClassType.isTypedDictClass(concreteElementType)) {
+                return concreteElementType;
+            }
+        }
         if (evaluator.assignType(referenceType, concreteElementType)) {
             return concreteElementType;
         }
@@ -1558,6 +1585,7 @@ exports.narrowTypeForDiscriminatedTupleComparison = narrowTypeForDiscriminatedTu
 // literal value.
 function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceType, memberName, literalType, isPositiveTest) {
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        var _a;
         let memberInfo;
         if ((0, types_1.isClassInstance)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
@@ -1570,7 +1598,7 @@ function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceTy
             // Handle the case where the field is a property
             // that has a declared literal return type for its getter.
             if ((0, types_1.isClassInstance)(subtype) && (0, types_1.isClassInstance)(memberType) && (0, typeUtils_1.isProperty)(memberType)) {
-                const getterType = memberType.fgetFunction;
+                const getterType = (_a = memberType.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType;
                 if (getterType && getterType.details.declaredReturnType) {
                     const getterReturnType = types_1.FunctionType.getSpecializedReturnType(getterType);
                     if (getterReturnType) {
@@ -1773,14 +1801,14 @@ exports.enumerateLiteralsForType = enumerateLiteralsForType;
 function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allowIntersections) {
     return evaluator.mapSubtypesExpandTypeVars(type, /* conditionFilter */ undefined, (subtype) => {
         switch (subtype.category) {
-            case 4 /* Function */:
-            case 5 /* OverloadedFunction */: {
+            case 4 /* TypeCategory.Function */:
+            case 5 /* TypeCategory.OverloadedFunction */: {
                 return isPositiveTest ? subtype : undefined;
             }
-            case 7 /* Module */: {
+            case 7 /* TypeCategory.Module */: {
                 return isPositiveTest ? undefined : subtype;
             }
-            case 6 /* Class */: {
+            case 6 /* TypeCategory.Class */: {
                 if ((0, typeUtils_1.isNoneInstance)(subtype)) {
                     return isPositiveTest ? undefined : subtype;
                 }
@@ -1788,7 +1816,7 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                     return isPositiveTest ? subtype : undefined;
                 }
                 // See if the object is callable.
-                const callMemberType = (0, typeUtils_1.lookUpClassMember)(subtype, '__call__', 16 /* SkipInstanceMembers */);
+                const callMemberType = (0, typeUtils_1.lookUpClassMember)(subtype, '__call__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
                 if (!callMemberType) {
                     if (!isPositiveTest) {
                         return subtype;
@@ -1799,7 +1827,7 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                         // new intersection type.
                         const className = `<callable subtype of ${subtype.details.name}>`;
                         const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
                         /* declaredMetaclass */ undefined, subtype.details.effectiveMetaclass, subtype.details.docString);
                         newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
                         (0, typeUtils_1.computeMroLinearization)(newClassType);
@@ -1807,7 +1835,7 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                         // Add a __call__ method to the new class.
                         const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
                         const selfParam = {
-                            category: 0 /* Simple */,
+                            category: 0 /* ParameterCategory.Simple */,
                             name: 'self',
                             type: types_1.ClassType.cloneAsInstance(newClassType),
                             hasDeclaredType: true,
@@ -1815,7 +1843,7 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                         types_1.FunctionType.addParameter(callMethod, selfParam);
                         types_1.FunctionType.addDefaultParameters(callMethod);
                         callMethod.details.declaredReturnType = types_1.UnknownType.create();
-                        newClassType.details.fields.set('__call__', symbol_1.Symbol.createWithType(4 /* ClassMember */, callMethod));
+                        newClassType.details.fields.set('__call__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, callMethod));
                         return types_1.ClassType.cloneAsInstance(newClassType);
                     }
                     return undefined;