@zzzen/pyright-internal 1.2.0-dev.20220710 → 1.2.0-dev.20220717

package/dist/analyzer/typeEvaluator.js

@@ -182,6 +182,9 @@ const maxReturnTypeInferenceArgumentCount = 6;
 // when its parameters are unannotated? We want to keep this
 // pretty low because this can be very costly.
 const maxReturnTypeInferenceCodeFlowComplexity = 8;
+// What is the max number of return types cached per function
+// when using call-site inference?
+const maxCallSiteReturnTypeCacheSize = 8;
 // How many entries in a list, set, or dict should we examine
 // when inferring the type? We need to cut it off at some point
 // to avoid excessive computation.
@@ -209,7 +212,7 @@ const maxLiteralMathSubtypeCount = 64;
 // off code flow analysis at some point for code flow graphs that are too
 // complex. Otherwise we risk overflowing the stack or incurring extremely
 // long analysis times. This number has been tuned empirically.
-exports.maxCodeComplexity = 1024;
+exports.maxCodeComplexity = 768;
 function createTypeEvaluator(importLookup, evaluatorOptions) {
     const symbolResolutionStack = [];
     const typeCacheFlags = new Map();
@@ -231,6 +234,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let functionObj;
     let tupleClassType;
     let boolClassType;
+    let intClassType;
     let strClassType;
     let dictClassType;
     let typedDictClassType;
@@ -452,6 +456,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             noneType = getTypeshedType(node, 'NoneType') || types_1.AnyType.create();
             tupleClassType = getBuiltInType(node, 'tuple');
             boolClassType = getBuiltInType(node, 'bool');
+            intClassType = getBuiltInType(node, 'int');
             strClassType = getBuiltInType(node, 'str');
             dictClassType = getBuiltInType(node, 'dict');
             typedDictClassType = getTypingType(node, '_TypedDict');
@@ -1272,10 +1277,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addOneFunctionToSignature(type);
             }
             else {
-                type.overloads.forEach((func) => {
-                    if (types_1.FunctionType.isOverloaded(func)) {
-                        addOneFunctionToSignature(func);
-                    }
+                types_1.OverloadedFunctionType.getOverloads(type).forEach((func) => {
+                    addOneFunctionToSignature(func);
                 });
             }
         }
@@ -1477,13 +1480,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return subtype;
             }
             if ((0, types_1.isClassInstance)(subtype)) {
-                const awaitReturnType = getSpecializedReturnType(subtype, '__await__', errorNode);
+                const awaitReturnType = getSpecializedReturnType(subtype, '__await__', [], errorNode);
                 if (awaitReturnType) {
                     if ((0, types_1.isAnyOrUnknown)(awaitReturnType)) {
                         return awaitReturnType;
                     }
                     if ((0, types_1.isClassInstance)(awaitReturnType)) {
-                        const iterReturnType = getSpecializedReturnType(awaitReturnType, '__iter__', errorNode);
+                        const iterReturnType = getSpecializedReturnType(awaitReturnType, '__iter__', [], errorNode);
                         if (iterReturnType) {
                             const generatorReturnType = getReturnTypeFromGenerator(awaitReturnType);
                             if (generatorReturnType) {
@@ -1528,18 +1531,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         subtype.tupleTypeArguments.length === 0) {
                         return types_1.NeverType.createNever();
                     }
-                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, errorNode);
+                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, [], errorNode);
                 }
                 else if (types_1.TypeBase.isInstantiable(subtype) &&
                     subtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(subtype.details.effectiveMetaclass)) {
-                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, errorNode, subtype);
+                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, [], errorNode, subtype);
                 }
                 if (!iterReturnType) {
                     // There was no __iter__. See if we can fall back to
                     // the __getitem__ method instead.
-                    if ((0, types_1.isClassInstance)(subtype)) {
-                        const getItemReturnType = getSpecializedReturnType(subtype, '__getitem__', errorNode);
+                    if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
+                        const getItemReturnType = getSpecializedReturnType(subtype, '__getitem__', [
+                            {
+                                argumentCategory: 0 /* Simple */,
+                                typeResult: {
+                                    type: intClassType && (0, types_1.isInstantiableClass)(intClassType)
+                                        ? types_1.ClassType.cloneAsInstance(intClassType)
+                                        : types_1.UnknownType.create(),
+                                },
+                            },
+                        ], errorNode);
                         if (getItemReturnType) {
                             return getItemReturnType;
                         }
@@ -1554,7 +1566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return subtype;
                         }
                         if ((0, types_1.isClassInstance)(subtype)) {
-                            const nextReturnType = getSpecializedReturnType(subtype, nextMethodName, errorNode);
+                            const nextReturnType = getSpecializedReturnType(subtype, nextMethodName, [], errorNode);
                             if (!nextReturnType) {
                                 iterReturnTypeDiag.addMessage(localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
                                     name: nextMethodName,
@@ -1607,12 +1619,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClass)(subtype)) {
                 let iterReturnType;
                 if (types_1.TypeBase.isInstance(subtype)) {
-                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, errorNode);
+                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, [], errorNode);
                 }
                 else if (types_1.TypeBase.isInstantiable(subtype) &&
                     subtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(subtype.details.effectiveMetaclass)) {
-                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, errorNode, subtype);
+                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, [], errorNode, subtype);
                 }
                 if (iterReturnType) {
                     return makeTopLevelTypeVarsConcrete(iterReturnType);
@@ -1760,6 +1772,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unreachableCode(), textRange);
         }
     }
+    function addUnreachableCode(node, textRange) {
+        if (!isDiagnosticSuppressedForNode(node)) {
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            fileInfo.diagnosticSink.addUnreachableCodeWithTextRange(localize_1.Localizer.Diagnostic.unreachableCode(), textRange);
+        }
+    }
     function addDeprecated(message, node) {
         if (!isDiagnosticSuppressedForNode(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -2514,7 +2532,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function getSpecializedReturnType(objType, memberName, errorNode, bindToClass) {
+    function getSpecializedReturnType(objType, memberName, argList, errorNode, bindToClass) {
         const classMember = (0, typeUtils_1.lookUpObjectMember)(objType, memberName, 8 /* SkipInstanceVariables */);
         if (!classMember) {
             return undefined;
@@ -2523,13 +2541,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isAnyOrUnknown)(memberType)) {
             return memberType;
         }
-        if ((0, types_1.isFunction)(memberType)) {
+        if ((0, types_1.isFunction)(memberType) || (0, types_1.isOverloadedFunction)(memberType)) {
             const methodType = bindFunctionToClassOrObject(bindToClass || objType, memberType, classMember && (0, types_1.isInstantiableClass)(classMember.classType) ? classMember.classType : undefined, errorNode, 
             /* recursionCount */ undefined, 
             /* treatConstructorAsClassMember */ false, 
             /* firstParamType */ bindToClass);
             if (methodType) {
-                return getFunctionEffectiveReturnType(methodType);
+                if ((0, types_1.isOverloadedFunction)(methodType)) {
+                    if (errorNode) {
+                        const bestOverload = getBestOverloadForArguments(errorNode, methodType, argList);
+                        if (bestOverload) {
+                            return getFunctionEffectiveReturnType(bestOverload);
+                        }
+                    }
+                }
+                else {
+                    return getFunctionEffectiveReturnType(methodType);
+                }
             }
         }
         return undefined;
@@ -3701,7 +3729,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isFinal = types_1.FunctionType.isFinal(concreteSubtype);
                     }
                     else {
-                        const impl = concreteSubtype.overloads.find((f) => !types_1.FunctionType.isOverloaded(f));
+                        const impl = types_1.OverloadedFunctionType.getImplementation(concreteSubtype);
                         if (impl) {
                             isFinal = types_1.FunctionType.isFinal(impl);
                         }
@@ -4444,7 +4472,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeResult.isIncomplete) {
                     isPositionalIndexTypeIncomplete = true;
                 }
-                const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg) || types_1.UnknownType.create();
+                const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg.valueExpression) || types_1.UnknownType.create();
                 tupleEntries.push(iterableType);
             });
             positionalIndexType = makeTupleObject(tupleEntries, unpackedListArgs.length > 0);
@@ -5086,7 +5114,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     bindToType: resultIsInstance && bindToType && (0, types_1.isInstantiableClass)(bindToType)
                         ? types_1.ClassType.cloneAsInstance(bindToType)
                         : bindToType,
-                    isSuperCall: true,
                 };
             }
         }
@@ -5098,7 +5125,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
                 return {
                     type: types_1.UnknownType.create(),
-                    isSuperCall: true,
                     node,
                 };
             }
@@ -5108,7 +5134,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isInstantiableClass)(baseClassType)) {
                     return {
                         type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
-                        isSuperCall: true,
                         node,
                     };
                 }
@@ -5116,7 +5141,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return {
             type: types_1.UnknownType.create(),
-            isSuperCall: true,
             node,
         };
     }
@@ -5210,15 +5234,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let overloadIndex = 0;
         let matches = [];
         // Create a list of potential overload matches based on arguments.
-        type.overloads.forEach((overload) => {
+        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
             useSpeculativeMode(errorNode, () => {
-                if (types_1.FunctionType.isOverloaded(overload)) {
-                    const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
-                    if (!matchResults.argumentErrors) {
-                        matches.push(matchResults);
-                    }
-                    overloadIndex++;
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
+                if (!matchResults.argumentErrors) {
+                    matches.push(matchResults);
                 }
+                overloadIndex++;
             });
         });
         matches = sortOverloadsByBestMatch(matches);
@@ -5255,17 +5277,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cache or record any diagnostics at this stage.
         useSpeculativeMode(errorNode, () => {
             let overloadIndex = 0;
-            type.overloads.forEach((overload) => {
+            types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
                 // Consider only the functions that have the @overload decorator,
                 // not the final function that omits the overload. This is the
                 // intended behavior according to PEP 484.
-                if (types_1.FunctionType.isOverloaded(overload)) {
-                    const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
-                    if (!matchResults.argumentErrors) {
-                        filteredMatchResults.push(matchResults);
-                    }
-                    overloadIndex++;
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
+                if (!matchResults.argumentErrors) {
+                    filteredMatchResults.push(matchResults);
                 }
+                overloadIndex++;
             });
         });
         filteredMatchResults = sortOverloadsByBestMatch(filteredMatchResults);
@@ -12110,7 +12130,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     // For "async while", an implicit "await" is performed.
                     if (isAsync) {
-                        memberReturnType = getTypeOfAwaitable(memberReturnType, node);
+                        memberReturnType = getTypeOfAwaitable(memberReturnType, node.expression);
                     }
                     return memberReturnType;
                 }
@@ -13376,7 +13396,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else if (node.parent &&
             node.parent.nodeType === 35 /* MemberAccess */ &&
             node === node.parent.memberName) {
-            let baseType = getTypeOfExpression(node.parent.leftExpression, 2 /* DoNotSpecialize */).type;
+            let baseType = getType(node.parent.leftExpression);
             if (baseType) {
                 baseType = makeTopLevelTypeVarsConcrete(baseType);
                 const memberName = node.parent.memberName.value;
@@ -13451,7 +13471,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const argNode = node.parent;
             const paramName = node.value;
             if (argNode.parent && argNode.parent.nodeType === 9 /* Call */) {
-                const baseType = getTypeOfExpression(argNode.parent.leftExpression, 2 /* DoNotSpecialize */).type;
+                const baseType = getType(argNode.parent.leftExpression);
                 if (baseType) {
                     if ((0, types_1.isFunction)(baseType) && baseType.details.declaration) {
                         const paramDecl = getDeclarationFromFunctionNamedParameter(baseType, paramName);
@@ -14292,9 +14312,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (returnTypeInferenceContextStack.length >= maxReturnTypeInferenceStackSize) {
             return undefined;
         }
+        const paramTypes = [];
+        let isResultFromCache = false;
         // Suppress diagnostics because we don't want to generate errors.
         suppressDiagnostics(functionNode, () => {
-            var _a;
+            var _a, _b;
             // Allocate a new temporary type cache for the context of just
             // this function so we can analyze it separately without polluting
             // the main type cache.
@@ -14337,13 +14359,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (!paramType) {
                             paramType = types_1.UnknownType.create();
                         }
+                        paramTypes.push(paramType);
                         writeTypeCache(param.name, paramType, 0 /* None */, /* isIncomplete */ false);
                     }
                 });
                 // Don't bother trying to determine the contextual return
                 // type if none of the argument types are known.
                 if (!allArgTypesAreUnknown) {
-                    contextualReturnType = (_a = inferFunctionReturnType(functionNode, types_1.FunctionType.isAbstractMethod(type))) === null || _a === void 0 ? void 0 : _a.type;
+                    // See if the return type is already cached. If so, skip the
+                    // inference step, which is potentially very expensive.
+                    const cacheEntry = (_a = functionType.functionType.callSiteReturnTypeCache) === null || _a === void 0 ? void 0 : _a.find((entry) => {
+                        return (entry.paramTypes.length === paramTypes.length &&
+                            entry.paramTypes.every((t, i) => (0, types_1.isTypeSame)(t, paramTypes[i])));
+                    });
+                    if (cacheEntry) {
+                        contextualReturnType = cacheEntry.returnType;
+                        isResultFromCache = true;
+                    }
+                    else {
+                        contextualReturnType = (_b = inferFunctionReturnType(functionNode, types_1.FunctionType.isAbstractMethod(type))) === null || _b === void 0 ? void 0 : _b.type;
+                    }
                 }
             }
             finally {
@@ -14357,6 +14392,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (types_1.FunctionType.isWrapReturnTypeInAwait(type) && !(0, types_1.isNever)(contextualReturnType)) {
                 contextualReturnType = createAwaitableReturnType(functionNode, contextualReturnType, !!((_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.isGenerator));
             }
+            if (!isResultFromCache) {
+                // Cache the resulting type.
+                if (!functionType.functionType.callSiteReturnTypeCache) {
+                    functionType.functionType.callSiteReturnTypeCache = [];
+                }
+                if (functionType.functionType.callSiteReturnTypeCache.length >= maxCallSiteReturnTypeCacheSize) {
+                    functionType.functionType.callSiteReturnTypeCache =
+                        functionType.functionType.callSiteReturnTypeCache.slice(1);
+                }
+                functionType.functionType.callSiteReturnTypeCache.push({
+                    paramTypes,
+                    returnType: contextualReturnType,
+                });
+            }
             return contextualReturnType;
         }
         return undefined;
@@ -15240,11 +15289,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Find first overloaded function that matches the parameters.
                 // We don't want to pollute the current typeVarContext, so we'll
                 // make a copy of the existing one if it's specified.
-                const overloads = concreteSrcType.overloads;
+                const overloads = types_1.OverloadedFunctionType.getOverloads(concreteSrcType);
                 const overloadIndex = overloads.findIndex((overload) => {
-                    if (!types_1.FunctionType.isOverloaded(overload)) {
-                        return false;
-                    }
                     return assignType(destType, overload, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone(), srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone(), flags, recursionCount);
                 });
                 if (overloadIndex < 0) {
@@ -15268,10 +15314,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isOverloadedFunction)(destType)) {
             const overloadDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
             // All overloads in the dest must be assignable.
-            const isAssignable = destType.overloads.every((destOverload) => {
-                if (!types_1.FunctionType.isOverloaded(destOverload)) {
-                    return true;
-                }
+            const isAssignable = types_1.OverloadedFunctionType.getOverloads(destType).every((destOverload) => {
                 if (destTypeVarContext) {
                     destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destOverload));
                 }
@@ -15403,6 +15446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // For union sources, all of the types need to be assignable to the dest.
         let isIncompatible = false;
+        // Sort the subtypes so we have a deterministic order for unions.
         (0, typeUtils_1.doForEachSubtype)(srcType, (subtype, subtypeIndex) => {
             if (isIncompatible) {
                 return;
@@ -15427,7 +15471,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncompatible = true;
                 }
             }
-        });
+        }, 
+        /* sortSubtypes */ true);
         if (isIncompatible) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
                 sourceType: printType(srcType),
@@ -16402,22 +16447,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return narrowedType;
     }
     function validateOverrideMethod(baseMethod, overrideMethod, diag, enforceParamNames = true) {
-        var _a, _b;
-        // If we're overriding an overloaded method, uses the implementation.
-        if ((0, types_1.isOverloadedFunction)(baseMethod)) {
-            const implementation = baseMethod.overloads.find((overload) => !types_1.FunctionType.isOverloaded(overload));
-            // If the overloaded method doesn't have an implementation, skip the check.
-            if (!implementation) {
-                return true;
-            }
-            baseMethod = implementation;
-        }
         // If we're overriding a non-method with a method, report it as an error.
         // This occurs when a non-property overrides a property.
-        if (!(0, types_1.isFunction)(baseMethod)) {
+        if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloadedFunction)(baseMethod)) {
             diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideType().format({ type: printType(baseMethod) }));
             return false;
         }
+        if ((0, types_1.isFunction)(baseMethod)) {
+            // Handle the easy case - a simple function overriding another simple function.
+            if ((0, types_1.isFunction)(overrideMethod)) {
+                return validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames);
+            }
+            // For an overload overriding a base method, at least one overload
+            // must be compatible with the base method.
+            if (types_1.OverloadedFunctionType.getOverloads(overrideMethod).some((overrideOverload) => {
+                return validateOverrideMethodInternal(baseMethod, overrideOverload, 
+                /* diag */ undefined, enforceParamNames);
+            })) {
+                return true;
+            }
+            // Or the implementation must be compatible.
+            const overrideImplementation = types_1.OverloadedFunctionType.getImplementation(overrideMethod);
+            if (overrideImplementation) {
+                if (validateOverrideMethodInternal(baseMethod, overrideImplementation, 
+                /* diag */ undefined, enforceParamNames)) {
+                    return true;
+                }
+            }
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNoOverloadMatches());
+            return false;
+        }
+        // TODO - need to implement the case where the base method is overloaded
+        return true;
+    }
+    function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {
+        var _a, _b;
         const baseParamDetails = (0, typeUtils_1.getParameterListDetails)(baseMethod);
         const overrideParamDetails = (0, typeUtils_1.getParameterListDetails)(overrideMethod);
         let canOverride = true;
@@ -16425,19 +16489,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // an incompatible type.
         if (types_1.FunctionType.isStaticMethod(baseMethod)) {
             if (!types_1.FunctionType.isStaticMethod(overrideMethod)) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
                 canOverride = false;
             }
         }
         else if (types_1.FunctionType.isClassMethod(baseMethod)) {
             if (!types_1.FunctionType.isClassMethod(overrideMethod)) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
                 canOverride = false;
             }
         }
         if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
             if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
                 canOverride = false;
             }
         }
@@ -16462,7 +16526,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (foundParamCountMismatch) {
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
                 baseCount: baseParamDetails.params.length,
                 overrideCount: overrideParamDetails.params.length,
             }));
@@ -16489,13 +16553,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (overrideParam.category === 0 /* Simple */) {
                     if (enforceParamNames) {
                         if (overrideParamDetails.params[i].source === typeUtils_1.ParameterSource.PositionOnly) {
-                            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                                 index: i + 1,
                                 baseName: baseParam.name || '*',
                             }));
                         }
                         else {
-                            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
                                 index: i + 1,
                                 baseName: baseParam.name || '*',
                                 overrideName: overrideParam.name || '*',
@@ -16507,7 +16571,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (i < overrideParamDetails.positionOnlyParamCount &&
                 i >= baseParamDetails.positionOnlyParamCount) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                     index: i + 1,
                     baseName: baseParam.name || '*',
                 }));
@@ -16520,8 +16584,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.details.isSynthesized;
                 if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
                     if (baseParam.category !== overrideParam.category ||
-                        !assignType(overrideParamType, baseParamType, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
+                        !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
                             index: i + 1,
                             baseType: printType(baseParamType),
                             overrideType: printType(overrideParamType),
@@ -16530,7 +16594,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 if (baseParamDetails.params[i].param.hasDefault && !overrideParamDetails.params[i].param.hasDefault) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
                         index: i + 1,
                     }));
                     canOverride = false;
@@ -16540,7 +16604,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Check for a *args match.
         if (baseParamDetails.argsIndex !== undefined) {
             if (overrideParamDetails.argsIndex === undefined) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
                     name: (_a = baseParamDetails.params[baseParamDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : '?',
                 }));
                 canOverride = false;
@@ -16548,9 +16612,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                 const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
-                if (!assignType(overrideParamType, baseParamType, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
                 /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
                         name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
                         baseType: printType(baseParamType),
                         overrideType: printType(overrideParamType),
@@ -16568,7 +16632,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             var _a, _b, _c;
             const overrideParamInfo = overrideWkOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
             if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
                     name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
                 }));
                 canOverride = false;
@@ -16578,9 +16642,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!targetParamType) {
                     targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                 }
-                if (!assignType(targetParamType, paramInfo.type, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
                 /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
                         name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
                         baseType: printType(paramInfo.type),
                         overrideType: printType(targetParamType),
@@ -16589,7 +16653,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (overrideParamInfo) {
                     if (paramInfo.param.hasDefault && !overrideParamInfo.param.hasDefault) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
                             name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
                         }));
                         canOverride = false;
@@ -16605,7 +16669,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!baseParamInfo) {
                 if (baseParamDetails.kwargsIndex === undefined) {
                     if (!paramInfo.param.hasDefault) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
                             name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
                         }));
                         canOverride = false;
@@ -16616,9 +16680,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
-        if (!assignType(baseReturnType, overrideReturnType, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 
+        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 
         /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideReturnType().format({
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),
             }));
@@ -17033,6 +17097,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addWarning,
         addInformation,
         addUnusedCode,
+        addUnreachableCode,
         addDeprecated,
         addDiagnostic,
         addDiagnosticForTextRange,