@zzzen/pyright-internal 1.2.0-dev.20221225 → 1.2.0-dev.20230108

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -163,6 +163,7 @@ export interface PrintTypeOptions {
 export interface TypeEvaluator {
     runWithCancellationToken<T>(token: CancellationToken, callback: () => T): T;
     getType: (node: ExpressionNode) => Type | undefined;
+    getTypeResult: (node: ExpressionNode) => TypeResult | undefined;
     getCachedType: (node: ExpressionNode) => Type | undefined;
     getTypeOfExpression: (node: ExpressionNode, flags?: EvaluatorFlags, expectedType?: Type) => TypeResult;
     getTypeOfAnnotation: (node: ExpressionNode, options?: AnnotationTypeOptions) => Type;
@@ -237,7 +238,7 @@ export interface TypeEvaluator {
     addUnusedCode: (node: ParseNode, textRange: TextRange) => void;
     addUnreachableCode: (node: ParseNode, textRange: TextRange) => void;
     addDeprecated: (message: string, node: ParseNode) => void;
-    addDiagnostic: (diagLevel: DiagnosticLevel, rule: string, message: string, node: ParseNode) => Diagnostic | undefined;
+    addDiagnostic: (diagLevel: DiagnosticLevel, rule: string, message: string, node: ParseNode, range?: TextRange) => Diagnostic | undefined;
     addDiagnosticForTextRange: (fileInfo: AnalyzerFileInfo, diagLevel: DiagnosticLevel, rule: string, message: string, range: TextRange) => Diagnostic | undefined;
     printType: (type: Type, options?: PrintTypeOptions) => string;
     printFunctionParts: (type: FunctionType) => [string[], string];

package/dist/analyzer/typeGuards.d.ts

@@ -1,7 +1,11 @@
 import { ExpressionNode } from '../parser/parseNodes';
 import { TypeEvaluator } from './typeEvaluatorTypes';
 import { ClassType, Type } from './types';
-export declare type TypeNarrowingCallback = (type: Type) => Type | undefined;
+export interface TypeNarrowingResult {
+    type: Type;
+    isIncomplete: boolean;
+}
+export declare 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: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
 export declare function isIsinstanceFilterSubclass(evaluator: TypeEvaluator, varType: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;

package/dist/analyzer/typeGuards.js

@@ -72,7 +72,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
                 if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
                     return (type) => {
-                        return narrowTypeForIsNone(evaluator, type, adjIsPositiveTest);
+                        return { type: narrowTypeForIsNone(evaluator, type, adjIsPositiveTest), isIncomplete: false };
                     };
                 }
                 if (leftExpression.nodeType === 24 /* Index */ &&
@@ -87,11 +87,31 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     const indexValue = leftExpression.items[0].valueExpression.value;
                     if (typeof indexValue === 'number') {
                         return (type) => {
-                            return narrowTupleTypeForIsNone(evaluator, type, adjIsPositiveTest, indexValue);
+                            return {
+                                type: narrowTupleTypeForIsNone(evaluator, type, adjIsPositiveTest, indexValue),
+                                isIncomplete: false,
+                            };
                         };
                     }
                 }
             }
+            // Look for "X is ...", "X is not ...", "X == ...", and "X != ...".
+            if (testExpression.rightExpression.nodeType === 18 /* 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 */) {
+                    leftExpression = leftExpression.name;
+                }
+                if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
+                    return (type) => {
+                        return {
+                            type: narrowTypeForIsEllipsis(evaluator, type, adjIsPositiveTest),
+                            isIncomplete: false,
+                        };
+                    };
+                }
+            }
             // Look for "type(X) is Y" or "type(X) is not Y".
             if (isOrIsNotOperator && testExpression.leftExpression.nodeType === 9 /* Call */) {
                 if (testExpression.leftExpression.arguments.length === 1 &&
@@ -100,10 +120,14 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                         const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* DoNotSpecialize */).type;
                         if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type')) {
-                            const classType = evaluator.makeTopLevelTypeVarsConcrete(evaluator.getTypeOfExpression(testExpression.rightExpression).type);
+                            const classTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                            const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
                             if ((0, types_1.isInstantiableClass)(classType)) {
                                 return (type) => {
-                                    return narrowTypeForTypeIs(evaluator, type, classType, adjIsPositiveTest);
+                                    return {
+                                        type: narrowTypeForTypeIs(evaluator, type, classType, adjIsPositiveTest),
+                                        isIncomplete: !!classTypeResult.isIncomplete,
+                                    };
                                 };
                             }
                         }
@@ -113,13 +137,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             // Look for "X is Y" or "X is not Y" where Y is a an enum or bool literal.
             if (isOrIsNotOperator) {
                 if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
-                    const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                    const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                    const rightType = rightTypeResult.type;
                     if ((0, types_1.isClassInstance)(rightType) &&
                         (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
                         rightType.literalValue !== undefined) {
                         return (type) => {
-                            return narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
-                            /* isIsOperator */ true);
+                            return {
+                                type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
+                                /* isIsOperator */ true),
+                                isIncomplete: !!rightTypeResult.isIncomplete,
+                            };
                         };
                     }
                 }
@@ -128,21 +156,29 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 // Look for X == <literal> or X != <literal>
                 const adjIsPositiveTest = testExpression.operator === 12 /* Equals */ ? isPositiveTest : !isPositiveTest;
                 if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
-                    const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                    const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                    const rightType = rightTypeResult.type;
                     if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                         return (type) => {
-                            return narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
-                            /* isIsOperator */ false);
+                            return {
+                                type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
+                                /* isIsOperator */ false),
+                                isIncomplete: !!rightTypeResult.isIncomplete,
+                            };
                         };
                     }
                 }
                 // Look for <literal> == X or <literal> != X
                 if (ParseTreeUtils.isMatchingExpression(reference, testExpression.rightExpression)) {
-                    const leftType = evaluator.getTypeOfExpression(testExpression.leftExpression).type;
+                    const leftTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression);
+                    const leftType = leftTypeResult.type;
                     if ((0, types_1.isClassInstance)(leftType) && leftType.literalValue !== undefined) {
                         return (type) => {
-                            return narrowTypeForLiteralComparison(evaluator, type, leftType, adjIsPositiveTest, 
-                            /* isIsOperator */ false);
+                            return {
+                                type: narrowTypeForLiteralComparison(evaluator, type, leftType, adjIsPositiveTest, 
+                                /* isIsOperator */ false),
+                                isIncomplete: !!leftTypeResult.isIncomplete,
+                            };
                         };
                     }
                 }
@@ -152,21 +188,29 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     !testExpression.leftExpression.trailingComma &&
                     testExpression.leftExpression.items[0].argumentCategory === 0 /* Simple */ &&
                     ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
-                    const indexType = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression).type;
+                    const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
+                    const indexType = indexTypeResult.type;
                     if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
                         if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
                             const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
                             if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 return (type) => {
-                                    return narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest);
+                                    return {
+                                        type: narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
+                                        isIncomplete: !!indexTypeResult.isIncomplete,
+                                    };
                                 };
                             }
                         }
                         else if (types_1.ClassType.isBuiltIn(indexType, 'int')) {
-                            const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                            const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                            const rightType = rightTypeResult.type;
                             if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 return (type) => {
-                                    return narrowTypeForDiscriminatedTupleComparison(evaluator, type, indexType, rightType, adjIsPositiveTest);
+                                    return {
+                                        type: narrowTypeForDiscriminatedTupleComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
+                                        isIncomplete: !!rightTypeResult.isIncomplete,
+                                    };
                                 };
                             }
                         }
@@ -181,12 +225,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 testExpression.rightExpression.isInteger) {
                 const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
                 if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                    const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                    const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* DoNotSpecialize */);
+                    const callType = callTypeResult.type;
                     if ((0, types_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
                         const tupleLength = testExpression.rightExpression.value;
                         if (typeof tupleLength === 'number') {
                             return (type) => {
-                                return narrowTypeForTupleLength(evaluator, type, tupleLength, adjIsPositiveTest);
+                                return {
+                                    type: narrowTypeForTupleLength(evaluator, type, tupleLength, adjIsPositiveTest),
+                                    isIncomplete: !!callTypeResult.isIncomplete,
+                                };
                             };
                         }
                     }
@@ -196,11 +244,15 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             if (equalsOrNotEqualsOperator &&
                 testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
                 ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
-                const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                const rightType = rightTypeResult.type;
                 const memberName = testExpression.leftExpression.memberName;
                 if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                     return (type) => {
-                        return narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest);
+                        return {
+                            type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
+                            isIncomplete: !!rightTypeResult.isIncomplete,
+                        };
                     };
                 }
             }
@@ -208,13 +260,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             // an enum or bool literal
             if (testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
                 ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
-                const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                const rightType = rightTypeResult.type;
                 const memberName = testExpression.leftExpression.memberName;
                 if ((0, types_1.isClassInstance)(rightType) &&
                     (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
                     rightType.literalValue !== undefined) {
                     return (type) => {
-                        return narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest);
+                        return {
+                            type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
+                            isIncomplete: !!rightTypeResult.isIncomplete,
+                        };
                     };
                 }
             }
@@ -226,27 +282,38 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 testExpression.rightExpression.constType === 26 /* None */) {
                 const memberName = testExpression.leftExpression.memberName;
                 return (type) => {
-                    return narrowTypeForDiscriminatedFieldNoneComparison(evaluator, type, memberName.value, adjIsPositiveTest);
+                    return {
+                        type: narrowTypeForDiscriminatedFieldNoneComparison(evaluator, type, memberName.value, adjIsPositiveTest),
+                        isIncomplete: false,
+                    };
                 };
             }
         }
         if (testExpression.operator === 41 /* In */ || testExpression.operator === 42 /* 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 rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                const rightType = rightTypeResult.type;
                 const adjIsPositiveTest = testExpression.operator === 41 /* In */ ? isPositiveTest : !isPositiveTest;
                 return (type) => {
-                    return narrowTypeForContainerType(evaluator, type, rightType, adjIsPositiveTest);
+                    return {
+                        type: narrowTypeForContainerType(evaluator, type, rightType, adjIsPositiveTest),
+                        isIncomplete: !!rightTypeResult.isIncomplete,
+                    };
                 };
             }
             if (ParseTreeUtils.isMatchingExpression(reference, testExpression.rightExpression)) {
                 // Look for <string literal> in y where y is a union that contains
                 // one or more TypedDicts.
-                const leftType = evaluator.getTypeOfExpression(testExpression.leftExpression).type;
+                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;
                     return (type) => {
-                        return narrowTypeForTypedDictKey(evaluator, type, types_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest);
+                        return {
+                            type: narrowTypeForTypedDictKey(evaluator, type, types_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
+                            isIncomplete: !!leftTypeResult.isIncomplete,
+                        };
                     };
                 }
             }
@@ -261,24 +328,43 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             const arg0Expr = testExpression.arguments[0].valueExpression;
             const arg1Expr = testExpression.arguments[1].valueExpression;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callType = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
+                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 arg1Type = evaluator.getTypeOfExpression(arg1Expr, 8 /* EvaluateStringLiteralAsType */ |
+                    const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 8 /* EvaluateStringLiteralAsType */ |
                         32 /* ParamSpecDisallowed */ |
-                        128 /* TypeVarTupleDisallowed */).type;
+                        128 /* TypeVarTupleDisallowed */);
+                    const arg1Type = arg1TypeResult.type;
                     const classTypeList = getIsInstanceClassTypes(arg1Type);
+                    const isIncomplete = !!callTypeResult.isIncomplete || !!arg1TypeResult.isIncomplete;
                     if (classTypeList) {
                         return (type) => {
                             const narrowedType = narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, 
                             /* allowIntersections */ false, testExpression);
                             if (!(0, types_1.isNever)(narrowedType)) {
-                                return narrowedType;
+                                return {
+                                    type: narrowedType,
+                                    isIncomplete,
+                                };
                             }
                             // Try again with intersection types allowed.
-                            return narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, 
-                            /* allowIntersections */ true, testExpression);
+                            return {
+                                type: narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, 
+                                /* allowIntersections */ true, testExpression),
+                                isIncomplete,
+                            };
+                        };
+                    }
+                    else if (isIncomplete) {
+                        // If the type is incomplete, it may include unknowns, which will result
+                        // in classTypeList being undefined.
+                        return (type) => {
+                            return {
+                                type,
+                                isIncomplete: true,
+                            };
                         };
                     }
                 }
@@ -288,7 +374,8 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
         if (testExpression.arguments.length === 1) {
             const arg0Expr = testExpression.arguments[0].valueExpression;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callType = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
+                const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && callType.details.builtInName === 'callable') {
                     return (type) => {
                         let narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
@@ -298,7 +385,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                             narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
                             /* allowIntersections */ true);
                         }
-                        return narrowedType;
+                        return { type: narrowedType, isIncomplete: !!callTypeResult.isIncomplete };
                     };
                 }
             }
@@ -306,10 +393,14 @@ 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 callType = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
+                const callType = callTypeResult.type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
                     return (type) => {
-                        return narrowTypeForTruthiness(evaluator, type, isPositiveTest);
+                        return {
+                            type: narrowTypeForTruthiness(evaluator, type, isPositiveTest),
+                            isIncomplete: !!callTypeResult.isIncomplete,
+                        };
                     };
                 }
             }
@@ -325,7 +416,8 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         (0, types_1.isClassInstance)(type.details.declaredReturnType) &&
                         types_1.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'StrictTypeGuard']));
                 };
-                const callType = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
+                const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
                     isPossiblyTypeGuard = true;
                 }
@@ -335,14 +427,19 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
                 if (isPossiblyTypeGuard) {
                     // Evaluate the type guard call expression.
-                    const functionReturnType = evaluator.getTypeOfExpression(testExpression).type;
+                    const functionReturnTypeResult = evaluator.getTypeOfExpression(testExpression);
+                    const functionReturnType = functionReturnTypeResult.type;
                     if ((0, types_1.isClassInstance)(functionReturnType) &&
                         types_1.ClassType.isBuiltIn(functionReturnType, 'bool') &&
                         functionReturnType.typeGuardType) {
                         const isStrictTypeGuard = !!functionReturnType.isStrictTypeGuard;
                         const typeGuardType = functionReturnType.typeGuardType;
+                        const isIncomplete = !!callTypeResult.isIncomplete || !!functionReturnTypeResult.isIncomplete;
                         return (type) => {
-                            return narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard);
+                            return {
+                                type: narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard),
+                                isIncomplete,
+                            };
                         };
                     }
                 }
@@ -351,7 +448,10 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
     }
     if (ParseTreeUtils.isMatchingExpression(reference, testExpression)) {
         return (type) => {
-            return narrowTypeForTruthiness(evaluator, type, isPositiveTest);
+            return {
+                type: narrowTypeForTruthiness(evaluator, type, isPositiveTest),
+                isIncomplete: false,
+            };
         };
     }
     // Is this a reference to an aliased conditional expression (a local variable
@@ -557,6 +657,38 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
         return undefined;
     });
 }
+// Handle type narrowing for expressions of the form "x is ..." and "x is not ...".
+function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
+    const expandedType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+    });
+    return evaluator.mapSubtypesExpandTypeVars(expandedType, 
+    /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            // We need to assume that "Any" is always both None and not None,
+            // so it matches regardless of whether the test is positive or negative.
+            return subtype;
+        }
+        // If this is a TypeVar that isn't constrained, use the unexpanded
+        // TypeVar. For all other cases (including constrained TypeVars),
+        // use the expanded subtype.
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+            ? unexpandedSubtype
+            : subtype;
+        // See if it's a match for object.
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
+            return isPositiveTest
+                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
+                : adjustedSubtype;
+        }
+        const isEllipsis = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'ellipsis');
+        // See if it's a match for "...".
+        if (isEllipsis === isPositiveTest) {
+            return subtype;
+        }
+        return undefined;
+    });
+}
 // The "isinstance" and "issubclass" calls support two forms - a simple form
 // that accepts a single class, and a more complex form that accepts a tuple
 // of classes (including arbitrarily-nested tuples). This method determines
@@ -700,8 +832,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                                 /* isTypeArgumentExplicit */ false);
                                 if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, varType, typeVarContext, 
                                 /* liveTypeVarScopes */ undefined)) {
-                                    specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, 
-                                    /* unknownIfNotFound */ true);
+                                    specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, { unknownIfNotFound: true });
                                 }
                             }
                         }
@@ -882,7 +1013,12 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
         }
         if (isInstanceCheck) {
             if ((0, types_1.isNoneInstance)(subtype)) {
-                const containsNoneType = classTypeList.some((t) => (0, types_1.isNoneTypeClass)(t));
+                const containsNoneType = classTypeList.some((t) => {
+                    if ((0, types_1.isNoneTypeClass)(t)) {
+                        return true;
+                    }
+                    return (0, types_1.isInstantiableClass)(t) && types_1.ClassType.isBuiltIn(t, 'NoneType');
+                });
                 if (isPositiveTest) {
                     return containsNoneType ? subtype : undefined;
                 }