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

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -15,35 +15,36 @@ import { AssignTypeFlags, ClassMember, InferenceContext, MemberAccessFlags, Uniq
 import { TypeVarContext } from './typeVarContext';
 import { AnyType, ClassType, FunctionParameter, FunctionType, OverloadedFunctionType, Type, TypeCondition, TypeVarType, UnknownType, Variance } from './types';
 export declare const maxSubtypesForInferredType = 64;
-export declare const enum EvaluatorFlags {
+export declare const enum EvalFlags {
     None = 0,
     ConvertEllipsisToAny = 1,
-    DoNotSpecialize = 2,
-    AllowForwardReferences = 4,
-    EvaluateStringLiteralAsType = 8,
-    DisallowFinal = 16,
-    DisallowParamSpec = 32,
-    DisallowTypeVarTuple = 64,
-    ExpectingInstantiableType = 128,
-    ExpectingTypeAnnotation = 256,
+    NoSpecialize = 2,
+    ForwardRefs = 4,
+    StrLiteralAsType = 8,
+    NoFinal = 16,
+    NoParamSpec = 32,
+    NoTypeVarTuple = 64,
+    InstantiableType = 128,
+    TypeExpression = 256,
     AllowMissingTypeArgs = 512,
-    AllowGenericClassType = 1024,
-    DisallowTypeVarsWithScopeId = 2048,
-    AllowTypeVarsWithoutScopeId = 4096,
-    AssociateTypeVarsWithCurrentScope = 8192,
-    EnforceTypeVarVarianceConsistency = 16384,
-    VariableTypeAnnotation = 32768,
-    DisallowClassVar = 131072,
-    DisallowNakedGeneric = 262144,
-    NotParsedByInterpreter = 524288,
+    AllowGeneric = 1024,
+    NoTypeVarWithScopeId = 2048,
+    AllowTypeVarWithoutScopeId = 4096,
+    TypeVarGetsCurScope = 8192,
+    EnforceVarianceConsistency = 16384,
+    VarTypeAnnotation = 32768,
+    NoClassVar = 131072,
+    NoNakedGeneric = 262144,
+    NotParsed = 524288,
     AllowRequired = 1048576,
-    AllowUnpackedTupleOrTypeVarTuple = 2097152,
-    InterpreterParsesStringLiteral = 4194304,
-    AllowUnpackedTypedDict = 8388608,
-    SkipConvertParamSpecToRuntimeObject = 33554432,
-    DisallowNonTypeSpecialForms = 67108864,
+    AllowUnpackedTuple = 2097152,
+    AllowUnpackedTypedDict = 4194304,
+    ParsesStringLiteral = 8388608,
+    NoConvertSpecialForm = 33554432,
+    NoNonTypeSpecialForms = 67108864,
     AllowConcatenate = 134217728,
-    StripLiteralTypeForTuple = 268435456,
+    StripTupleLiterals = 268435456,
+    IsinstanceParam = 536870912,
     CallBaseDefaults = 2,
     IndexBaseDefaults = 2,
     MemberAccessBaseDefaults = 2
@@ -239,7 +240,7 @@ export interface TypeEvaluator {
     getTypeResult: (node: ExpressionNode) => TypeResult | undefined;
     getTypeResultForDecorator: (node: DecoratorNode) => TypeResult | undefined;
     getCachedType: (node: ExpressionNode) => Type | undefined;
-    getTypeOfExpression: (node: ExpressionNode, flags?: EvaluatorFlags, context?: InferenceContext) => TypeResult;
+    getTypeOfExpression: (node: ExpressionNode, flags?: EvalFlags, context?: InferenceContext) => TypeResult;
     getTypeOfAnnotation: (node: ExpressionNode, options?: AnnotationTypeOptions) => Type;
     getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
     getTypeOfFunction: (node: FunctionNode) => FunctionTypeResult | undefined;
@@ -312,7 +313,7 @@ export interface TypeEvaluator {
     inferReturnTypeIfNecessary: (type: Type) => void;
     inferTypeParameterVarianceForClass: (type: ClassType) => void;
     assignTypeArguments: (destType: ClassType, srcType: ClassType, diag: DiagnosticAddendum | undefined, destTypeVarContext: TypeVarContext | undefined, srcTypeVarContext: TypeVarContext | undefined, flags: AssignTypeFlags, recursionCount: number) => boolean;
-    reportMissingTypeArguments: (node: ExpressionNode, type: Type, flags: EvaluatorFlags) => Type;
+    reportMissingTypeArguments: (node: ExpressionNode, type: Type, flags: EvalFlags) => Type;
     isFinalVariable: (symbol: Symbol) => boolean;
     isFinalVariableDeclaration: (decl: Declaration) => boolean;
     isExplicitTypeAliasDeclaration: (decl: Declaration) => boolean;
@@ -332,7 +333,7 @@ export interface TypeEvaluator {
     disposeEvaluator: () => void;
     useSpeculativeMode: <T>(speculativeNode: ParseNode | undefined, callback: () => T) => T;
     isSpeculativeModeInUse: (node: ParseNode | undefined) => boolean;
-    setTypeResultForNode: (node: ParseNode, typeResult: TypeResult, flags?: EvaluatorFlags) => void;
+    setTypeResultForNode: (node: ParseNode, typeResult: TypeResult, flags?: EvalFlags) => void;
     checkForCancellation: () => void;
     printControlFlowGraph: (flowNode: FlowNode, reference: CodeFlowReferenceExpressionNode | undefined, callName: string, logger: ConsoleInterface) => void;
     printTypeVarContext: (typeVarContext: TypeVarContext) => void;

package/dist/analyzer/typeEvaluatorTypes.js

@@ -8,89 +8,93 @@
  * Abstract interface and other helper types for type evaluator module.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvaluatorFlags = exports.maxSubtypesForInferredType = void 0;
+exports.EvalFlags = exports.maxSubtypesForInferredType = void 0;
 // Maximum number of unioned subtypes for an inferred type (e.g.
 // a list) before the type is considered an "Any".
 exports.maxSubtypesForInferredType = 64;
-var EvaluatorFlags;
-(function (EvaluatorFlags) {
-    EvaluatorFlags[EvaluatorFlags["None"] = 0] = "None";
+var EvalFlags;
+(function (EvalFlags) {
+    EvalFlags[EvalFlags["None"] = 0] = "None";
     // Interpret an ellipsis type annotation to mean "Any".
-    EvaluatorFlags[EvaluatorFlags["ConvertEllipsisToAny"] = 1] = "ConvertEllipsisToAny";
+    EvalFlags[EvalFlags["ConvertEllipsisToAny"] = 1] = "ConvertEllipsisToAny";
     // Normally a generic named type is specialized with "Any"
     // types. This flag indicates that specialization shouldn't take
     // place.
-    EvaluatorFlags[EvaluatorFlags["DoNotSpecialize"] = 2] = "DoNotSpecialize";
+    EvalFlags[EvalFlags["NoSpecialize"] = 2] = "NoSpecialize";
     // Allow forward references. Don't report unbound errors.
-    EvaluatorFlags[EvaluatorFlags["AllowForwardReferences"] = 4] = "AllowForwardReferences";
+    EvalFlags[EvalFlags["ForwardRefs"] = 4] = "ForwardRefs";
     // Treat string literal as a type.
-    EvaluatorFlags[EvaluatorFlags["EvaluateStringLiteralAsType"] = 8] = "EvaluateStringLiteralAsType";
+    EvalFlags[EvalFlags["StrLiteralAsType"] = 8] = "StrLiteralAsType";
     // 'Final' is not allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["DisallowFinal"] = 16] = "DisallowFinal";
+    EvalFlags[EvalFlags["NoFinal"] = 16] = "NoFinal";
     // A ParamSpec isn't allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["DisallowParamSpec"] = 32] = "DisallowParamSpec";
+    EvalFlags[EvalFlags["NoParamSpec"] = 32] = "NoParamSpec";
     // A TypeVarTuple isn't allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["DisallowTypeVarTuple"] = 64] = "DisallowTypeVarTuple";
+    EvalFlags[EvalFlags["NoTypeVarTuple"] = 64] = "NoTypeVarTuple";
     // Expression is expected to be an instantiable type rather
     // than an instance (object)
-    EvaluatorFlags[EvaluatorFlags["ExpectingInstantiableType"] = 128] = "ExpectingInstantiableType";
-    // A type annotation restricts the types of expressions that are
-    // allowed. If this flag is set, illegal type expressions are
+    EvalFlags[EvalFlags["InstantiableType"] = 128] = "InstantiableType";
+    // A type expression imposes grammatical and semantic limits on an
+    // expression. If this flag is set, illegal type expressions are
     // flagged as errors.
-    EvaluatorFlags[EvaluatorFlags["ExpectingTypeAnnotation"] = 256] = "ExpectingTypeAnnotation";
+    EvalFlags[EvalFlags["TypeExpression"] = 256] = "TypeExpression";
     // Suppress the reportMissingTypeArgument diagnostic in this context.
-    EvaluatorFlags[EvaluatorFlags["AllowMissingTypeArgs"] = 512] = "AllowMissingTypeArgs";
+    EvalFlags[EvalFlags["AllowMissingTypeArgs"] = 512] = "AllowMissingTypeArgs";
     // The Generic class type is allowed in this context. It is
     // normally not allowed if ExpectingType is set.
-    EvaluatorFlags[EvaluatorFlags["AllowGenericClassType"] = 1024] = "AllowGenericClassType";
+    EvalFlags[EvalFlags["AllowGeneric"] = 1024] = "AllowGeneric";
     // TypeVars within this expression must not refer to type vars
     // used in an outer scope.
-    EvaluatorFlags[EvaluatorFlags["DisallowTypeVarsWithScopeId"] = 2048] = "DisallowTypeVarsWithScopeId";
+    EvalFlags[EvalFlags["NoTypeVarWithScopeId"] = 2048] = "NoTypeVarWithScopeId";
     // TypeVars within this expression do not need to refer to type vars
     // used in an outer scope.
-    EvaluatorFlags[EvaluatorFlags["AllowTypeVarsWithoutScopeId"] = 4096] = "AllowTypeVarsWithoutScopeId";
+    EvalFlags[EvalFlags["AllowTypeVarWithoutScopeId"] = 4096] = "AllowTypeVarWithoutScopeId";
     // TypeVars within this expression that are otherwise not
     // associated with an outer scope should be associated with
     // the containing function's scope.
-    EvaluatorFlags[EvaluatorFlags["AssociateTypeVarsWithCurrentScope"] = 8192] = "AssociateTypeVarsWithCurrentScope";
+    EvalFlags[EvalFlags["TypeVarGetsCurScope"] = 8192] = "TypeVarGetsCurScope";
     // When a new class-scoped TypeVar is used within a class
     // declaration, make sure that it is not used to parameterize
     // a base class whose TypeVar variance is inconsistent.
-    EvaluatorFlags[EvaluatorFlags["EnforceTypeVarVarianceConsistency"] = 16384] = "EnforceTypeVarVarianceConsistency";
+    EvalFlags[EvalFlags["EnforceVarianceConsistency"] = 16384] = "EnforceVarianceConsistency";
     // Used for PEP 526-style variable type annotations
-    EvaluatorFlags[EvaluatorFlags["VariableTypeAnnotation"] = 32768] = "VariableTypeAnnotation";
+    EvalFlags[EvalFlags["VarTypeAnnotation"] = 32768] = "VarTypeAnnotation";
     // 'ClassVar' is not allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["DisallowClassVar"] = 131072] = "DisallowClassVar";
+    EvalFlags[EvalFlags["NoClassVar"] = 131072] = "NoClassVar";
     // 'Generic' cannot be used without type arguments in this context.
-    EvaluatorFlags[EvaluatorFlags["DisallowNakedGeneric"] = 262144] = "DisallowNakedGeneric";
+    EvalFlags[EvalFlags["NoNakedGeneric"] = 262144] = "NoNakedGeneric";
     // The node is not parsed by the interpreter because it is within
     // a comment or a string literal.
-    EvaluatorFlags[EvaluatorFlags["NotParsedByInterpreter"] = 524288] = "NotParsedByInterpreter";
+    EvalFlags[EvalFlags["NotParsed"] = 524288] = "NotParsed";
     // Required and NotRequired are allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["AllowRequired"] = 1048576] = "AllowRequired";
+    EvalFlags[EvalFlags["AllowRequired"] = 1048576] = "AllowRequired";
     // Allow Unpack annotation for a tuple or TypeVarTuple.
-    EvaluatorFlags[EvaluatorFlags["AllowUnpackedTupleOrTypeVarTuple"] = 2097152] = "AllowUnpackedTupleOrTypeVarTuple";
+    EvalFlags[EvalFlags["AllowUnpackedTuple"] = 2097152] = "AllowUnpackedTuple";
+    // Allow Unpack annotation for TypedDict.
+    EvalFlags[EvalFlags["AllowUnpackedTypedDict"] = 4194304] = "AllowUnpackedTypedDict";
     // Even though an expression is enclosed in a string literal,
     // the interpreter (within a source file, not a stub) still
     // parses the expression and generates parse errors.
-    EvaluatorFlags[EvaluatorFlags["InterpreterParsesStringLiteral"] = 4194304] = "InterpreterParsesStringLiteral";
-    // Allow Unpack annotation for TypedDict.
-    EvaluatorFlags[EvaluatorFlags["AllowUnpackedTypedDict"] = 8388608] = "AllowUnpackedTypedDict";
-    // 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";
+    EvalFlags[EvalFlags["ParsesStringLiteral"] = 8388608] = "ParsesStringLiteral";
+    // Do not convert special forms to their corresponding runtime
+    // objects even when expecting a type expression.
+    EvalFlags[EvalFlags["NoConvertSpecialForm"] = 33554432] = "NoConvertSpecialForm";
+    // Certain special forms (Protocol, TypedDict, etc.) are not allowed
+    // in this context.
+    EvalFlags[EvalFlags["NoNonTypeSpecialForms"] = 67108864] = "NoNonTypeSpecialForms";
     // Allow use of the Concatenate special form.
-    EvaluatorFlags[EvaluatorFlags["AllowConcatenate"] = 134217728] = "AllowConcatenate";
+    EvalFlags[EvalFlags["AllowConcatenate"] = 134217728] = "AllowConcatenate";
     // Do not infer literal types within a tuple (used for tuples nested within
     // other container classes).
-    EvaluatorFlags[EvaluatorFlags["StripLiteralTypeForTuple"] = 268435456] = "StripLiteralTypeForTuple";
+    EvalFlags[EvalFlags["StripTupleLiterals"] = 268435456] = "StripTupleLiterals";
+    // Interpret the expression using the specialized behaviors associated
+    // with the second argument to isinstance and issubclass calls.
+    EvalFlags[EvalFlags["IsinstanceParam"] = 536870912] = "IsinstanceParam";
     // Defaults used for evaluating the LHS of a call expression.
-    EvaluatorFlags[EvaluatorFlags["CallBaseDefaults"] = 2] = "CallBaseDefaults";
+    EvalFlags[EvalFlags["CallBaseDefaults"] = 2] = "CallBaseDefaults";
     // Defaults used for evaluating the LHS of a member access expression.
-    EvaluatorFlags[EvaluatorFlags["IndexBaseDefaults"] = 2] = "IndexBaseDefaults";
+    EvalFlags[EvalFlags["IndexBaseDefaults"] = 2] = "IndexBaseDefaults";
     // Defaults used for evaluating the LHS of a member access expression.
-    EvaluatorFlags[EvaluatorFlags["MemberAccessBaseDefaults"] = 2] = "MemberAccessBaseDefaults";
-})(EvaluatorFlags || (exports.EvaluatorFlags = EvaluatorFlags = {}));
+    EvalFlags[EvalFlags["MemberAccessBaseDefaults"] = 2] = "MemberAccessBaseDefaults";
+})(EvalFlags || (exports.EvalFlags = EvalFlags = {}));
 //# 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;;;AA+CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,cA6GjB;AA7GD,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,gEAAgE;IAChE,wHAA6C,CAAA;IAE7C,0DAA0D;IAC1D,wGAAqC,CAAA;IAErC,6CAA6C;IAC7C,mFAA0B,CAAA;IAE1B,2EAA2E;IAC3E,4BAA4B;IAC5B,mGAAkC,CAAA;IAElC,6DAA6D;IAC7D,2EAAkC,CAAA;IAElC,sEAAsE;IACtE,6EAAmC,CAAA;IAEnC,sEAAsE;IACtE,2FAA0C,CAAA;AAC9C,CAAC,EA7GiB,cAAc,8BAAd,cAAc,QA6G/B"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA+CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,SAkHjB;AAlHD,WAAkB,SAAS;IACvB,yCAAQ,CAAA;IAER,uDAAuD;IACvD,yEAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yDAAqB,CAAA;IAErB,yDAAyD;IACzD,uDAAoB,CAAA;IAEpB,kCAAkC;IAClC,iEAAyB,CAAA;IAEzB,0CAA0C;IAC1C,gDAAgB,CAAA;IAEhB,6CAA6C;IAC7C,wDAAoB,CAAA;IAEpB,gDAAgD;IAChD,8DAAuB,CAAA;IAEvB,2DAA2D;IAC3D,4BAA4B;IAC5B,mEAAyB,CAAA;IAEzB,kEAAkE;IAClE,gEAAgE;IAChE,qBAAqB;IACrB,+DAAuB,CAAA;IAEvB,qEAAqE;IACrE,2EAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,4DAAsB,CAAA;IAEtB,8DAA8D;IAC9D,0BAA0B;IAC1B,4EAA8B,CAAA;IAE9B,oEAAoE;IACpE,0BAA0B;IAC1B,wFAAoC,CAAA;IAEpC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,0EAA6B,CAAA;IAE7B,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,yFAAoC,CAAA;IAEpC,mDAAmD;IACnD,uEAA2B,CAAA;IAE3B,6CAA6C;IAC7C,0DAAoB,CAAA;IAEpB,mEAAmE;IACnE,kEAAwB,CAAA;IAExB,iEAAiE;IACjE,iCAAiC;IACjC,wDAAmB,CAAA;IAEnB,wDAAwD;IACxD,iEAAuB,CAAA;IAEvB,uDAAuD;IACvD,2EAA4B,CAAA;IAE5B,yCAAyC;IACzC,mFAAgC,CAAA;IAEhC,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6EAA6B,CAAA;IAE7B,8DAA8D;IAC9D,iDAAiD;IACjD,gFAA8B,CAAA;IAE9B,oEAAoE;IACpE,mBAAmB;IACnB,kFAA+B,CAAA;IAE/B,6CAA6C;IAC7C,yEAA0B,CAAA;IAE1B,2EAA2E;IAC3E,4BAA4B;IAC5B,6EAA4B,CAAA;IAE5B,sEAAsE;IACtE,+DAA+D;IAC/D,uEAAyB,CAAA;IAEzB,6DAA6D;IAC7D,iEAA+B,CAAA;IAE/B,sEAAsE;IACtE,mEAAgC,CAAA;IAEhC,sEAAsE;IACtE,iFAAuC,CAAA;AAC3C,CAAC,EAlHiB,SAAS,yBAAT,SAAS,QAkH1B"}

package/dist/analyzer/typeGuards.js

@@ -129,7 +129,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     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, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
+                        const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* EvalFlags.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);
@@ -325,7 +325,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             testExpression.leftExpression.arguments.length === 1) {
             const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
                     const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
@@ -396,19 +396,19 @@ 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, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvalFlags.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 /* EvaluatorFlags.AllowMissingTypeArgs */ |
-                        8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-                        32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        16 /* EvaluatorFlags.DisallowFinal */ |
-                        2 /* EvaluatorFlags.DoNotSpecialize */);
+                    const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 512 /* EvalFlags.AllowMissingTypeArgs */ |
+                        8 /* EvalFlags.StrLiteralAsType */ |
+                        32 /* EvalFlags.NoParamSpec */ |
+                        64 /* EvalFlags.NoTypeVarTuple */ |
+                        16 /* EvalFlags.NoFinal */ |
+                        2 /* EvalFlags.NoSpecialize */);
                     const arg1Type = arg1TypeResult.type;
-                    const classTypeList = getIsInstanceClassTypes(arg1Type);
+                    const classTypeList = getIsInstanceClassTypes(evaluator, arg1Type);
                     const isIncomplete = !!callTypeResult.isIncomplete || !!arg1TypeResult.isIncomplete;
                     if (classTypeList) {
                         return (type) => {
@@ -436,7 +436,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, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && callType.details.builtInName === 'callable') {
                     return (type) => {
@@ -455,7 +455,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, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
                     return (type) => {
@@ -478,7 +478,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         (0, types_1.isClassInstance)(type.details.declaredReturnType) &&
                         types_1.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'TypeIs']));
                 };
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
                     isPossiblyTypeGuard = true;
@@ -760,7 +760,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
 // that accepts a single class, and a more complex form that accepts a tuple
 // of classes (including arbitrarily-nested tuples). This method determines
 // which form and returns a list of classes or undefined.
-function getIsInstanceClassTypes(argType) {
+function getIsInstanceClassTypes(evaluator, argType) {
     let foundNonClassType = false;
     const classTypeList = [];
     // Create a helper function that returns a list of class types or
@@ -768,7 +768,7 @@ function getIsInstanceClassTypes(argType) {
     const addClassTypesToList = (types) => {
         types.forEach((subtype) => {
             if ((0, types_1.isClass)(subtype)) {
-                subtype = (0, typeUtils_1.specializeWithUnknownTypeArgs)(subtype);
+                subtype = (0, typeUtils_1.specializeWithUnknownTypeArgs)(subtype, evaluator.getTupleClassType());
                 if ((0, types_1.isInstantiableClass)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'Callable')) {
                     subtype = (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.getUnknownTypeForCallable)());
                 }
@@ -897,7 +897,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                     if (concreteFilterType.typeArguments && !concreteFilterType.isTypeArgumentExplicit) {
                         concreteFilterType = (0, typeUtils_1.specializeWithUnknownTypeArgs)(types_1.ClassType.cloneForSpecialization(concreteFilterType, 
                         /* typeArguments */ undefined, 
-                        /* isTypeArgumentExplicit */ false));
+                        /* isTypeArgumentExplicit */ false), evaluator.getTupleClassType());
                     }
                     filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck);
                     filterIsSubclass = isIsinstanceFilterSubclass(evaluator, concreteVarType, concreteFilterType, isInstanceCheck);
@@ -955,9 +955,13 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                                         const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType, 
                                         /* typeArguments */ undefined, 
                                         /* isTypeArgumentExplicit */ false);
-                                        if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext, 
+                                        if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext, 
                                         /* liveTypeVarScopes */ undefined, errorNode.start)) {
-                                            specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, { unknownIfNotFound: true, useUnknownOverDefault: true });
+                                            specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, {
+                                                unknownIfNotFound: true,
+                                                useUnknownOverDefault: true,
+                                                tupleClassType: evaluator.getTupleClassType(),
+                                            });
                                         }
                                     }
                                 }
@@ -1198,8 +1202,11 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
     });
     const anyOrUnknownSubstitutions = [];
     const anyOrUnknown = [];
-    const filteredType = evaluator.mapSubtypesExpandTypeVars(expandedTypes, 
-    /* options */ undefined, (subtype, unexpandedSubtype) => {
+    const filteredType = evaluator.mapSubtypesExpandTypeVars(expandedTypes, {
+        expandCallback: (type) => {
+            return evaluator.expandPromotionTypes(errorNode, type);
+        },
+    }, (subtype, unexpandedSubtype) => {
         // If we fail to filter anything in the negative case, we need to decide
         // whether to retain the original TypeVar or replace it with its specialized
         // type(s). We'll assume that if someone is using isinstance or issubclass
@@ -1716,21 +1723,46 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
 // "is not". This pattern is sometimes used for sentinels.
 function narrowTypeForClassComparison(evaluator, referenceType, classType, isPositiveTest) {
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
-        const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
+        let concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
         if (isPositiveTest) {
             if ((0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
-                return undefined;
-            }
-            if ((0, types_1.isClassInstance)(concreteSubtype) && types_1.TypeBase.isInstance(subtype)) {
-                if (types_1.ClassType.isBuiltIn(concreteSubtype, 'type')) {
-                    return classType;
+                return (0, typeUtils_1.isNoneTypeClass)(classType) ? classType : undefined;
+            }
+            if ((0, types_1.isClassInstance)(concreteSubtype) &&
+                types_1.TypeBase.isInstance(subtype) &&
+                types_1.ClassType.isBuiltIn(concreteSubtype, 'type')) {
+                concreteSubtype =
+                    concreteSubtype.typeArguments && concreteSubtype.typeArguments.length > 0
+                        ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.typeArguments[0])
+                        : types_1.UnknownType.create();
+            }
+            if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
+                return classType;
+            }
+            if ((0, types_1.isClass)(concreteSubtype)) {
+                if (types_1.TypeBase.isInstance(concreteSubtype)) {
+                    return types_1.ClassType.isBuiltIn(concreteSubtype, 'object') ? classType : undefined;
                 }
-                return undefined;
-            }
-            if ((0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isFinal(concreteSubtype)) {
-                if (!types_1.ClassType.isSameGenericClass(concreteSubtype, classType) &&
-                    !isIsinstanceFilterSuperclass(evaluator, subtype, concreteSubtype, classType, classType, 
-                    /* isInstanceCheck */ false)) {
+                const isSuperType = isIsinstanceFilterSuperclass(evaluator, subtype, concreteSubtype, classType, classType, 
+                /* isInstanceCheck */ false);
+                if (!classType.includeSubclasses) {
+                    // Handle the case where the LHS and RHS operands are specific
+                    // classes, as opposed to types that represent classes and their
+                    // subclasses.
+                    if (!concreteSubtype.includeSubclasses) {
+                        return types_1.ClassType.isSameGenericClass(concreteSubtype, classType) ? classType : undefined;
+                    }
+                    const isSubType = isIsinstanceFilterSubclass(evaluator, concreteSubtype, classType, 
+                    /* isInstanceCheck */ false);
+                    if (isSuperType) {
+                        return classType;
+                    }
+                    if (isSubType) {
+                        return (0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(concreteSubtype));
+                    }
+                    return undefined;
+                }
+                if (types_1.ClassType.isFinal(concreteSubtype) && !isSuperType) {
                     return undefined;
                 }
             }