@zzzen/pyright-internal 1.2.0-dev.20221009 → 1.2.0-dev.20221127

package/dist/analyzer/checker.js

@@ -39,6 +39,7 @@ const diagnosticRules_1 = require("../common/diagnosticRules");
 const pathUtils_1 = require("../common/pathUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
 const textRange_1 = require("../common/textRange");
+const definitionProvider_1 = require("../languageService/definitionProvider");
 const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
@@ -50,6 +51,7 @@ const importStatementUtils_1 = require("./importStatementUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const parseTreeWalker_1 = require("./parseTreeWalker");
 const patternMatching_1 = require("./patternMatching");
+const regions_1 = require("./regions");
 const scopeUtils_1 = require("./scopeUtils");
 const sourceFile_1 = require("./sourceFile");
 const sourceMapper_1 = require("./sourceMapper");
@@ -102,21 +104,32 @@ const deprecatedSpecialForms = new Map([
 // functions to be emitted.
 const isPrintCodeComplexityEnabled = false;
 class Checker extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(_importResolver, _evaluator, _moduleNode) {
+    constructor(_importResolver, _evaluator, _parseResults, _sourceMapper) {
         super();
         this._importResolver = _importResolver;
         this._evaluator = _evaluator;
-        this._moduleNode = _moduleNode;
+        this._parseResults = _parseResults;
+        this._sourceMapper = _sourceMapper;
         this._isUnboundCheckSuppressed = false;
         // A list of all nodes that are defined within the module that
         // have their own scopes.
         this._scopedNodes = [];
         // A list of all visited type parameter lists.
         this._typeParameterLists = [];
-        this._fileInfo = AnalyzerNodeInfo.getFileInfo(_moduleNode);
+        this._moduleNode = _parseResults.parseTree;
+        this._fileInfo = AnalyzerNodeInfo.getFileInfo(this._moduleNode);
     }
     check() {
         this._scopedNodes.push(this._moduleNode);
+        this._conditionallyReportShadowedModule();
+        // Report code complexity issues for the module.
+        const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(this._moduleNode);
+        if (isPrintCodeComplexityEnabled) {
+            console.log(`Code complexity of module ${this._fileInfo.filePath} is ${codeComplexity.toString()}`);
+        }
+        if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), { start: 0, length: 0 });
+        }
         this._walkStatementsAndReportUnreachable(this._moduleNode.statements);
         // Mark symbols accessed by __all__ as accessed.
         const dunderAllInfo = AnalyzerNodeInfo.getDunderAllInfo(this._moduleNode);
@@ -128,7 +141,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // defined in this module for things like unaccessed variables.
         this._validateSymbolTables();
         this._reportDuplicateImports();
-        MissingModuleSourceReporter.report(this._importResolver, this._evaluator, this._fileInfo, this._moduleNode);
+        this._checkRegions();
     }
     walk(node) {
         if (!AnalyzerNodeInfo.isCodeUnreachable(node)) {
@@ -176,9 +189,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             !types_1.ClassType.isBuiltIn(baseClassType, 'Generic')) {
                             if (!types_1.ClassType.isProtocolClass(baseClassType)) {
                                 this._evaluator.addError(localize_1.Localizer.Diagnostic.protocolBaseClass().format({
-                                    classType: this._evaluator.printType(classTypeResult.classType, 
-                                    /* expandTypeAlias */ false),
-                                    baseType: this._evaluator.printType(baseClassType, /* expandTypeAlias */ false),
+                                    classType: this._evaluator.printType(classTypeResult.classType),
+                                    baseType: this._evaluator.printType(baseClassType),
                                 }), arg.valueExpression);
                             }
                         }
@@ -262,7 +274,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
                             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                             diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.paramType().format({
-                                paramType: this._evaluator.printType(paramType, /* expandTypeAlias */ true),
+                                paramType: this._evaluator.printType(paramType, { expandTypeAlias: true }),
                             }));
                             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypePartiallyUnknown().format({
                                 paramName: param.name.value,
@@ -292,7 +304,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             });
             // Check for invalid use of ParamSpec P.args and P.kwargs.
-            const paramSpecParams = types_1.FunctionType.getFunctionParameters(functionTypeResult.functionType).filter((param) => {
+            const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
                 if (param.typeAnnotation && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
                     if (param.category !== 0 /* Simple */ && param.name && param.type.paramSpecAccess) {
                         return true;
@@ -430,7 +442,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.lambdaReturnTypePartiallyUnknown().format({
-                    returnType: this._evaluator.printType(returnType, /* expandTypeAlias */ true),
+                    returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
                 }), node.expression);
             }
         }
@@ -449,7 +461,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const returnType = this._evaluator.getType(node);
                 if (!isRevealTypeCall && returnType && this._isTypeValidForUnusedValueTest(returnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
-                        type: this._evaluator.printType(returnType, /* expandTypeAlias */ false),
+                        type: this._evaluator.printType(returnType),
                     }), node);
                     if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, 'Coroutine')) {
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCoroutine, diagnosticRules_1.DiagnosticRule.reportUnusedCoroutine, localize_1.Localizer.Diagnostic.unusedCoroutine(), node);
@@ -467,7 +479,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const returnType = this._evaluator.getType(node);
                 if (returnType && this._isTypeValidForUnusedValueTest(returnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
-                        type: this._evaluator.printType(returnType, /* expandTypeAlias */ false),
+                        type: this._evaluator.printType(returnType),
                     }), node);
                 }
             }
@@ -533,6 +545,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // There is no return expression, so "None" is assumed.
             returnType = types_1.NoneType.createInstance();
         }
+        // If the enclosing function is async and a generator, the return
+        // statement is not allowed to have an argument. A syntax error occurs
+        // at runtime in this case.
+        if ((enclosingFunctionNode === null || enclosingFunctionNode === void 0 ? void 0 : enclosingFunctionNode.isAsync) && node.returnExpression) {
+            const functionDecl = AnalyzerNodeInfo.getDeclaration(enclosingFunctionNode);
+            if ((functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.type) === 5 /* Function */ && functionDecl.isGenerator) {
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.returnInAsyncGenerator(), node.returnExpression);
+            }
+        }
         if (this._evaluator.isNodeReachable(node, /* sourceNode */ undefined) && enclosingFunctionNode) {
             if (declaredReturnType) {
                 if ((0, types_1.isNever)(declaredReturnType)) {
@@ -573,8 +594,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     if (!returnTypeMatches) {
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeMismatch().format({
-                            exprType: this._evaluator.printType(returnType, /* expandTypeAlias */ false),
-                            returnType: this._evaluator.printType(declaredReturnType, /* expandTypeAlias */ false),
+                            exprType: this._evaluator.printType(returnType),
+                            returnType: this._evaluator.printType(declaredReturnType),
                         }) + diagAddendum.getString(), node.returnExpression ? node.returnExpression : node);
                     }
                 }
@@ -584,7 +605,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
-                    returnType: this._evaluator.printType(returnType, /* expandTypeAlias */ true),
+                    returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
                 }), node.returnExpression);
             }
         }
@@ -596,6 +617,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitYieldFrom(node) {
+        var _a, _b, _c, _d;
         const yieldFromType = this._evaluator.getType(node.expression) || types_1.UnknownType.create();
         let yieldType;
         if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
@@ -604,7 +626,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         else {
             yieldType =
-                this._evaluator.getTypeOfIterable(yieldFromType, /* isAsync */ false, node) || types_1.UnknownType.create();
+                (_b = (_a = this._evaluator.getTypeOfIterable({ type: yieldFromType }, /* isAsync */ false, node)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
             // Does the iterator return a Generator? If so, get the yield type from it.
             // If the iterator doesn't return a Generator, use the iterator return type
             // directly.
@@ -614,7 +636,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else {
                 yieldType =
-                    this._evaluator.getTypeOfIterator(yieldFromType, /* isAsync */ false, node) || types_1.UnknownType.create();
+                    (_d = (_c = this._evaluator.getTypeOfIterator({ type: yieldFromType }, /* isAsync */ false, node)) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
             }
         }
         this._validateYieldType(node, yieldType);
@@ -634,13 +656,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if ((0, types_1.isClass)(subtype)) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(subtype, baseExceptionType, /* ignoreUnknown */ false)) {
                                 diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                                    type: this._evaluator.printType(subtype, /* expandTypeAlias */ false),
+                                    type: this._evaluator.printType(subtype),
                                 }));
                             }
                         }
                         else {
                             diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                                type: this._evaluator.printType(subtype, /* expandTypeAlias */ false),
+                                type: this._evaluator.printType(subtype),
                             }));
                         }
                     }
@@ -854,10 +876,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitImportAs(node) {
+        this._conditionallyReportShadowedImport(node);
         this._evaluator.evaluateTypesForStatement(node);
-        return false;
+        return true;
     }
     visitImportFrom(node) {
+        // Verify that any "__future__" import occurs at the top of the file.
+        if (node.module.leadingDots === 0 &&
+            node.module.nameParts.length === 1 &&
+            node.module.nameParts[0].value === '__future__') {
+            if (!ParseTreeUtils.isValidLocationForFutureImport(node)) {
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.futureImportLocationNotAllowed(), node);
+            }
+        }
+        this._conditionallyReportShadowedImport(node);
         if (!node.isWildcardImport) {
             node.imports.forEach((importAs) => {
                 this._evaluator.evaluateTypesForStatement(importAs);
@@ -872,6 +904,41 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportWildcardImportFromLibrary, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.Localizer.Diagnostic.wildcardLibraryImport(), node.wildcardToken || node);
             }
         }
+        return true;
+    }
+    visitImportFromAs(node) {
+        if (this._fileInfo.isStubFile) {
+            return false;
+        }
+        const decls = this._evaluator.getDeclarationsForNameNode(node.name);
+        if (!decls) {
+            return false;
+        }
+        for (const decl of decls) {
+            if (!(0, declaration_1.isAliasDeclaration)(decl) || !decl.submoduleFallback || decl.node !== node) {
+                // If it is not implicitly imported module, move to next.
+                continue;
+            }
+            const resolvedAlias = this._evaluator.resolveAliasDeclaration(decl, /* resolveLocalNames */ true);
+            if (!(resolvedAlias === null || resolvedAlias === void 0 ? void 0 : resolvedAlias.path) || !(0, sourceMapper_1.isStubFile)(resolvedAlias.path)) {
+                continue;
+            }
+            const importResult = this._getImportResult(node, resolvedAlias.path);
+            if (!importResult) {
+                continue;
+            }
+            this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node.name);
+            break;
+        }
+        return false;
+    }
+    visitModuleName(node) {
+        if (this._fileInfo.isStubFile) {
+            return false;
+        }
+        const importResult = AnalyzerNodeInfo.getImportInfo(node);
+        (0, debug_1.assert)(importResult !== undefined);
+        this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node);
         return false;
     }
     visitTypeParameterList(node) {
@@ -914,6 +981,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Don't explore further.
         return false;
     }
+    _getImportResult(node, filePath) {
+        const execEnv = this._importResolver.getConfigOption().findExecEnvironment(filePath);
+        const moduleNameNode = node.parent.module;
+        // Handle both absolute and relative imports.
+        const moduleName = moduleNameNode.leadingDots === 0
+            ? this._importResolver.getModuleNameForImport(filePath, execEnv).moduleName
+            : (0, importStatementUtils_1.getRelativeModuleName)(this._importResolver.fileSystem, this._fileInfo.filePath, filePath);
+        if (!moduleName) {
+            return undefined;
+        }
+        return this._importResolver.resolveImport(this._fileInfo.filePath, execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName));
+    }
+    _addMissingModuleSourceDiagnosticIfNeeded(importResult, node) {
+        if (importResult.isNativeLib ||
+            !importResult.isStubFile ||
+            importResult.importType === 0 /* BuiltIn */ ||
+            !importResult.nonStubImportResult ||
+            importResult.nonStubImportResult.isImportFound) {
+            return;
+        }
+        // Type stub found, but source is missing.
+        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingModuleSource, diagnosticRules_1.DiagnosticRule.reportMissingModuleSource, localize_1.Localizer.Diagnostic.importSourceResolveFailure().format({
+            importName: importResult.importName,
+        }), node);
+    }
     _reportUnnecessaryConditionExpression(expression) {
         if (expression.nodeType === 7 /* BinaryOperation */) {
             if (expression.operator === 36 /* And */ || expression.operator === 37 /* Or */) {
@@ -941,6 +1033,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportUnusedExpression(node) {
+        var _a, _b;
         if (this._fileInfo.diagnosticRuleSet.reportUnusedExpression === 'none') {
             return;
         }
@@ -964,6 +1057,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 reportAsUnused = true;
             }
         }
+        if (reportAsUnused &&
+            this._fileInfo.ipythonMode === sourceFile_1.IPythonMode.CellDocs &&
+            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* StatementList */ &&
+            node.parent.statements[node.parent.statements.length - 1] === node &&
+            ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 36 /* Module */ &&
+            node.parent.parent.statements[node.parent.parent.statements.length - 1] === node.parent) {
+            // Exclude an expression at the end of a notebook cell, as that is treated as
+            // the cell's value.
+            reportAsUnused = false;
+        }
         if (reportAsUnused) {
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedExpression, diagnosticRules_1.DiagnosticRule.reportUnusedExpression, localize_1.Localizer.Diagnostic.unusedExpression(), node);
         }
@@ -1040,8 +1143,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     : localize_1.Localizer.Diagnostic.containmentAlwaysTrue();
             };
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryContains, diagnosticRules_1.DiagnosticRule.reportUnnecessaryContains, getMessage().format({
-                leftType: this._evaluator.printType(leftType, /* expandTypeAlias */ true),
-                rightType: this._evaluator.printType(elementType, /* expandTypeAlias */ true),
+                leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
+                rightType: this._evaluator.printType(elementType, { expandTypeAlias: true }),
             }), node);
         }
     }
@@ -1080,8 +1183,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 });
                 if (!isPossiblyTrue) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
-                        leftType: this._evaluator.printType(leftType, /* expandTypeAlias */ true),
-                        rightType: this._evaluator.printType(rightType, /* expandTypeAlias */ true),
+                        leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
+                        rightType: this._evaluator.printType(rightType, { expandTypeAlias: true }),
                     }), node);
                 }
             }
@@ -1104,8 +1207,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 });
             });
             if (!isComparable) {
-                const leftTypeText = this._evaluator.printType(leftType, /* expandTypeAlias */ true);
-                const rightTypeText = this._evaluator.printType(rightType, /* expandTypeAlias */ true);
+                const leftTypeText = this._evaluator.printType(leftType, { expandTypeAlias: true });
+                const rightTypeText = this._evaluator.printType(rightType, { expandTypeAlias: true });
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
                     leftType: leftTypeText,
                     rightType: rightTypeText,
@@ -1445,8 +1548,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!(0, types_1.isNever)(overloadReturnType) &&
             !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* SkipSolveTypeVars */)) {
             returnDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionReturnTypeMismatch().format({
-                sourceType: this._evaluator.printType(overloadReturnType, /* expandTypeAlias */ false),
-                destType: this._evaluator.printType(implementationReturnType, /* expandTypeAlias */ false),
+                sourceType: this._evaluator.printType(overloadReturnType),
+                destType: this._evaluator.printType(implementationReturnType),
             }));
             diag === null || diag === void 0 ? void 0 : diag.addAddendum(returnDiag);
             isLegal = false;
@@ -1557,6 +1660,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _validateExceptionType(exceptionType, errorNode) {
+        var _a, _b;
         const baseExceptionType = this._evaluator.getBuiltInType(errorNode, 'BaseException');
         const derivesFromBaseException = (classType) => {
             if (!baseExceptionType || !(0, types_1.isInstantiableClass)(baseExceptionType)) {
@@ -1573,14 +1677,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, types_1.isInstantiableClass)(exceptionType)) {
                 if (!derivesFromBaseException(exceptionType)) {
                     diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                        type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+                        type: this._evaluator.printType(exceptionType),
                     }));
                 }
                 resultingExceptionType = types_1.ClassType.cloneAsInstance(exceptionType);
             }
             else if ((0, types_1.isClassInstance)(exceptionType)) {
-                const iterableType = this._evaluator.getTypeOfIterator(exceptionType, /* isAsync */ false, errorNode) ||
-                    types_1.UnknownType.create();
+                const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, /* isAsync */ false, errorNode)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 resultingExceptionType = (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
                         return subtype;
@@ -1588,13 +1691,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if ((0, types_1.isInstantiableClass)(subtype)) {
                         if (!derivesFromBaseException(subtype)) {
                             diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                                type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+                                type: this._evaluator.printType(exceptionType),
                             }));
                         }
                         return types_1.ClassType.cloneAsInstance(subtype);
                     }
                     diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
-                        type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+                        type: this._evaluator.printType(exceptionType),
                     }));
                     return types_1.UnknownType.create();
                 });
@@ -1602,7 +1705,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (!diagAddendum.isEmpty()) {
             this._evaluator.addError(localize_1.Localizer.Diagnostic.exceptionTypeNotClass().format({
-                type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+                type: this._evaluator.printType(exceptionType),
             }), errorNode);
         }
         return resultingExceptionType || types_1.UnknownType.create();
@@ -1991,6 +2094,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _conditionallyReportUnusedDeclaration(decl, isPrivate) {
+        var _a;
         let diagnosticLevel;
         let nameNode;
         let message;
@@ -2001,8 +2105,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedImport;
                 if (decl.node.nodeType === 21 /* ImportAs */) {
                     if (decl.node.alias) {
-                        // Aliases in stub files are assumed to be re-exports.
-                        if (!this._fileInfo.isStubFile) {
+                        // For statements of the form "import x as x", don't mark "x" as unaccessed
+                        // because it's assumed to be re-exported.
+                        // See https://typing.readthedocs.io/en/latest/source/stubs.html#imports.
+                        if (decl.node.alias.value !== decl.moduleName) {
                             nameNode = decl.node.alias;
                         }
                     }
@@ -2021,9 +2127,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 else if (decl.node.nodeType === 23 /* ImportFromAs */) {
                     const importFrom = decl.node.parent;
-                    // If this is a stub file that is using the "from A import B as C" or "from . import C",
-                    // don't mark "C" as unaccessed because it's assumed to be re-exported.
-                    const isReexport = this._fileInfo.isStubFile && decl.node.alias !== undefined;
+                    // For statements of the form "from y import x as x", don't mark "x" as
+                    // unaccessed because it's assumed to be re-exported.
+                    const isReexport = ((_a = decl.node.alias) === null || _a === void 0 ? void 0 : _a.value) === decl.node.name.value;
                     // If this is a __future__ import, it's OK for the import symbol to be unaccessed.
                     const isFuture = importFrom.module.nameParts.length === 1 &&
                         importFrom.module.nameParts[0].value === '__future__';
@@ -2152,10 +2258,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarNotAllowed());
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, isInstanceCheck
                 ? localize_1.Localizer.Diagnostic.isInstanceInvalidType().format({
-                    type: this._evaluator.printType(arg1Type, /* expandTypeAlias */ false),
+                    type: this._evaluator.printType(arg1Type),
                 }) + diag.getString()
                 : localize_1.Localizer.Diagnostic.isSubclassInvalidType().format({
-                    type: this._evaluator.printType(arg1Type, /* expandTypeAlias */ false),
+                    type: this._evaluator.printType(arg1Type),
                 }) + diag.getString(), node.arguments[1]);
         }
         // If this call is within an assert statement, we won't check whether
@@ -2315,12 +2421,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!arg1IncludesSubclasses && (0, types_1.isTypeSame)(filteredType, arg0Type, { ignorePseudoGeneric: true })) {
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryIsInstance, diagnosticRules_1.DiagnosticRule.reportUnnecessaryIsInstance, isInstanceCheck
                 ? localize_1.Localizer.Diagnostic.unnecessaryIsInstanceAlways().format({
-                    testType: this._evaluator.printType(arg0Type, /* expandTypeAlias */ false),
-                    classType: this._evaluator.printType(getTestType(), /* expandTypeAlias */ false),
+                    testType: this._evaluator.printType(arg0Type),
+                    classType: this._evaluator.printType(getTestType()),
                 })
                 : localize_1.Localizer.Diagnostic.unnecessaryIsSubclassAlways().format({
-                    testType: this._evaluator.printType(arg0Type, /* expandTypeAlias */ false),
-                    classType: this._evaluator.printType(getTestType(), /* expandTypeAlias */ false),
+                    testType: this._evaluator.printType(arg0Type),
+                    classType: this._evaluator.printType(getTestType()),
                 }), node);
         }
     }
@@ -2416,6 +2522,79 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    _conditionallyReportShadowedModule() {
+        if (this._fileInfo.diagnosticRuleSet.reportShadowedImports === 'none') {
+            return;
+        }
+        // Check the module we're in.
+        const moduleName = this._fileInfo.moduleName;
+        const desc = {
+            nameParts: moduleName.split('.'),
+            leadingDots: 0,
+            importedSymbols: [],
+        };
+        const stdlibPath = this._importResolver.getTypeshedStdLibPath(this._fileInfo.executionEnvironment);
+        if (stdlibPath &&
+            this._importResolver.isStdlibModule(desc, this._fileInfo.executionEnvironment) &&
+            this._sourceMapper.isUserCode(this._fileInfo.filePath)) {
+            // This means the user has a module that is overwriting the stdlib module.
+            const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.Localizer.Diagnostic.stdlibModuleOverridden().format({
+                name: moduleName,
+                path: this._fileInfo.filePath,
+            }), this._moduleNode);
+            // Add a quick action that renames the file.
+            if (diag) {
+                const renameAction = {
+                    action: "renameShadowedFile" /* RenameShadowedFileAction */,
+                    oldFile: this._fileInfo.filePath,
+                    newFile: this._sourceMapper.getNextFileName(this._fileInfo.filePath),
+                };
+                diag.addAction(renameAction);
+            }
+        }
+    }
+    _conditionallyReportShadowedImport(node) {
+        if (this._fileInfo.diagnosticRuleSet.reportShadowedImports === 'none') {
+            return;
+        }
+        const namePartNodes = node.nodeType === 21 /* ImportAs */
+            ? node.module.nameParts
+            : node.nodeType === 23 /* ImportFromAs */
+                ? [node.name]
+                : node.module.nameParts;
+        const nameParts = namePartNodes.map((n) => n.value);
+        const module = {
+            nameParts,
+            leadingDots: 0,
+            importedSymbols: [],
+        };
+        // Make sure the module is a potential stdlib one so we don't spend the time
+        // searching for the definition.
+        const stdlibPath = this._importResolver.getTypeshedStdLibPath(this._fileInfo.executionEnvironment);
+        if (stdlibPath && this._importResolver.isStdlibModule(module, this._fileInfo.executionEnvironment)) {
+            // If the definition for this name is in 'user' module, it is overwriting the stdlib module.
+            const definitions = definitionProvider_1.DefinitionProvider.getDefinitionsForNode(this._sourceMapper, namePartNodes[namePartNodes.length - 1], definitionProvider_1.DefinitionFilter.All, this._evaluator);
+            const paths = definitions ? definitions.map((d) => d.path) : [];
+            paths.forEach((p) => {
+                if (!p.startsWith(stdlibPath) && !(0, sourceMapper_1.isStubFile)(p) && this._sourceMapper.isUserCode(p)) {
+                    // This means the user has a module that is overwriting the stdlib module.
+                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.Localizer.Diagnostic.stdlibModuleOverridden().format({
+                        name: nameParts.join('.'),
+                        path: p,
+                    }), node);
+                    // Add a quick action that renames the file.
+                    if (diag) {
+                        const renameAction = {
+                            action: "renameShadowedFile" /* RenameShadowedFileAction */,
+                            oldFile: p,
+                            newFile: this._sourceMapper.getNextFileName(p),
+                        };
+                        diag.addAction(renameAction);
+                    }
+                }
+            });
+        }
+    }
     _conditionallyReportPrivateUsage(node) {
         var _a;
         if (this._fileInfo.diagnosticRuleSet.reportPrivateUsage === 'none') {
@@ -2624,7 +2803,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 else if ((0, typeUtils_1.isPartlyUnknown)(declaredReturnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.declaredReturnTypePartiallyUnknown().format({
-                        returnType: this._evaluator.printType(declaredReturnType, /* expandTypeAlias */ true),
+                        returnType: this._evaluator.printType(declaredReturnType, { expandTypeAlias: true }),
                     }), returnAnnotation);
                 }
                 const diag = new diagnostic_1.DiagnosticAddendum();
@@ -2663,8 +2842,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // the return type matches. This check can also be skipped for an overload.
                         if (!ParseTreeUtils.isSuiteEmpty(node.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
                             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnMissing().format({
-                                returnType: this._evaluator.printType(declaredReturnType, 
-                                /* expandTypeAlias */ false),
+                                returnType: this._evaluator.printType(declaredReturnType),
                             }) + diagAddendum.getString(), returnAnnotation);
                         }
                     }
@@ -2678,7 +2856,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(inferredReturnType)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
-                    returnType: this._evaluator.printType(inferredReturnType, /* expandTypeAlias */ true),
+                    returnType: this._evaluator.printType(inferredReturnType, { expandTypeAlias: true }),
                 }), node.name);
             }
         }
@@ -2776,7 +2954,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 else if (decls[0].type === 5 /* Function */) {
-                    if (ParseTreeUtils.isSuiteEmpty(decls[0].node.suite) && decls[0]) {
+                    if (decls.every((decl) => decl.type !== 5 /* Function */ || ParseTreeUtils.isSuiteEmpty(decl.node.suite))) {
                         if ((0, pathUtils_1.getFileExtension)(decls[0].path).toLowerCase() !== '.pyi') {
                             if (!isSymbolImplemented(name)) {
                                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
@@ -2902,6 +3080,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Reports the case where an instance variable is not declared or initialized
     // within the class body or constructor method.
     _validateInstanceVariableInitialization(classType) {
+        // This check doesn't apply to stub files.
+        if (this._fileInfo.isStubFile) {
+            return;
+        }
         // This check can be expensive, so don't perform it if the corresponding
         // rule is disabled.
         if (this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable === 'none') {
@@ -3341,6 +3523,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, types_1.isAnyOrUnknown)(typeOfSymbol)) {
                 return;
             }
+            let foundOverride = false;
             for (const baseClass of classType.details.baseClasses) {
                 if (!(0, types_1.isClass)(baseClass)) {
                     continue;
@@ -3355,10 +3538,35 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!baseClassAndSymbol) {
                     continue;
                 }
+                foundOverride = true;
                 this._validateBaseClassOverride(baseClassAndSymbol, symbol, typeOfSymbol, classType, name);
             }
+            if (!foundOverride) {
+                // If this is a method decorated with @override, validate that there
+                // is a base class method of the same name.
+                this._validateOverrideDecorator(typeOfSymbol);
+            }
         });
     }
+    // Determines whether the type is a function or overloaded function with an @override
+    // decorator. In this case, an error is reported because no base class has declared
+    // a method of the same name.
+    _validateOverrideDecorator(overrideType) {
+        let overrideFunction;
+        if ((0, types_1.isFunction)(overrideType)) {
+            overrideFunction = overrideType;
+        }
+        else if ((0, types_1.isOverloadedFunction)(overrideType)) {
+            overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
+        }
+        if (!overrideFunction ||
+            !types_1.FunctionType.isOverridden(overrideFunction) ||
+            !overrideFunction.details.declaration) {
+            return;
+        }
+        const funcNode = overrideFunction.details.declaration.node;
+        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overrideNotFound().format({ name: funcNode.name.value }), funcNode.name);
+    }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
@@ -3430,7 +3638,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.methodOverridden().format({
                             name: memberName,
                             className: baseClassAndSymbol.classType.details.name,
-                            type: this._evaluator.printType(overrideType, /* expandTypeAlias */ false),
+                            type: this._evaluator.printType(overrideType),
                         }), lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
@@ -3647,9 +3855,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         else {
+            const decoratorIsPresent = node.decorators.length > 0;
+            const isOverloaded = types_1.FunctionType.isOverloaded(functionType);
             // The presence of a decorator can change the behavior, so we need
-            // to back off from this check if a decorator is present.
-            if (node.decorators.length === 0) {
+            // to back off from this check if a decorator is present. An overload
+            // is a decorator, but we'll ignore that here.
+            if (isOverloaded || !decoratorIsPresent) {
                 let paramName = '';
                 let firstParamIsSimple = true;
                 if (node.parameters.length > 0) {
@@ -3777,7 +3988,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!this._evaluator.assignType(paramType, expectedType)) {
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.clsSelfParamTypeMismatch().format({
                 name: paramInfo.name,
-                classType: this._evaluator.printType(expectedType, /* expandTypeAlias */ false),
+                classType: this._evaluator.printType(expectedType),
             }), paramInfo.typeAnnotation);
         }
     }
@@ -3808,8 +4019,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 if (!this._evaluator.assignType(declaredYieldType, yieldType, diagAddendum)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.yieldTypeMismatch().format({
-                        exprType: this._evaluator.printType(yieldType, /* expandTypeAlias */ false),
-                        yieldType: this._evaluator.printType(declaredYieldType, /* expandTypeAlias */ false),
+                        exprType: this._evaluator.printType(yieldType),
+                        yieldType: this._evaluator.printType(declaredYieldType),
                     }) + diagAddendum.getString(), node.expression || node);
                 }
             }
@@ -3821,6 +4032,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let sawUnknownExceptionType = false;
         const exceptionTypesSoFar = [];
         node.exceptClauses.forEach((except) => {
+            var _a, _b;
             if (sawUnknownExceptionType || except.isExceptGroup || !except.typeExpression) {
                 return;
             }
@@ -3839,8 +4051,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 typesOfThisExcept.push(exceptionType);
             }
             else if ((0, types_1.isClassInstance)(exceptionType)) {
-                const iterableType = this._evaluator.getTypeOfIterator(exceptionType, /* isAsync */ false, /* errorNode */ undefined) ||
-                    types_1.UnknownType.create();
+                const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, 
+                /* isAsync */ false, 
+                /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 (0, typeUtils_1.doForEachSubtype)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
                         sawUnknownExceptionType = true;
@@ -3915,94 +4128,33 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-}
-exports.Checker = Checker;
-class MissingModuleSourceReporter extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(_importResolver, _evaluator, _fileInfo) {
-        super();
-        this._importResolver = _importResolver;
-        this._evaluator = _evaluator;
-        this._fileInfo = _fileInfo;
-    }
-    static report(importResolver, evaluator, fileInfo, node) {
-        if (fileInfo.isStubFile) {
-            // Don't report this for stub files.
-            return;
-        }
-        new MissingModuleSourceReporter(importResolver, evaluator, fileInfo).walk(node);
-    }
-    visitNode(node) {
-        // Optimization. don't walk into expressions which can't
-        // have import statement as child nodes.
-        if ((0, parseNodes_1.isExpressionNode)(node)) {
-            return [];
-        }
-        return super.visitNode(node);
-    }
-    visitModule(node) {
-        const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(node);
-        if (isPrintCodeComplexityEnabled) {
-            console.log(`Code complexity of module ${this._fileInfo.filePath} is ${codeComplexity.toString()}`);
-        }
-        if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), { start: 0, length: 0 });
-            return false;
-        }
-        return true;
-    }
-    visitModuleName(node) {
-        const importResult = AnalyzerNodeInfo.getImportInfo(node);
-        (0, debug_1.assert)(importResult !== undefined);
-        this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node);
-        return false;
-    }
-    visitImportFromAs(node) {
-        const decls = this._evaluator.getDeclarationsForNameNode(node.name);
-        if (!decls) {
-            return false;
-        }
-        for (const decl of decls) {
-            if (!(0, declaration_1.isAliasDeclaration)(decl) || !decl.submoduleFallback || decl.node !== node) {
-                // If it is not implicitly imported module, move to next.
-                continue;
-            }
-            const resolvedAlias = this._evaluator.resolveAliasDeclaration(decl, /* resolveLocalNames */ true);
-            if (!(resolvedAlias === null || resolvedAlias === void 0 ? void 0 : resolvedAlias.path) || !(0, sourceMapper_1.isStubFile)(resolvedAlias.path)) {
-                continue;
+    _checkRegions() {
+        const regionComments = (0, regions_1.getRegionComments)(this._parseResults);
+        const regionStack = [];
+        regionComments.forEach((regionComment) => {
+            if (regionComment.type === 0 /* Region */) {
+                regionStack.push(regionComment);
             }
-            const importResult = this._getImportResult(node, resolvedAlias.path);
-            if (!importResult) {
-                continue;
+            else {
+                if (regionStack.length > 0) {
+                    regionStack.pop();
+                }
+                else {
+                    this._addDiagnosticForRegionComment(regionComment, localize_1.Localizer.Diagnostic.unmatchedEndregionComment());
+                }
             }
-            this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node.name);
-            break;
-        }
-        return false;
-    }
-    _getImportResult(node, filePath) {
-        const execEnv = this._importResolver.getConfigOption().findExecEnvironment(filePath);
-        const moduleNameNode = node.parent.module;
-        // Handle both absolute and relative imports.
-        const moduleName = moduleNameNode.leadingDots === 0
-            ? this._importResolver.getModuleNameForImport(filePath, execEnv).moduleName
-            : (0, importStatementUtils_1.getRelativeModuleName)(this._importResolver.fileSystem, this._fileInfo.filePath, filePath);
-        if (!moduleName) {
-            return undefined;
-        }
-        return this._importResolver.resolveImport(this._fileInfo.filePath, execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName));
+        });
+        regionStack.forEach((regionComment) => {
+            this._addDiagnosticForRegionComment(regionComment, localize_1.Localizer.Diagnostic.unmatchedRegionComment());
+        });
     }
-    _addMissingModuleSourceDiagnosticIfNeeded(importResult, node) {
-        if (importResult.isNativeLib ||
-            !importResult.isStubFile ||
-            importResult.importType === 0 /* BuiltIn */ ||
-            !importResult.nonStubImportResult ||
-            importResult.nonStubImportResult.isImportFound) {
-            return;
-        }
-        // Type stub found, but source is missing.
-        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingModuleSource, diagnosticRules_1.DiagnosticRule.reportMissingModuleSource, localize_1.Localizer.Diagnostic.importSourceResolveFailure().format({
-            importName: importResult.importName,
-        }), node);
+    _addDiagnosticForRegionComment(regionComment, message) {
+        // extend range to include # character
+        const range = regionComment.comment;
+        range.start -= 1;
+        range.length += 1;
+        return this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', message, range);
     }
 }
+exports.Checker = Checker;
 //# sourceMappingURL=checker.js.map