@zzzen/pyright-internal 1.2.0-dev.20260809 → 1.2.0-dev.20260823

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;
@@ -132,6 +134,7 @@ export declare class Checker extends ParseTreeWalker {
     private _validateProtocolTypeParamVariance;
     private _validateSlotsClassVarConflict;
     private _validateConstructorConsistency;
+    private _validateDisjointBaseClass;
     private _validateMultipleInheritanceBaseClasses;
     private _validateMultipleInheritanceCompatibility;
     private _validateMultipleInheritanceOverride;

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 {
@@ -192,6 +199,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateBaseClassOverrides(classTypeResult.classType);
             this._validateTypedDictOverrides(classTypeResult.classType);
             this._validateOverloadDecoratorConsistency(classTypeResult.classType);
+            this._validateDisjointBaseClass(classTypeResult.classType, node.d.name);
             this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.d.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.d.name);
             this._validateConstructorConsistency(classTypeResult.classType, node.d.name);
@@ -391,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()}`);
@@ -423,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);
             }
@@ -586,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);
             }
@@ -597,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();
@@ -740,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 */ &&
@@ -900,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) {
@@ -994,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 */ &&
@@ -1046,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;
@@ -1087,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);
@@ -1577,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.
@@ -1863,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, 
@@ -1887,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.
@@ -2085,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;
         }
@@ -2096,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);
@@ -2115,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) {
@@ -2662,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;
@@ -2676,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;
@@ -2785,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) {
@@ -3126,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)) {
@@ -3242,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]);
             }
         });
@@ -3254,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 */) {
@@ -3270,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;
@@ -3374,7 +3395,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.
@@ -3502,7 +3523,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 ||
@@ -3997,6 +4018,42 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    // Verifies that a class has a unique most-derived disjoint base.
+    _validateDisjointBaseClass(classType, errorNode) {
+        if (classType.shared.baseClasses.length < 2) {
+            return;
+        }
+        const candidates = [];
+        for (const baseClass of classType.shared.baseClasses) {
+            if (!(0, types_1.isInstantiableClass)(baseClass)) {
+                // An unknown base may introduce an unknown disjoint base, but it
+                // cannot make two already-incompatible known bases compatible,
+                // so keep collecting the known candidates.
+                continue;
+            }
+            const candidate = types_1.ClassType.getDisjointBase(baseClass);
+            if (!candidate) {
+                // The base class is invalid or its disjoint base is unknown; an
+                // unknown disjoint base cannot relate two otherwise-incompatible
+                // known candidates, so keep collecting the known candidates.
+                continue;
+            }
+            if (!candidates.some((existingCandidate) => types_1.ClassType.isSameGenericClass(existingCandidate, candidate))) {
+                candidates.push(candidate);
+            }
+        }
+        if (candidates.length > 1 && !types_1.ClassType.getMostDerivedDisjointBase(candidates)) {
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.disjointBaseIncompatible().format({
+                // `object` is a disjoint base but is compatible with every
+                // other disjoint base, so including it in the reported names
+                // would be misleading. Filter it out.
+                bases: candidates
+                    .filter((candidate) => !types_1.ClassType.isBuiltIn(candidate, 'object'))
+                    .map((candidate) => `"${candidate.shared.name}"`)
+                    .join(', '),
+            }), errorNode);
+        }
+    }
     // Verifies that classes that have more than one base class do not have
     // have conflicting type arguments.
     _validateMultipleInheritanceBaseClasses(classType, errorNode) {
@@ -5262,7 +5319,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 &&
@@ -5369,7 +5426,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 */) {