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

package/dist/analyzer/binder.js

@@ -68,6 +68,63 @@ 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
@@ -480,6 +537,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         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);
@@ -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;
                 }
@@ -1414,7 +1488,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitImportFrom(node) {
         const typingSymbolsOfInterest = ['Final', 'ClassVar', 'Annotated'];
-        const dataclassesSymbolsOfInterest = ['InitVar'];
+        const dataclassesSymbolsOfInterest = ['InitVar', 'KW_ONLY'];
         const importInfo = AnalyzerNodeInfo.getImportInfo(node.d.module);
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
         let resolvedPath = uri_1.Uri.empty();
@@ -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);
@@ -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;