@zzzen/pyright-internal 1.2.0-dev.20230212 → 1.2.0-dev.20230226

package/dist/analyzer/typeEvaluator.js

@@ -121,12 +121,12 @@ const binaryOperatorMap = {
     [8 /* BitwiseXor */]: ['__xor__', '__rxor__'],
     [17 /* LeftShift */]: ['__lshift__', '__rlshift__'],
     [31 /* RightShift */]: ['__rshift__', '__rrshift__'],
-    [12 /* Equals */]: ['__eq__', '__ne__'],
-    [28 /* NotEquals */]: ['__ne__', '__eq__'],
-    [20 /* LessThan */]: ['__lt__', '__ge__'],
-    [21 /* LessThanOrEqual */]: ['__le__', '__gt__'],
-    [15 /* GreaterThan */]: ['__gt__', '__le__'],
-    [16 /* GreaterThanOrEqual */]: ['__ge__', '__lt__'],
+    [12 /* Equals */]: ['__eq__', '__eq__'],
+    [28 /* NotEquals */]: ['__ne__', '__ne__'],
+    [20 /* LessThan */]: ['__lt__', '__gt__'],
+    [21 /* LessThanOrEqual */]: ['__le__', '__ge__'],
+    [15 /* GreaterThan */]: ['__gt__', '__lt__'],
+    [16 /* GreaterThanOrEqual */]: ['__ge__', '__le__'],
 };
 // Map of operators that always return a bool result.
 const booleanOperatorMap = {
@@ -298,8 +298,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function isTypeCached(node) {
-        const cachedEntry = readTypeCacheEntry(node);
-        return cachedEntry !== undefined && !cachedEntry.typeResult.isIncomplete;
+        const cacheEntry = readTypeCacheEntry(node);
+        if (!cacheEntry) {
+            return false;
+        }
+        return (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount);
     }
     function readTypeCache(node, flags) {
         var _a, _b;
@@ -689,7 +692,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeResult.type = types_1.UnknownType.create();
                 }
             }
-            if (!types_1.TypeBase.isInstantiable(typeResult.type)) {
+            if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
                 const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
                     types_1.ClassType.isTupleClass(typeResult.type) &&
                     ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
@@ -2027,7 +2030,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const diag = new diagnostic_1.DiagnosticAddendum();
         if ((0, types_1.isUnion)(type)) {
             (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-                if (!types_1.TypeBase.isInstantiable(subtype)) {
+                if (!(0, typeUtils_1.isEffectivelyInstantiable)(subtype)) {
                     diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeNotClass().format({ type: printType(subtype) }));
                 }
             });
@@ -3703,8 +3706,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Determine whether to replace Self variables with a specific
                 // class. Avoid doing this if there's a "bindToType" specified
                 // because that case is used for super() calls where we want
-                // to leave the Self type generic (not specialized).
-                const selfClass = bindToType ? undefined : classType;
+                // to leave the Self type generic (not specialized). We'll also
+                // skip this for __new__ methods because they are not bound
+                // to the class but rather assume the type of the cls argument.
+                const selfClass = bindToType || memberName === '__new__' ? undefined : classType;
                 const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
                 if (typeResult) {
                     type = typeResult.type;
@@ -4007,6 +4012,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If this function is an instance member (e.g. a lambda that was
                 // assigned to an instance variable), don't perform any binding.
                 if (!isAccessedThroughObject || (memberInfo && !memberInfo.isInstanceMember)) {
+                    // Skip binding if the class appears to be a metaclass (i.e. a subclass of
+                    // `type`) because the first parameter of instance methods in a metaclass
+                    // are not `self` instances.
+                    const isMetaclass = !isAccessedThroughObject &&
+                        (0, types_1.isClass)(baseTypeClass) &&
+                        (flags & 16 /* TreatConstructorAsClassMethod */) === 0 &&
+                        baseTypeClass.details.mro.some((mroType) => (0, types_1.isClass)(mroType) && types_1.ClassType.isBuiltIn(mroType, 'type'));
+                    if (isMetaclass) {
+                        return concreteSubtype;
+                    }
                     return bindFunctionToClassOrObject(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(baseTypeClass) : baseTypeClass, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, 
                     /* recursionCount */ undefined, treatConstructorAsClassMember, bindToType);
                 }
@@ -5185,7 +5200,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
         const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgumentExpectingType(node.arguments[1]).type);
-        if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type, { treatAnySameAsUnknown: true })) {
+        if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type, { treatAnySameAsUnknown: true, ignorePseudoGeneric: true })) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.assertTypeTypeMismatch().format({
                 expected: printType(assertedType),
                 received: printType(arg0TypeResult.type),
@@ -5243,7 +5258,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (expectedRevealType) {
-            if (!(0, types_1.isTypeSame)(expectedRevealType, type)) {
+            if (!(0, types_1.isTypeSame)(expectedRevealType, type, { ignorePseudoGeneric: true })) {
                 const expectedRevealTypeText = printType(expectedRevealType);
                 addError(localize_1.Localizer.Diagnostic.revealTypeExpectedTypeMismatch().format({
                     expected: expectedRevealTypeText,
@@ -5401,9 +5416,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: resultIsInstance
                         ? types_1.ClassType.cloneAsInstance(lookupResults.classType)
                         : lookupResults.classType,
-                    bindToType: resultIsInstance && bindToType && (0, types_1.isInstantiableClass)(bindToType)
-                        ? types_1.ClassType.cloneAsInstance(bindToType)
-                        : bindToType,
+                    bindToType: bindToType
+                        ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, !resultIsInstance), bindToType.condition)
+                        : undefined,
                 };
             }
         }
@@ -5676,6 +5691,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
             effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(lastMatch.overload));
+            if (lastMatch.overload.details.constructorTypeVarScopeId) {
+                effectiveTypeVarContext.addSolveForScope(lastMatch.overload.details.constructorTypeVarScopeId);
+            }
             effectiveTypeVarContext.unlock();
             return validateFunctionArgumentTypesWithExpectedType(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         };
@@ -6394,6 +6412,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 case 3 /* None */: {
+                    if (types_1.TypeBase.isInstantiable(expandedSubtype)) {
+                        if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
+                            const functionResult = validateCallArguments(errorNode, argList, { type: noneType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                            if (functionResult.isTypeIncomplete) {
+                                isTypeIncomplete = true;
+                            }
+                            if (functionResult.argumentErrors) {
+                                argumentErrors = true;
+                            }
+                        }
+                        return types_1.NoneType.createInstance();
+                    }
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalCall, diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.Localizer.Diagnostic.noneNotCallable(), errorNode);
                     return undefined;
                 }
@@ -8249,9 +8279,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
-            if ((0, types_1.isInstantiableClass)(specializedType) ||
-                (0, types_1.isAnyOrUnknown)(specializedType) ||
-                ((0, types_1.isClassInstance)(specializedType) && types_1.ClassType.isBuiltIn(specializedType, 'type'))) {
+            if ((0, typeUtils_1.isEffectivelyInstantiable)(specializedType)) {
                 classType.details.baseClasses.push(specializedType);
             }
             else {
@@ -8523,9 +8551,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const diag = new diagnostic_1.DiagnosticAddendum();
-        // Don't use literal math if either of the operand types are
-        // incomplete because we may be evaluating types within a loop,
-        // so the literal values may change each time.
+        // Don't use literal math if either of the operation is within a loop
+        // because the literal values may change each time.
         const isLiteralMathAllowed = !ParseTreeUtils.isWithinLoop(node);
         // Don't special-case tuple __add__ if the left type is a union. This
         // can result in an infinite loop if we keep creating new tuple types
@@ -8632,11 +8659,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // If the LHS class didn't support the magic method for augmented
                         // assignment, fall back on the normal binary expression evaluator.
                         const binaryOperator = operatorMap[node.operator][1];
-                        // Don't use literal math if either of the operand types are
-                        // incomplete because we may be evaluating types within a loop,
-                        // so the literal values may change each time.
-                        const isLiteralMathAllowed = !leftTypeResult.isIncomplete &&
-                            !rightTypeResult.isIncomplete &&
+                        // Don't use literal math if either of the operation is within a loop
+                        // because the literal values may change each time.
+                        const isLiteralMathAllowed = !ParseTreeUtils.isWithinLoop(node) &&
                             (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
                                 maxLiteralMathSubtypeCount;
                         // Don't special-case tuple __add__ if the left type is a union. This
@@ -9516,7 +9541,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typesToCombine = [];
         let isIncomplete = false;
         let typeErrors = false;
-        if (isNodeReachable(node.ifExpression)) {
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.testExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+        if (constExprValue !== false && isNodeReachable(node.ifExpression)) {
             const ifType = getTypeOfExpression(node.ifExpression, flags, inferenceContext);
             typesToCombine.push(ifType.type);
             if (ifType.isIncomplete) {
@@ -9526,7 +9553,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeErrors = true;
             }
         }
-        if (isNodeReachable(node.elseExpression)) {
+        if (constExprValue !== true && isNodeReachable(node.elseExpression)) {
             const elseType = getTypeOfExpression(node.elseExpression, flags, inferenceContext);
             typesToCombine.push(elseType.type);
             if (elseType.isIncomplete) {
@@ -9548,14 +9575,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (functionTypeInfo) {
                 const returnType = types_1.FunctionType.getSpecializedReturnType(functionTypeInfo.functionType);
                 if (returnType) {
+                    expectedYieldType = (0, typeUtils_1.getGeneratorYieldType)(returnType, !!enclosingFunction.isAsync);
                     const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(returnType);
-                    if (generatorTypeArgs) {
-                        if (generatorTypeArgs.length >= 1) {
-                            expectedYieldType = generatorTypeArgs[0];
-                        }
-                        if (generatorTypeArgs.length >= 2) {
-                            sentType = generatorTypeArgs[1];
-                        }
+                    if (generatorTypeArgs && generatorTypeArgs.length >= 2) {
+                        sentType = generatorTypeArgs[1];
                     }
                 }
             }
@@ -10073,7 +10096,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!validateTypeArg(typeArgs[0])) {
             typeArg0Type = types_1.UnknownType.create();
         }
-        else if (!types_1.TypeBase.isInstantiable(typeArg0Type)) {
+        else if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeArg0Type)) {
             addExpectedClassDiagnostic(typeArg0Type, typeArgs[0].node);
             typeArg0Type = types_1.UnknownType.create();
         }
@@ -10515,7 +10538,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!validateTypeArg(typeArg, { allowVariadicTypeVar: true, allowUnpackedTuples: true })) {
                 typeArgType = types_1.UnknownType.create();
             }
-            else if (!types_1.TypeBase.isInstantiable(typeArgType)) {
+            else if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeArgType)) {
                 addExpectedClassDiagnostic(typeArgType, typeArg.node);
                 typeArgType = types_1.UnknownType.create();
             }
@@ -10779,7 +10802,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // If the entire statement has already been evaluated, don't
         // re-evaluate it.
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         let flags = 0 /* None */;
@@ -11007,7 +11030,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return aliasType;
     }
     function evaluateTypesForAugmentedAssignment(node) {
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         const destTypeResult = getTypeOfAugmentedAssignment(node, /* inferenceContext */ undefined);
@@ -11118,7 +11141,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     argType = (0, types_1.removeUnbound)(argType);
                 }
                 if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
-                    if (!(0, types_1.isInstantiableClass)(argType)) {
+                    if ((0, types_1.isClass)(argType) && types_1.TypeBase.isInstance(argType) && types_1.ClassType.isBuiltIn(argType, 'type')) {
+                        argType =
+                            argType.typeArguments && argType.typeArguments.length > 0
+                                ? argType.typeArguments[0]
+                                : types_1.UnknownType.create();
+                    }
+                    else if (!(0, types_1.isInstantiableClass)(argType)) {
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.baseClassInvalid(), arg);
                         argType = types_1.UnknownType.create();
                     }
@@ -11919,10 +11948,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
             functionFlags |= 16 /* Generator */;
         }
-        // Special-case magic method __class_getitem__, which is implicitly a class method.
-        if (containingClassNode && node.name.value === '__class_getitem__') {
-            functionFlags |= 2 /* ClassMethod */;
-        }
         if (fileInfo.isStubFile) {
             functionFlags |= 2048 /* StubDefinition */;
         }
@@ -12445,15 +12470,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getFunctionFlagsFromDecorators(node, isInClass) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         let flags = 0 /* None */;
-        // The "__new__" magic method is not an instance method.
-        // It acts as a static method instead.
-        if (node.name.value === '__new__' && isInClass) {
-            flags |= 1 /* ConstructorMethod */;
-        }
-        // The "__init_subclass__" magic method is not an instance method.
-        // It acts an an implicit class method instead.
-        if (node.name.value === '__init_subclass__' && isInClass) {
-            flags |= 2 /* ClassMethod */;
+        if (isInClass) {
+            // The "__new__" magic method is not an instance method.
+            // It acts as a static method instead.
+            if (node.name.value === '__new__') {
+                flags |= 1 /* ConstructorMethod */;
+            }
+            // Several magic methods are treated as class methods implicitly
+            // by the runtime. Check for these here.
+            const implicitClassMethods = ['__init_subclass__', '__class_getitem__'];
+            if (implicitClassMethods.some((name) => node.name.value === name)) {
+                flags |= 2 /* ClassMethod */;
+            }
         }
         for (const decoratorNode of node.decorators) {
             // Some stub files (e.g. builtins.pyi) rely on forward declarations of decorators.
@@ -12785,14 +12813,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const inferredReturnTypes = [];
                         if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.returnStatements) {
                             functionDecl.returnStatements.forEach((returnNode) => {
-                                var _a;
                                 if (isNodeReachable(returnNode)) {
                                     if (returnNode.returnExpression) {
                                         const returnTypeResult = getTypeOfExpression(returnNode.returnExpression);
                                         if (returnTypeResult.isIncomplete) {
                                             isIncomplete = true;
                                         }
-                                        inferredReturnTypes.push((_a = returnTypeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create());
+                                        let returnType = returnTypeResult.type;
+                                        // If the return type includes an instance of a class with isEmptyContainer
+                                        // set, clear that because we don't want this flag to "leak" into the
+                                        // inferred return type.
+                                        returnType = (0, typeUtils_1.mapSubtypes)(returnType, (subtype) => {
+                                            if ((0, types_1.isClassInstance)(subtype) && subtype.isEmptyContainer) {
+                                                return types_1.ClassType.cloneForSpecialization(subtype, subtype.typeArguments, !!subtype.isTypeArgumentExplicit, subtype.includeSubclasses, subtype.tupleTypeArguments, 
+                                                /* isEmptyContainer */ false);
+                                            }
+                                            return subtype;
+                                        });
+                                        inferredReturnTypes.push(returnType);
                                     }
                                     else {
                                         inferredReturnTypes.push(types_1.NoneType.createInstance());
@@ -12900,7 +12938,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function evaluateTypesForForStatement(node) {
         var _a, _b;
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         const iteratorTypeResult = getTypeOfExpression(node.iterableExpression);
@@ -12911,7 +12949,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function evaluateTypesForExceptStatement(node) {
         // This should be called only if the except node has a target exception.
         (0, debug_1.assert)(node.typeExpression !== undefined);
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         const exceptionTypeResult = getTypeOfExpression(node.typeExpression);
@@ -12959,7 +12997,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node, { type: targetType }, 0 /* None */);
     }
     function evaluateTypesForWithStatement(node) {
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         const exprTypeResult = getTypeOfExpression(node.expression);
@@ -13025,7 +13063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function evaluateTypesForImportAs(node) {
         var _a;
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         let symbolNameNode;
@@ -13057,7 +13095,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function evaluateTypesForImportFromAs(node) {
         var _a;
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         const aliasNode = node.alias || node.name;
@@ -13113,7 +13151,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForMatchStatement(node) {
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         const subjectTypeResult = getTypeOfExpression(node.subjectExpression);
@@ -13128,19 +13166,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForCaseStatement(node) {
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         if (!node.parent || node.parent.nodeType !== 63 /* Match */) {
             (0, debug_1.fail)('Expected parent of case statement to be match statement');
             return;
         }
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const subjectTypeResult = getTypeOfExpression(node.parent.subjectExpression);
         let subjectType = subjectTypeResult.type;
         // Apply negative narrowing for each of the cases prior to the current one
         // except for those that have a guard expression.
         for (const caseStatement of node.parent.cases) {
             if (caseStatement === node) {
+                if (fileInfo.diagnosticRuleSet.reportUnnecessaryComparison !== 'none') {
+                    (0, patternMatching_1.checkForUnusedPattern)(evaluatorInterface, node.pattern, subjectType);
+                }
                 break;
             }
             if (!caseStatement.guardExpression) {
@@ -13162,7 +13204,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportFrom(node) {
-        if (readTypeCache(node, 0 /* None */)) {
+        if (isTypeCached(node)) {
             return;
         }
         // Use the first element of the name parts as the symbol.
@@ -14944,7 +14986,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Infer the type.
         const typesToCombine = [];
         const decls = symbol.getDeclarations();
-        const isFinalVar = (0, symbolUtils_1.isFinalVariable)(symbol);
         let isIncomplete = false;
         let sawPendingEvaluation = false;
         let includesVariableDecl = false;
@@ -15042,7 +15083,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 if (!fileInfo.isTypingStubFile) {
                                     includesVariableDecl = true;
                                 }
-                                let isConstant = resolvedDecl.type === 1 /* Variable */ && !!resolvedDecl.isConstant;
+                                let isConstant = false;
+                                if (resolvedDecl.type === 1 /* Variable */) {
+                                    if (resolvedDecl.isConstant || resolvedDecl.isFinal) {
+                                        isConstant = true;
+                                    }
+                                }
                                 // Treat enum values declared within an enum class as though they are const even
                                 // though they may not be named as such.
                                 if ((0, types_1.isClassInstance)(type) &&
@@ -15052,7 +15098,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }
                                 // If the symbol is constant, we can retain the literal
                                 // value. Otherwise, strip literal values to widen the type.
-                                if (types_1.TypeBase.isInstance(type) && !isExplicitTypeAlias && !isConstant && !isFinalVar) {
+                                if (types_1.TypeBase.isInstance(type) && !isExplicitTypeAlias && !isConstant) {
                                     type = stripLiteralValue(type);
                                 }
                             }
@@ -15695,12 +15741,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // specified inheritance chain, taking into account its type arguments.
     function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         let curSrcType = srcType;
-        let curTypeVarContext = destTypeVarContext;
+        let curDestTypeVarContext = destTypeVarContext;
         let effectiveFlags = flags;
         inferTypeParameterVarianceForClass(destType);
         effectiveFlags |= 8 /* SkipSolveTypeVars */;
         if (!destTypeVarContext) {
-            curTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
+            curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
             effectiveFlags &= ~8 /* SkipSolveTypeVars */;
         }
         else {
@@ -15711,6 +15757,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         for (let ancestorIndex = inheritanceChain.length - 1; ancestorIndex >= 0; ancestorIndex--) {
             const ancestorType = inheritanceChain[ancestorIndex];
+            const curSrcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(curSrcType));
             // If we've hit an "unknown", all bets are off, and we need to assume
             // that the type is assignable.
             if ((0, types_1.isUnknown)(ancestorType)) {
@@ -15728,7 +15775,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Handle built-in types that support arbitrary numbers
             // of type parameters like Tuple.
             if (ancestorIndex === 0 && destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
-                return assignTupleTypeArgs(destType, curSrcType, diag, curTypeVarContext, flags, recursionCount);
+                return assignTupleTypeArgs(destType, curSrcType, diag, curDestTypeVarContext, flags, recursionCount);
             }
             // If there are no type parameters on this class, we're done.
             const ancestorTypeParams = types_1.ClassType.getTypeParameters(ancestorType);
@@ -15740,12 +15787,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             }
             // Validate that the type arguments match.
-            if (!verifyTypeArgumentsAssignable(ancestorType, curSrcType, diag, curTypeVarContext, 
-            /* srcTypeVarContext */ undefined, effectiveFlags, recursionCount)) {
+            if (!verifyTypeArgumentsAssignable(ancestorType, curSrcType, diag, curDestTypeVarContext, curSrcTypeVarContext, effectiveFlags, recursionCount)) {
                 return false;
             }
             // Allocate a new type var map for the next time through the loop.
-            curTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(ancestorType));
+            curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(ancestorType));
             effectiveFlags &= ~8 /* SkipSolveTypeVars */;
         }
         if (destType.typeArguments) {
@@ -16108,8 +16154,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isUnion)(destType)) {
             return assignToUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, originalFlags, recursionCount);
         }
-        if ((0, types_1.isNoneInstance)(destType) && (0, types_1.isNoneInstance)(srcType)) {
-            return true;
+        if ((0, types_1.isNoneInstance)(destType)) {
+            if ((0, types_1.isNoneInstance)(srcType)) {
+                return true;
+            }
+            if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'NoneType')) {
+                return true;
+            }
         }
         if ((0, types_1.isNoneTypeClass)(destType)) {
             if ((0, types_1.isNoneTypeClass)(srcType)) {