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

package/dist/analyzer/binder.js

@@ -58,7 +58,6 @@ const positionUtils_1 = require("../common/positionUtils");
 const textRange_1 = require("../common/textRange");
 const uri_1 = require("../common/uri/uri");
 const localize_1 = require("../localization/localize");
-const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const codeFlowTypes_1 = require("./codeFlowTypes");
 const declaration_1 = require("./declaration");
 const importStatementUtils_1 = require("./importStatementUtils");
@@ -68,13 +67,70 @@ const scope_1 = require("./scope");
 const StaticExpressions = __importStar(require("./staticExpressions"));
 const symbol_1 = require("./symbol");
 const symbolNameUtils_1 = require("./symbolNameUtils");
+function isStaticClassAssignmentTarget(target) {
+    switch (target.nodeType) {
+        case 38 /* ParseNodeType.Name */:
+            return true;
+        case 54 /* ParseNodeType.TypeAnnotation */:
+            return isStaticClassAssignmentTarget(target.d.valueExpr);
+        case 52 /* ParseNodeType.Tuple */:
+        case 34 /* ParseNodeType.List */:
+            return target.d.items.every((item) => isStaticClassAssignmentTarget(item));
+        case 56 /* ParseNodeType.Unpack */:
+            return isStaticClassAssignmentTarget(target.d.expr);
+        default:
+            return false;
+    }
+}
+function getCalledBuiltInName(scope, expression, visitedSymbols = new Set()) {
+    if (expression.nodeType === 38 /* ParseNodeType.Name */) {
+        const symbolWithScope = scope.lookUpSymbolRecursive(expression.d.value);
+        if (!symbolWithScope || visitedSymbols.has(symbolWithScope.symbol)) {
+            return undefined;
+        }
+        visitedSymbols.add(symbolWithScope.symbol);
+        if (symbolWithScope.scope.type === 5 /* ScopeType.Builtin */) {
+            return expression.d.value;
+        }
+        const declarations = symbolWithScope.symbol.getDeclarations();
+        const declaration = declarations[declarations.length - 1];
+        if (declaration?.type === 1 /* DeclarationType.Variable */ &&
+            (declaration.inferredTypeSource?.nodeType === 38 /* ParseNodeType.Name */ ||
+                declaration.inferredTypeSource?.nodeType === 35 /* ParseNodeType.MemberAccess */)) {
+            return getCalledBuiltInName(scope, declaration.inferredTypeSource, visitedSymbols);
+        }
+        if (declaration?.type === 8 /* DeclarationType.Alias */ &&
+            declaration.moduleName === 'builtins' &&
+            declaration.symbolName) {
+            return declaration.symbolName;
+        }
+    }
+    else if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+        expression.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */) {
+        const symbolWithScope = scope.lookUpSymbolRecursive(expression.d.leftExpr.d.value);
+        const declarations = symbolWithScope?.symbol.getDeclarations() ?? [];
+        const declaration = declarations[declarations.length - 1];
+        if (declaration?.type === 8 /* DeclarationType.Alias */ &&
+            declaration.moduleName === 'builtins' &&
+            !declaration.symbolName) {
+            return expression.d.member.d.value;
+        }
+    }
+    return undefined;
+}
+function doesCallExposeClassNamespace(scope, node) {
+    const builtInName = getCalledBuiltInName(scope, node.d.leftExpr);
+    return (builtInName === 'exec' ||
+        (builtInName === 'eval' && node.d.args.length === 1) ||
+        ((builtInName === 'locals' || builtInName === 'vars') && node.d.args.length === 0));
+}
 // For each flow node within an execution context, we'll add a small
 // amount to the complexity factor. Without this, the complexity
 // calculation fails to take into account large numbers of non-cyclical
 // flow nodes. This number is somewhat arbitrary and is tuned empirically.
 const flowNodeComplexityContribution = 0.025;
 class Binder extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(fileInfo, _moduleSymbolOnly = false, _cellChainIndex) {
+    constructor(fileInfo, _moduleSymbolOnly, _cellChainIndex, nodeInfo) {
         super();
         this._moduleSymbolOnly = _moduleSymbolOnly;
         this._cellChainIndex = _cellChainIndex;
@@ -119,6 +175,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // the current function.
         this._codeFlowComplexity = 0;
         this._fileInfo = fileInfo;
+        this._nodeInfo = nodeInfo;
     }
     bindModule(node) {
         // We'll assume that if there is no builtins scope provided, we must be
@@ -128,8 +185,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._addTypingImportAliasesFromBuiltinsScope();
         this._createNewScope(isBuiltInModule ? 5 /* ScopeType.Builtin */ : 4 /* ScopeType.Module */, this._fileInfo.builtinsScope, 
         /* proxyScope */ undefined, chainedModuleLevelScopeLookup, () => {
-            AnalyzerNodeInfo.setScope(node, this._currentScope);
-            AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+            this._nodeInfo.setScope(node, this._currentScope);
+            this._nodeInfo.setFlowNode(node, this._currentFlowNode);
             // Bind implicit names.
             // List taken from https://docs.python.org/3/reference/import.html#__name__
             this._addImplicitSymbolToCurrentScope('__name__', node, 'str');
@@ -147,9 +204,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._currentFlowNode = this._createStartFlowNode();
             this._walkStatementsAndReportUnreachable(node.d.statements);
             // Associate the code flow node at the end of the module with the module.
-            AnalyzerNodeInfo.setAfterFlowNode(node, this._currentFlowNode);
-            AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
-            AnalyzerNodeInfo.setCodeFlowComplexity(node, this._codeFlowComplexity);
+            this._nodeInfo.setAfterFlowNode(node, this._currentFlowNode);
+            this._nodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
+            this._nodeInfo.setCodeFlowComplexity(node, this._codeFlowComplexity);
         });
         // Perform all analysis that was deferred during the first pass.
         this._bindDeferred();
@@ -191,17 +248,17 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         if (this._dunderAllNames) {
-            AnalyzerNodeInfo.setDunderAllInfo(node, {
+            this._nodeInfo.setDunderAllInfo(node, {
                 names: this._dunderAllNames,
                 stringNodes: this._dunderAllStringNodes,
                 usesUnsupportedDunderAllForm: this._usesUnsupportedDunderAllForm,
             });
         }
         else {
-            AnalyzerNodeInfo.setDunderAllInfo(node, /* names */ undefined);
+            this._nodeInfo.setDunderAllInfo(node, /* names */ undefined);
         }
         // Set __all__ flags on the module symbols.
-        const scope = AnalyzerNodeInfo.getScope(node);
+        const scope = this._nodeInfo.getScope(node);
         if (scope && this._dunderAllNames) {
             for (const name of this._dunderAllNames) {
                 scope.symbolTable.get(name)?.setIsInDunderAll();
@@ -219,7 +276,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitModuleName(node) {
-        const importResult = AnalyzerNodeInfo.getImportInfo(node);
+        const importResult = this._nodeInfo.getImportInfo(node);
         (0, debug_1.assert)(importResult !== undefined);
         if (importResult.isNativeLib) {
             return true;
@@ -278,17 +335,17 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             symbol.addDeclaration(classDeclaration);
         }
         // Stash the declaration in the parse node for later access.
-        AnalyzerNodeInfo.setDeclaration(node, classDeclaration);
+        this._nodeInfo.setDeclaration(node, classDeclaration);
         let typeParamScope;
         if (node.d.typeParams) {
             this.walk(node.d.typeParams);
-            typeParamScope = AnalyzerNodeInfo.getScope(node.d.typeParams);
+            typeParamScope = this._nodeInfo.getScope(node.d.typeParams);
         }
         this.walkMultiple(node.d.arguments);
         this._createNewScope(3 /* ScopeType.Class */, typeParamScope ?? this._getNonClassParentScope(), 
         /* proxyScope */ undefined, 
         /* chainedModuleLevelScopeLookup */ undefined, () => {
-            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            this._nodeInfo.setScope(node, this._currentScope);
             this._addImplicitSymbolToCurrentScope('__doc__', node, 'str | None');
             this._addImplicitSymbolToCurrentScope('__module__', node, 'str');
             this._dunderSlotsEntries = undefined;
@@ -330,7 +387,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitFunction(node) {
         this._createVariableAnnotationFlowNode();
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         const symbol = this._bindNameToScope(this._currentScope, node.d.name);
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
         const functionDeclaration = {
@@ -347,7 +404,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             symbol.addDeclaration(functionDeclaration);
         }
         // Stash the declaration in the parse node for later access.
-        AnalyzerNodeInfo.setDeclaration(node, functionDeclaration);
+        this._nodeInfo.setDeclaration(node, functionDeclaration);
         // Walk the default values prior to the type parameters.
         node.d.params.forEach((param) => {
             if (param.d.defaultValue) {
@@ -357,7 +414,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         let typeParamScope;
         if (node.d.typeParams) {
             this.walk(node.d.typeParams);
-            typeParamScope = AnalyzerNodeInfo.getScope(node.d.typeParams);
+            typeParamScope = this._nodeInfo.getScope(node.d.typeParams);
         }
         this.walkMultiple(node.d.decorators);
         node.d.params.forEach((param) => {
@@ -379,7 +436,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._createNewScope(2 /* ScopeType.Function */, typeParamScope ?? this._getNonClassParentScope(), 
         /* proxyScope */ undefined, 
         /* chainedModuleLevelScopeLookup */ undefined, () => {
-            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            this._nodeInfo.setScope(node, this._currentScope);
             const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
             if (enclosingClass) {
                 // Add the implicit "__class__" symbol described in PEP 3135.
@@ -402,7 +459,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                 isInExceptSuite: this._isInExceptSuite,
                             };
                             symbol.addDeclaration(paramDeclaration);
-                            AnalyzerNodeInfo.setDeclaration(paramNode.d.name, paramDeclaration);
+                            this._nodeInfo.setDeclaration(paramNode.d.name, paramDeclaration);
                         }
                         this._createFlowAssignment(paramNode.d.name);
                     }
@@ -414,15 +471,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._targetFunctionDeclaration = undefined;
                 // Associate the code flow node at the end of the suite with
                 // the suite.
-                AnalyzerNodeInfo.setAfterFlowNode(node.d.suite, this._currentFlowNode);
+                this._nodeInfo.setAfterFlowNode(node.d.suite, this._currentFlowNode);
                 // Compute the final return flow node and associate it with
                 // the function's parse node. If this node is unreachable, then
                 // the function never returns.
                 this._addAntecedent(this._currentReturnTarget, this._currentFlowNode);
                 const returnFlowNode = this._finishFlowLabel(this._currentReturnTarget);
-                AnalyzerNodeInfo.setAfterFlowNode(node, returnFlowNode);
-                AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
-                AnalyzerNodeInfo.setCodeFlowComplexity(node, this._codeFlowComplexity);
+                this._nodeInfo.setAfterFlowNode(node, returnFlowNode);
+                this._nodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
+                this._nodeInfo.setCodeFlowComplexity(node, this._codeFlowComplexity);
             });
         });
         this._createAssignmentTargetFlowNodes(node.d.name, /* walkTargets */ false, /* unbound */ false);
@@ -431,7 +488,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitLambda(node) {
         this._createVariableAnnotationFlowNode();
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         // Analyze the parameter defaults in the context of the parent's scope
         // before we add any names from the function's scope.
         node.d.params.forEach((param) => {
@@ -442,7 +499,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._createNewScope(2 /* ScopeType.Function */, this._getNonClassParentScope(), 
         /* proxyScope */ undefined, 
         /* chainedModuleLevelScopeLookup */ undefined, () => {
-            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            this._nodeInfo.setScope(node, this._currentScope);
             const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
             if (enclosingClass) {
                 // Lambdas create the same implicit __class__ closure as named functions.
@@ -464,28 +521,31 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                 isInExceptSuite: this._isInExceptSuite,
                             };
                             symbol.addDeclaration(paramDeclaration);
-                            AnalyzerNodeInfo.setDeclaration(paramNode.d.name, paramDeclaration);
+                            this._nodeInfo.setDeclaration(paramNode.d.name, paramDeclaration);
                         }
                         this._createFlowAssignment(paramNode.d.name);
                         this.walk(paramNode.d.name);
-                        AnalyzerNodeInfo.setFlowNode(paramNode, this._currentFlowNode);
+                        this._nodeInfo.setFlowNode(paramNode, this._currentFlowNode);
                     }
                 });
                 // Walk the expression that make up the lambda body.
                 this.walk(node.d.expr);
-                AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
+                this._nodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
             });
         });
         // We'll walk the child nodes in a deferred manner.
         return false;
     }
     visitCall(node) {
+        if (this._currentScope.type === 3 /* ScopeType.Class */ && doesCallExposeClassNamespace(this._currentScope, node)) {
+            this._currentScope.hasPotentiallyDynamicSymbolTable = true;
+        }
         this._disableTrueFalseTargets(() => {
             this.walk(node.d.leftExpr);
             const sortedArgs = ParseTreeUtils.getArgsByRuntimeOrder(node);
             sortedArgs.forEach((argNode) => {
                 if (this._currentFlowNode) {
-                    AnalyzerNodeInfo.setFlowNode(argNode, this._currentFlowNode);
+                    this._nodeInfo.setFlowNode(argNode, this._currentFlowNode);
                 }
                 this.walk(argNode);
             });
@@ -590,7 +650,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 isInExceptSuite: this._isInExceptSuite,
             };
             symbol.addDeclaration(paramDeclaration);
-            AnalyzerNodeInfo.setDeclaration(name, paramDeclaration);
+            this._nodeInfo.setDeclaration(name, paramDeclaration);
             if (typeParamsSeen.has(name.d.value)) {
                 this._addSyntaxError(localize_1.LocMessage.typeParameterExistingTypeParameter().format({ name: name.d.value }), name);
             }
@@ -603,7 +663,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this.walk(param.d.defaultExpr);
             }
         });
-        AnalyzerNodeInfo.setScope(node, typeParamScope);
+        this._nodeInfo.setScope(node, typeParamScope);
         return false;
     }
     visitTypeAlias(node) {
@@ -612,7 +672,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         let typeParamScope;
         if (node.d.typeParams) {
             this.walk(node.d.typeParams);
-            typeParamScope = AnalyzerNodeInfo.getScope(node.d.typeParams);
+            typeParamScope = this._nodeInfo.getScope(node.d.typeParams);
         }
         const typeAliasDeclaration = {
             type: 4 /* DeclarationType.TypeAlias */,
@@ -628,7 +688,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             symbol.addDeclaration(typeAliasDeclaration);
         }
         // Stash the declaration in the parse node for later access.
-        AnalyzerNodeInfo.setDeclaration(node, typeAliasDeclaration);
+        this._nodeInfo.setDeclaration(node, typeAliasDeclaration);
         this._createAssignmentTargetFlowNodes(node.d.name, /* walkTargets */ true, /* unbound */ false);
         const prevScope = this._currentScope;
         this._currentScope = typeParamScope ?? this._currentScope;
@@ -766,9 +826,23 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     });
                 }
+                else if (expr.nodeType === 18 /* ParseNodeType.Dictionary */) {
+                    expr.d.items.forEach((dictionaryEntryNode) => {
+                        if (dictionaryEntryNode.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */ &&
+                            dictionaryEntryNode.d.keyExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
+                            dictionaryEntryNode.d.keyExpr.d.strings.length === 1 &&
+                            dictionaryEntryNode.d.keyExpr.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                            this._dunderSlotsEntries.push(dictionaryEntryNode.d.keyExpr);
+                        }
+                        else {
+                            isExpressionUnderstood = false;
+                        }
+                    });
+                }
                 else {
                     isExpressionUnderstood = false;
                 }
+                this._currentScope.setHasNonEmptySlots(this._dunderSlotsEntries.some((entry) => entry.d.strings[0].d.value !== '__dict__'));
                 if (!isExpressionUnderstood) {
                     this._dunderSlotsEntries = undefined;
                 }
@@ -783,7 +857,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Evaluate the operand expression.
             this.walk(node.d.rightExpr);
         });
-        const evaluationNode = ParseTreeUtils.getEvaluationNodeForAssignmentExpression(node);
+        const evaluationNode = ParseTreeUtils.getEvaluationNodeForAssignmentExpression(node, this._nodeInfo);
         if (!evaluationNode) {
             this._addSyntaxError(localize_1.LocMessage.assignmentExprContext(), node);
             this.walk(node.d.name);
@@ -793,7 +867,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // because of the behavior defined in PEP 572. Targets of assignment
             // expressions don't bind to a list comprehension's scope but instead
             // bind to its containing scope.
-            const containerScope = AnalyzerNodeInfo.getScope(evaluationNode);
+            const containerScope = this._nodeInfo.getScope(evaluationNode);
             // If we're in a list comprehension (possibly nested), make sure that
             // local for targets don't collide with the target of the assignment
             // expression.
@@ -997,10 +1071,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._targetFunctionDeclaration.returnStatements.push(node);
         }
         if (node.d.expr) {
-            AnalyzerNodeInfo.setFlowNode(node.d.expr, this._currentFlowNode);
+            this._nodeInfo.setFlowNode(node.d.expr, this._currentFlowNode);
             this.walk(node.d.expr);
         }
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         if (this._currentReturnTarget) {
             this._addAntecedent(this._currentReturnTarget, this._currentFlowNode);
         }
@@ -1026,15 +1100,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitMemberAccess(node) {
         this.walk(node.d.leftExpr);
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         return false;
     }
     visitName(node) {
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         return false;
     }
     visitIndex(node) {
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         this.walk(node.d.leftExpr);
         // If we're within an 'Annotated' type annotation, set the flag.
         const wasInAnnotatedAnnotation = this._isInAnnotatedAnnotation;
@@ -1056,7 +1130,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Determine if the test condition is always true or always false. If so,
             // we can treat either the then or the else clause as unconditional.
             const constExprValue = StaticExpressions.evaluateStaticBoolLikeExpression(node.d.testExpr, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
-            AnalyzerNodeInfo.setStaticConditionValue(node, constExprValue);
+            this._nodeInfo.setStaticConditionValue(node, constExprValue);
             this._bindConditional(node.d.testExpr, thenLabel, elseLabel);
             // Handle the if clause.
             this._currentFlowNode =
@@ -1295,7 +1369,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitAwait(node) {
         // Make sure this is within an async lambda or function.
-        const execScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
+        const execScopeNode = ParseTreeUtils.getExecutionScopeNode(node, this._nodeInfo);
         if (execScopeNode?.nodeType !== 31 /* ParseNodeType.Function */ || !execScopeNode.d.isAsync) {
             if (this._fileInfo.ipythonMode && execScopeNode?.nodeType === 36 /* ParseNodeType.Module */) {
                 // Top level await is allowed in ipython mode.
@@ -1392,7 +1466,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     this._potentialHiddenSymbols.set(symbolName, symbol);
                 }
             }
-            const importInfo = AnalyzerNodeInfo.getImportInfo(node.d.module);
+            const importInfo = this._nodeInfo.getImportInfo(node.d.module);
             (0, debug_1.assert)(importInfo !== undefined);
             if (symbol) {
                 this._createAliasDeclarationForMultipartImportName(node, node.d.alias, importInfo, symbol);
@@ -1414,9 +1488,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitImportFrom(node) {
         const typingSymbolsOfInterest = ['Final', 'ClassVar', 'Annotated'];
-        const dataclassesSymbolsOfInterest = ['InitVar'];
-        const importInfo = AnalyzerNodeInfo.getImportInfo(node.d.module);
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        const dataclassesSymbolsOfInterest = ['InitVar', 'KW_ONLY'];
+        const importInfo = this._nodeInfo.getImportInfo(node.d.module);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         let resolvedPath = uri_1.Uri.empty();
         if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib) {
             resolvedPath = importInfo.resolvedUris[importInfo.resolvedUris.length - 1];
@@ -1556,7 +1630,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             node.d.imports.forEach((importSymbolNode) => {
                 const importedName = importSymbolNode.d.name.d.value;
                 const nameNode = importSymbolNode.d.alias || importSymbolNode.d.name;
-                AnalyzerNodeInfo.setFlowNode(importSymbolNode, this._currentFlowNode);
+                this._nodeInfo.setFlowNode(importSymbolNode, this._currentFlowNode);
                 const symbol = this._bindNameToScope(this._currentScope, nameNode);
                 if (symbol) {
                     // All import statements of the form `from . import x` treat x
@@ -1785,7 +1859,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._createNewScope(1 /* ScopeType.Comprehension */, this._getNonClassParentScope(), 
         /* proxyScope */ undefined, 
         /* chainedModuleLevelScopeLookup */ undefined, () => {
-            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            this._nodeInfo.setScope(node, this._currentScope);
             const falseLabel = this._createBranchLabel();
             // We'll walk the forIfNodes list twice. The first time we'll
             // bind targets of for statements. The second time we'll walk
@@ -2123,7 +2197,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     _createAliasDeclarationForMultipartImportName(node, importAlias, importInfo, symbol) {
         const firstNamePartValue = node.d.module.d.nameParts[0].d.value;
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
         let uriOfFirstSubmodule;
         if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib && importInfo.resolvedUris.length > 0) {
             uriOfFirstSubmodule = importInfo.resolvedUris[0];
@@ -2199,7 +2273,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // See if there is import info for this part of the path. This allows us
         // to implicitly import all of the modules in a multi-part module name.
-        const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.d.module.d.nameParts[0]);
+        const implicitImportInfo = this._nodeInfo.getImportInfo(node.d.module.d.nameParts[0]);
         if (implicitImportInfo && implicitImportInfo.resolvedUris.length) {
             newDecl.uri = implicitImportInfo.resolvedUris[0];
             newDecl.loadSymbolsFromPath = true;
@@ -2254,7 +2328,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     // is import info for this part of the path. This allows us to implicitly
                     // import all of the modules in a multi-part module name (e.g. "import a.b.c"
                     // imports "a" and "a.b" and "a.b.c").
-                    const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.d.module.d.nameParts[i]);
+                    const implicitImportInfo = this._nodeInfo.getImportInfo(node.d.module.d.nameParts[i]);
                     if (implicitImportInfo && implicitImportInfo.resolvedUris.length) {
                         loaderActions.uri = implicitImportInfo.resolvedUris[i];
                         loaderActions.loadSymbolsFromPath = true;
@@ -2271,7 +2345,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _walkStatementsAndReportUnreachable(statements) {
         let foundUnreachableStatement = false;
         for (const statement of statements) {
-            AnalyzerNodeInfo.setFlowNode(statement, this._currentFlowNode);
+            this._nodeInfo.setFlowNode(statement, this._currentFlowNode);
             if (!foundUnreachableStatement) {
                 foundUnreachableStatement = this._isCodeUnreachable();
             }
@@ -2292,7 +2366,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 // subtree, we need to create dummy scopes for them. The type analyzer
                 // depends on scopes being present.
                 if (!this._moduleSymbolOnly) {
-                    const dummyScopeGenerator = new DummyScopeGenerator(this._currentScope);
+                    const dummyScopeGenerator = new DummyScopeGenerator(this._currentScope, this._nodeInfo);
                     dummyScopeGenerator.walk(statement);
                 }
             }
@@ -2768,8 +2842,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // introduced in except clauses. If there is no use the previous flow node
         // associated, use the previous flow node (applies in the del case).
         // Otherwise, the node will be evaluated as unbound at this point in the flow.
-        if (!unbound || AnalyzerNodeInfo.getFlowNode(node) === undefined) {
-            AnalyzerNodeInfo.setFlowNode(node, unbound ? prevFlowNode : this._currentFlowNode);
+        if (!unbound || this._nodeInfo.getFlowNode(node) === undefined) {
+            this._nodeInfo.setFlowNode(node, unbound ? prevFlowNode : this._currentFlowNode);
         }
     }
     _createFlowWildcardImport(node, names) {
@@ -2784,7 +2858,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._addExceptTargets(flowNode);
             this._currentFlowNode = flowNode;
         }
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
     }
     _createFlowExhaustedMatch(node) {
         if (!this._isCodeUnreachable()) {
@@ -2797,7 +2871,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             };
             this._currentFlowNode = flowNode;
         }
-        AnalyzerNodeInfo.setAfterFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setAfterFlowNode(node, this._currentFlowNode);
     }
     _isCodeUnreachable() {
         return !!(this._currentFlowNode.flags &
@@ -2893,6 +2967,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return undefined;
     }
     _bindPossibleTupleNamedTarget(target, addedSymbols) {
+        if (this._currentScope.type === 3 /* ScopeType.Class */ && !isStaticClassAssignmentTarget(target)) {
+            this._currentScope.hasPotentiallyDynamicSymbolTable = true;
+        }
         switch (target.nodeType) {
             case 38 /* ParseNodeType.Name */: {
                 this._bindNameToScope(this._currentScope, target, addedSymbols);
@@ -2986,7 +3063,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // state so that hits from later cells are correctly marked.
         return (name, context) => {
             for (const moduleNode of cellChainIndex.getLaterModuleNodes(fileUri) ?? []) {
-                const moduleScope = AnalyzerNodeInfo.getScope(moduleNode);
+                const moduleScope = this._nodeInfo.getScope(moduleNode);
                 if (!moduleScope) {
                     continue;
                 }
@@ -3183,6 +3260,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                             }
                         }
                     }
+                    if (this._isDataclassesAnnotation(typeAnnotation, 'KW_ONLY')) {
+                        symbolWithScope.symbol.setIsDataClassKeywordOnly();
+                    }
+                    else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ &&
+                        this._isTypingAnnotation(typeAnnotation.d.leftExpr, 'Annotated') &&
+                        typeAnnotation.d.items.length > 0 &&
+                        this._isDataclassesAnnotation(typeAnnotation.d.items[0].d.valueExpr, 'KW_ONLY')) {
+                        symbolWithScope.symbol.setIsDataClassKeywordOnly();
+                    }
                 }
                 declarationHandled = true;
                 break;
@@ -3249,8 +3335,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _isKnownAnnotation(typeAnnotation, name, importAliases, symbolAliases) {
         let annotationNode = typeAnnotation;
         // Is this a quoted annotation?
-        if (annotationNode.nodeType === 48 /* ParseNodeType.StringList */ && annotationNode.d.annotation) {
-            annotationNode = annotationNode.d.annotation;
+        if (annotationNode.nodeType === 48 /* ParseNodeType.StringList */) {
+            annotationNode = this._nodeInfo.getStringAnnotation(annotationNode) ?? annotationNode;
         }
         if (annotationNode.nodeType === 38 /* ParseNodeType.Name */) {
             const alias = symbolAliases.get(annotationNode.d.value);
@@ -3322,8 +3408,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         let classVarTypeNode;
         while (typeAnnotation) {
             // Is this a quoted annotation?
-            if (typeAnnotation.nodeType === 48 /* ParseNodeType.StringList */ && typeAnnotation.d.annotation) {
-                typeAnnotation = typeAnnotation.d.annotation;
+            if (typeAnnotation.nodeType === 48 /* ParseNodeType.StringList */) {
+                typeAnnotation = this._nodeInfo.getStringAnnotation(typeAnnotation) ?? typeAnnotation;
             }
             if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ &&
                 typeAnnotation.d.items.length > 0 &&
@@ -3422,7 +3508,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
         }
-        const classScope = AnalyzerNodeInfo.getScope(classNode);
+        const classScope = this._nodeInfo.getScope(classNode);
         (0, debug_1.assert)(classScope !== undefined);
         return {
             classNode,
@@ -3629,7 +3715,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         if (symbol) {
             symbol.addDeclaration(specialBuiltInClassDeclaration);
         }
-        AnalyzerNodeInfo.setDeclaration(node, specialBuiltInClassDeclaration);
+        this._nodeInfo.setDeclaration(node, specialBuiltInClassDeclaration);
         return true;
     }
     _deferBinding(callback) {
@@ -3673,7 +3759,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         if (node.d.expr) {
             this.walk(node.d.expr);
         }
-        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        this._nodeInfo.setFlowNode(node, this._currentFlowNode);
     }
     _getUniqueFlowNodeId() {
         this._codeFlowComplexity += flowNodeComplexityContribution;
@@ -3752,16 +3838,17 @@ exports.ReturnFinder = ReturnFinder;
 // will still evaluate these types, and it depends on the presence
 // of a scope.
 class DummyScopeGenerator extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(currentScope) {
+    constructor(currentScope, _nodeInfo) {
         super();
+        this._nodeInfo = _nodeInfo;
         this._currentScope = currentScope;
     }
     visitClass(node) {
         const newScope = this._createNewScope(3 /* ScopeType.Class */, () => {
             this.walk(node.d.suite);
         });
-        if (!AnalyzerNodeInfo.getScope(node)) {
-            AnalyzerNodeInfo.setScope(node, newScope);
+        if (!this._nodeInfo.getScope(node)) {
+            this._nodeInfo.setScope(node, newScope);
         }
         return false;
     }
@@ -3769,8 +3856,8 @@ class DummyScopeGenerator extends parseTreeWalker_1.ParseTreeWalker {
         const newScope = this._createNewScope(2 /* ScopeType.Function */, () => {
             this.walk(node.d.suite);
         });
-        if (!AnalyzerNodeInfo.getScope(node)) {
-            AnalyzerNodeInfo.setScope(node, newScope);
+        if (!this._nodeInfo.getScope(node)) {
+            this._nodeInfo.setScope(node, newScope);
         }
         return false;
     }