@zzzen/pyright-internal 1.2.0-dev.20260816 → 1.2.0-dev.20260830

package/dist/analyzer/checker.d.ts

@@ -1,19 +1,21 @@
 import { AssertNode, AssignmentExpressionNode, AssignmentNode, AugmentedAssignmentNode, AwaitNode, BinaryOperationNode, CallNode, CaseNode, ClassNode, ComprehensionIfNode, ComprehensionNode, DelNode, DictionaryNode, ErrorNode, ExceptNode, ForNode, FormatStringNode, FunctionNode, GlobalNode, IfNode, ImportAsNode, ImportFromAsNode, ImportFromNode, IndexNode, LambdaNode, ListNode, MatchNode, MemberAccessNode, ModuleNameNode, NameNode, NonlocalNode, ParseNode, PatternClassNode, RaiseNode, ReturnNode, SetNode, SliceNode, StatementListNode, StringListNode, SuiteNode, TernaryNode, TryNode, TupleNode, TypeAliasNode, TypeAnnotationNode, TypeParameterListNode, TypeParameterNode, UnaryOperationNode, UnpackNode, WhileNode, WithNode, YieldFromNode, YieldNode } from '../parser/parseNodes';
 import { ParserOutput } from '../parser/parser';
+import * as AnalyzerNodeInfo from './analyzerNodeInfo';
 import { ImportResolver } from './importResolver';
 import { ParseTreeWalker } from './parseTreeWalker';
 import { TypeEvaluator } from './typeEvaluatorTypes';
 export declare class Checker extends ParseTreeWalker {
     private _importResolver;
     private _evaluator;
-    private _dependentFiles?;
+    private _dependentFiles;
     private readonly _moduleNode;
     private readonly _fileInfo;
+    private readonly _nodeInfo;
     private _isUnboundCheckSuppressed;
     private _scopedNodes;
     private _typeParamLists;
     private _multipartImports;
-    constructor(_importResolver: ImportResolver, _evaluator: TypeEvaluator, parseResults: ParserOutput, _dependentFiles?: ParserOutput[] | undefined);
+    constructor(_importResolver: ImportResolver, _evaluator: TypeEvaluator, parseResults: ParserOutput, _dependentFiles: ParserOutput[] | undefined, nodeInfoReader: AnalyzerNodeInfo.AnalyzerNodeInfoReader);
     check(): void;
     walk(node: ParseNode): void;
     visitSuite(node: SuiteNode): boolean;

package/dist/analyzer/checker.js

@@ -88,8 +88,14 @@ const typeUtils_1 = require("./typeUtils");
 // functions to be emitted.
 const isPrintCodeComplexityEnabled = false;
 class Checker extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(_importResolver, _evaluator, parseResults, _dependentFiles) {
-        super();
+    constructor(_importResolver, _evaluator, parseResults, _dependentFiles, nodeInfoReader) {
+        // Forward the reader to the base walker so the structural walk expands both tier-1
+        // (parser-derived) and tier-2 (evaluator-discovered, e.g. `cast("Foo", v)`) string
+        // annotations. The checker runs after type evaluation, so tier-2 annotations exist by
+        // the time it descends; without the reader it would silently skip tier-2 forward-ref
+        // subtrees and drop checker-only diagnostics (reportDeprecated, reportPrivateUsage, ...)
+        // for symbols referenced only inside an evaluator-discovered forward reference.
+        super(nodeInfoReader);
         this._importResolver = _importResolver;
         this._evaluator = _evaluator;
         this._dependentFiles = _dependentFiles;
@@ -101,13 +107,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._typeParamLists = [];
         // A list of all visited multipart import statements.
         this._multipartImports = [];
+        this._nodeInfo = AnalyzerNodeInfo.createAnalyzerNodeInfoAccessor(nodeInfoReader);
         this._moduleNode = parseResults.parseTree;
-        this._fileInfo = AnalyzerNodeInfo.getFileInfo(this._moduleNode);
+        this._fileInfo = this._nodeInfo.getFileInfo(this._moduleNode);
     }
     check() {
         this._scopedNodes.push(this._moduleNode);
         // Report code complexity issues for the module.
-        const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(this._moduleNode);
+        const codeComplexity = this._nodeInfo.getCodeFlowComplexity(this._moduleNode);
         if (isPrintCodeComplexityEnabled) {
             console.log(`Code complexity of module ${this._fileInfo.fileUri.toUserVisibleString()} is ${codeComplexity.toString()}`);
         }
@@ -116,7 +123,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         this._walkStatementsAndReportUnreachable(this._moduleNode.d.statements);
         // Mark symbols accessed by __all__ as accessed.
-        const dunderAllInfo = AnalyzerNodeInfo.getDunderAllInfo(this._moduleNode);
+        const dunderAllInfo = this._nodeInfo.getDunderAllInfo(this._moduleNode);
         if (dunderAllInfo) {
             this._evaluator.markNamesAccessed(this._moduleNode, dunderAllInfo.names);
             this._reportUnusedDunderAllSymbols(dunderAllInfo.stringNodes);
@@ -128,7 +135,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._reportDuplicateImports();
     }
     walk(node) {
-        if (!AnalyzerNodeInfo.isCodeUnreachable(node)) {
+        if (!this._nodeInfo.isCodeUnreachable(node)) {
             super.walk(node);
         }
         else {
@@ -392,7 +399,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this.walk(param.d.name);
             }
         });
-        const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(node);
+        const codeComplexity = this._nodeInfo.getCodeFlowComplexity(node);
         const isTooComplexToAnalyze = codeComplexity > typeEvaluator_1.maxCodeComplexity;
         if (isPrintCodeComplexityEnabled) {
             console.log(`Code complexity of function ${node.d.name.d.value} is ${codeComplexity.toString()}`);
@@ -424,7 +431,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // if there is a '__getattr__' function defined when in strict mode.
         // This signifies an incomplete stub file that obscures type errors.
         if (this._fileInfo.isStubFile && node.d.name.d.value === '__getattr__') {
-            const scope = (0, scopeUtils_1.getScopeForNode)(node);
+            const scope = (0, scopeUtils_1.getScopeForNode)(node, this._nodeInfo);
             if (scope?.type === 4 /* ScopeType.Module */) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.LocMessage.stubUsesGetAttr(), node.d.name);
             }
@@ -587,7 +594,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // statement is not allowed to have an argument. A syntax error occurs
         // at runtime in this case.
         if (enclosingFunctionNode?.d.isAsync && node.d.expr) {
-            const functionDecl = AnalyzerNodeInfo.getDeclaration(enclosingFunctionNode);
+            const functionDecl = this._nodeInfo.getDeclaration(enclosingFunctionNode);
             if (functionDecl?.type === 5 /* DeclarationType.Function */ && functionDecl.isGenerator) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnInAsyncGenerator(), node.d.expr);
             }
@@ -598,7 +605,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnContainsReturn(), node);
                 }
                 else {
-                    const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                    const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node, this._nodeInfo);
                     declaredReturnType = this._evaluator.stripTypeGuard(declaredReturnType);
                     let adjReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -741,7 +748,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.d.leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
             const annotationType = this._evaluator.getTypeOfAnnotation(node.d.leftExpr.d.annotation);
             if ((0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias')) {
-                const scope = (0, scopeUtils_1.getScopeForNode)(node);
+                const scope = (0, scopeUtils_1.getScopeForNode)(node, this._nodeInfo);
                 if (scope) {
                     if (scope.type !== 3 /* ScopeType.Class */ &&
                         scope.type !== 4 /* ScopeType.Module */ &&
@@ -901,7 +908,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
         }
-        if (node.d.annotation) {
+        if (AnalyzerNodeInfo.getStringAnnotation(node, AnalyzerNodeInfo.getInfoReader(this._evaluator))) {
             this._evaluator.getType(node);
         }
         if (node.d.strings.length > 1 && !node.d.hasParens) {
@@ -995,7 +1002,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         else {
             this._evaluator.evaluateTypesForStatement(node);
-            const importInfo = AnalyzerNodeInfo.getImportInfo(node.d.module);
+            const importInfo = this._nodeInfo.getImportInfo(node.d.module);
             if (importInfo &&
                 importInfo.isImportFound &&
                 importInfo.importType !== 2 /* ImportType.Local */ &&
@@ -1047,7 +1054,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.isStubFile) {
             return false;
         }
-        const importResult = AnalyzerNodeInfo.getImportInfo(node);
+        const importResult = this._nodeInfo.getImportInfo(node);
         (0, debug_1.assert)(importResult !== undefined);
         this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node);
         return false;
@@ -1088,7 +1095,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitTypeAlias(node) {
-        const scope = (0, scopeUtils_1.getScopeForNode)(node);
+        const scope = (0, scopeUtils_1.getScopeForNode)(node, this._nodeInfo);
         if (scope) {
             if (scope.type !== 3 /* ScopeType.Class */ && scope.type !== 4 /* ScopeType.Module */ && scope.type !== 5 /* ScopeType.Builtin */) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasStatementBadScope(), node.d.name);
@@ -1578,7 +1585,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const nameType = this._evaluator.getType(nameNode);
             if (nameType && (0, types_1.isTypeVar)(nameType) && !types_1.TypeVarType.isSelf(nameType)) {
                 // Does this name refer to a TypeVar that is scoped to this function?
-                if (nameType.priv.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
+                if (nameType.priv.scopeId === ParseTreeUtils.getScopeIdForNode(node, this._nodeInfo)) {
                     // We exempt constrained TypeVars, TypeVars that are type arguments of
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
@@ -1864,14 +1871,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const functionNode = functionType.shared.declaration?.node;
         if (functionNode) {
-            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(functionNode);
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(functionNode, this._nodeInfo);
             functionType = (0, typeUtils_1.makeTypeVarsBound)(functionType, liveTypeVars);
         }
         // Use the parent node of the declaration in this case so we don't transform
         // function-local type variables into bound type variables.
         const prevOverloadNode = prevOverload.shared.declaration?.node?.parent;
         if (prevOverloadNode) {
-            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(prevOverloadNode);
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(prevOverloadNode, this._nodeInfo);
             prevOverload = (0, typeUtils_1.makeTypeVarsBound)(prevOverload, liveTypeVars);
         }
         return this._evaluator.assignType(functionType, prevOverload, 
@@ -1888,12 +1895,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let overloadBound = overload;
         const implNode = implementation.shared.declaration?.node?.parent;
         if (implNode) {
-            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(implNode);
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(implNode, this._nodeInfo);
             implBound = (0, typeUtils_1.makeTypeVarsBound)(implementation, liveScopeIds);
         }
         const overloadNode = overload.shared.declaration?.node;
         if (overloadNode) {
-            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(overloadNode);
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(overloadNode, this._nodeInfo);
             overloadBound = (0, typeUtils_1.makeTypeVarsBound)(overload, liveScopeIds);
         }
         // First check the parameters to see if they are assignable.
@@ -2086,7 +2093,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.diagnosticRuleSet.reportUnsupportedDunderAll === 'none') {
             return;
         }
-        const moduleScope = AnalyzerNodeInfo.getScope(this._moduleNode);
+        const moduleScope = this._nodeInfo.getScope(this._moduleNode);
         if (!moduleScope) {
             return;
         }
@@ -2097,9 +2104,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _validateSymbolTables() {
-        const dependentFileInfo = this._dependentFiles?.map((p) => AnalyzerNodeInfo.getFileInfo(p.parseTree));
+        const dependentFileInfo = this._dependentFiles?.map((p) => this._nodeInfo.getFileInfo(p.parseTree));
         for (const scopedNode of this._scopedNodes) {
-            const scope = AnalyzerNodeInfo.getScope(scopedNode);
+            const scope = this._nodeInfo.getScope(scopedNode);
             if (scope) {
                 scope.symbolTable.forEach((symbol, name) => {
                     this._conditionallyReportUnusedSymbol(name, symbol, scope.type, dependentFileInfo);
@@ -2116,7 +2123,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Report unaccessed type parameters.
         const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
         for (const paramList of this._typeParamLists) {
-            const typeParamScope = AnalyzerNodeInfo.getScope(paramList);
+            const typeParamScope = this._nodeInfo.getScope(paramList);
             for (const param of paramList.d.params) {
                 const symbol = typeParamScope?.symbolTable.get(param.d.name.d.value);
                 if (!symbol) {
@@ -2663,6 +2670,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (this._fileInfo.isStubFile) {
                     return;
                 }
+                // The presence of a decorator can change how the class is used (e.g. it
+                // may be registered or consumed through a decorator side effect), so back
+                // off from reporting it as unaccessed if any decorator is present.
+                if (decl.node.d.decorators.length > 0) {
+                    return;
+                }
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedClass;
                 nameNode = decl.node.d.name;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedClass;
@@ -2677,6 +2690,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (this._fileInfo.isStubFile) {
                     return;
                 }
+                // The presence of a decorator can change how the function is used (e.g. a
+                // Flask `@app.route(...)` handler is registered via a decorator side effect),
+                // so back off from reporting it as unaccessed if any decorator is present.
+                if (decl.node.d.decorators.length > 0) {
+                    return;
+                }
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedFunction;
                 nameNode = decl.node.d.name;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedFunction;
@@ -2786,10 +2805,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.diagnosticRuleSet.reportUnnecessaryIsInstance !== 'none') {
             const narrowedTypeNegative = (0, typeGuards_1.narrowTypeForInstanceOrSubclass)(this._evaluator, arg0Type, classTypeList, isInstanceCheck, 
             /* isTypeIsCheck */ false, 
-            /* isPositiveTest */ false, node);
+            /* isPositiveTest */ false, node, this._nodeInfo);
             const narrowedTypePositive = (0, typeGuards_1.narrowTypeForInstanceOrSubclass)(this._evaluator, arg0Type, classTypeList, isInstanceCheck, 
             /* isTypeIsCheck */ false, 
-            /* isPositiveTest */ true, node);
+            /* isPositiveTest */ true, node, this._nodeInfo);
             const isAlwaysTrue = (0, types_1.isNever)(narrowedTypeNegative);
             const isNeverTrue = (0, types_1.isNever)(narrowedTypePositive);
             if (isAlwaysTrue || isNeverTrue) {
@@ -3127,7 +3146,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.parent?.nodeType === 1 /* ParseNodeType.Argument */ && node.parent.d.name === node) {
             return;
         }
-        if (!AnalyzerNodeInfo.isCodeUnreachable(node)) {
+        if (!this._nodeInfo.isCodeUnreachable(node)) {
             const type = this._evaluator.getType(node);
             if (type) {
                 if ((0, types_1.isUnbound)(type)) {
@@ -3243,7 +3262,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // enum class that has already defined values.
     _validateEnumClassOverride(node, classType) {
         classType.shared.baseClasses.forEach((baseClass, index) => {
-            if ((0, types_1.isClass)(baseClass) && (0, enums_1.isEnumClassWithMembers)(this._evaluator, baseClass)) {
+            if ((0, types_1.isClass)(baseClass) && (0, enums_1.isEnumClassWithMembers)(this._evaluator, baseClass, this._nodeInfo)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.enumClassOverride().format({ name: baseClass.shared.name }), node.d.arguments[index]);
             }
         });
@@ -3255,8 +3274,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const emitBadStatementError = (node) => {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBadVar(), node);
         };
+        const nodeInfo = this._nodeInfo;
         function validateStatement(statement) {
-            if (AnalyzerNodeInfo.isCodeUnreachable(statement)) {
+            if (nodeInfo.isCodeUnreachable(statement)) {
                 return;
             }
             if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
@@ -3271,7 +3291,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             if (statement.nodeType === 22 /* ParseNodeType.If */) {
-                const conditionValue = AnalyzerNodeInfo.getStaticConditionValue(statement);
+                const conditionValue = nodeInfo.getStaticConditionValue(statement);
                 if (conditionValue === undefined) {
                     emitBadStatementError(statement);
                     return;
@@ -3297,12 +3317,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!returnType) {
             return;
         }
-        if (!(0, types_1.isClassInstance)(returnType) || !returnType.priv.typeArgs || returnType.priv.typeArgs.length < 1) {
-            return;
-        }
-        const isTypeGuard = types_1.ClassType.isBuiltIn(returnType, 'TypeGuard');
-        const isTypeIs = types_1.ClassType.isBuiltIn(returnType, 'TypeIs');
-        if (!isTypeGuard && !isTypeIs) {
+        const guardSubtypes = [];
+        (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype) &&
+                (types_1.ClassType.isBuiltIn(subtype, 'TypeGuard') || types_1.ClassType.isBuiltIn(subtype, 'TypeIs')) &&
+                subtype.priv.typeArgs &&
+                subtype.priv.typeArgs.length >= 1) {
+                guardSubtypes.push(subtype);
+            }
+        });
+        if (guardSubtypes.length === 0) {
             return;
         }
         // Make sure there's at least one input parameter provided.
@@ -3317,25 +3341,27 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (paramCount < 1) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeGuardParamCount(), node.d.name);
         }
-        if (isTypeIs) {
-            const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(functionType);
-            const narrowedType = returnType.priv.typeArgs[0];
-            let typeGuardType = (0, typeUtils_1.makeTypeVarsBound)(narrowedType, scopeIds);
-            typeGuardType = types_1.TypeBase.cloneWithTypeForm(typeGuardType, typeGuardType);
-            // Determine the type of the first parameter.
-            const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
-            if (paramIndex >= functionType.shared.parameters.length) {
-                return;
-            }
-            const paramType = (0, typeUtils_1.makeTypeVarsBound)(types_1.FunctionType.getParamType(functionType, paramIndex), scopeIds);
-            // Verify that the typeGuardType is a narrower type than the paramType.
-            if (!this._evaluator.assignType(paramType, typeGuardType)) {
-                const returnAnnotation = node.d.returnAnnotation || node.d.funcAnnotationComment?.d.returnAnnotation;
-                if (returnAnnotation) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeIsReturnType().format({
-                        type: this._evaluator.printType(paramType),
-                        returnType: this._evaluator.printType(narrowedType),
-                    }), returnAnnotation);
+        const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(functionType);
+        // Determine the type of the first parameter.
+        const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
+        if (paramIndex >= functionType.shared.parameters.length) {
+            return;
+        }
+        const paramType = (0, typeUtils_1.makeTypeVarsBound)(types_1.FunctionType.getParamType(functionType, paramIndex), scopeIds);
+        for (const guardSubtype of guardSubtypes) {
+            if (types_1.ClassType.isBuiltIn(guardSubtype, 'TypeIs')) {
+                const narrowedType = guardSubtype.priv.typeArgs[0];
+                let typeGuardType = (0, typeUtils_1.makeTypeVarsBound)(narrowedType, scopeIds);
+                typeGuardType = types_1.TypeBase.cloneWithTypeForm(typeGuardType, typeGuardType);
+                // Verify that the typeGuardType is a narrower type than the paramType.
+                if (!this._evaluator.assignType(paramType, typeGuardType)) {
+                    const returnAnnotation = node.d.returnAnnotation || node.d.funcAnnotationComment?.d.returnAnnotation;
+                    if (returnAnnotation) {
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeIsReturnType().format({
+                            type: this._evaluator.printType(paramType),
+                            returnType: this._evaluator.printType(narrowedType),
+                        }), returnAnnotation);
+                    }
                 }
             }
         }
@@ -3375,7 +3401,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (declaredReturnType) {
                 this._reportUnknownReturnResult(node, declaredReturnType);
                 this._validateReturnTypeIsNotContravariant(declaredReturnType, returnAnnotation);
-                const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node, this._nodeInfo);
                 declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
             }
             // Wrap the declared type in a generator type if the function is a generator.
@@ -3503,7 +3529,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // type checking perspective, if the runtime treats the assignment
             // as an enum member but there is a type annotation present, it is
             // considered a type checking error.
-            const symbolType = (0, enums_1.transformTypeForEnumMember)(this._evaluator, classType, name, 
+            const symbolType = (0, enums_1.transformTypeForEnumMember)(this._evaluator, classType, name, this._nodeInfo, 
             /* ignoreAnnotation */ true);
             // Is this symbol a literal instance of the enum class?
             if (!symbolType ||
@@ -5299,7 +5325,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!declaredReturnType) {
             return;
         }
-        const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+        const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node, this._nodeInfo);
         declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
         let generatorType;
         if (!enclosingFunctionNode.d.isAsync &&
@@ -5406,7 +5432,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _reportDuplicateImports() {
-        const importStatements = (0, importStatementUtils_1.getTopLevelImports)(this._moduleNode);
+        const importStatements = (0, importStatementUtils_1.getTopLevelImports)(this._moduleNode, 
+        /* includeImplicitImports */ false, this._nodeInfo);
         const importModuleMap = new Map();
         importStatements.orderedImports.forEach((importStatement) => {
             if (importStatement.node.nodeType === 25 /* ParseNodeType.ImportFrom */) {