@zzzen/pyright-internal 1.2.0-dev.20260628 → 1.2.0-dev.20260705

package/dist/analyzer/binder.js

@@ -291,12 +291,35 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             AnalyzerNodeInfo.setScope(node, this._currentScope);
             this._addImplicitSymbolToCurrentScope('__doc__', node, 'str | None');
             this._addImplicitSymbolToCurrentScope('__module__', node, 'str');
-            this._addImplicitSymbolToCurrentScope('__qualname__', node, 'str');
             this._dunderSlotsEntries = undefined;
             if (!this._moduleSymbolOnly) {
                 // Analyze the suite.
                 this.walk(node.d.suite);
             }
+            // `__qualname__` is exposed via the metaclass (`type`) rather than as a
+            // class/instance attribute, unlike `__doc__`/`__module__`. We handle it
+            // after walking the suite so we can tell whether the class body already
+            // declared it.
+            const existingQualname = this._currentScope.lookUpSymbol('__qualname__');
+            if (existingQualname) {
+                // The class explicitly declares `__qualname__` (e.g. typeshed `type`,
+                // `function`, or a user `__qualname__ = "..."`). Keep that real
+                // declaration untouched so hover, go-to-definition, and completion all
+                // resolve to it. We must not append a synthetic empty-range Intrinsic
+                // declaration on top, because declaration-selecting consumers (e.g.
+                // `getLastTypedDeclarationForSymbol`) would otherwise resolve to the
+                // empty range instead of the real declaration. We still mark it as
+                // ignored for protocol matching, matching the implicit-dunder treatment.
+                existingQualname.setIsIgnoredForProtocolMatch();
+            }
+            else {
+                // The class does not declare `__qualname__`. Add it as a non-class
+                // member so it is name-resolvable within the class body (e.g.
+                // `print(__qualname__)`) but is not exposed as a class/instance
+                // attribute. Otherwise instance access (`instance.__qualname__`) would
+                // incorrectly resolve instead of reporting an attribute-access error.
+                this._addImplicitSymbolToCurrentScope('__qualname__', node, 'str', /* isClassMember */ false);
+            }
             if (this._dunderSlotsEntries) {
                 this._addSlotsToCurrentScope(this._dunderSlotsEntries);
             }
@@ -2891,8 +2914,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _addImplicitSymbolToCurrentScope(nameValue, node, type) {
-        const symbol = this._addSymbolToCurrentScope(nameValue, /* isInitiallyUnbound */ false);
+    _addImplicitSymbolToCurrentScope(nameValue, node, type, isClassMember = true) {
+        const symbol = this._addSymbolToCurrentScope(nameValue, /* isInitiallyUnbound */ false, isClassMember);
         if (symbol) {
             symbol.addDeclaration({
                 type: 0 /* DeclarationType.Intrinsic */,
@@ -2908,14 +2931,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     // Adds a new symbol with the specified name if it doesn't already exist.
-    _addSymbolToCurrentScope(nameValue, isInitiallyUnbound) {
+    _addSymbolToCurrentScope(nameValue, isInitiallyUnbound, isClassMember = true) {
         let symbol = this._currentScope.lookUpSymbol(nameValue);
         if (!symbol) {
             let symbolFlags = 0 /* SymbolFlags.None */;
             if (isInitiallyUnbound) {
                 symbolFlags |= 1 /* SymbolFlags.InitiallyUnbound */;
             }
-            if (this._currentScope.type === 3 /* ScopeType.Class */) {
+            if (this._currentScope.type === 3 /* ScopeType.Class */ && isClassMember) {
                 symbolFlags |= 4 /* SymbolFlags.ClassMember */;
             }
             if (this._fileInfo.isStubFile && (0, symbolNameUtils_1.isPrivateOrProtectedName)(nameValue)) {
@@ -3428,6 +3451,29 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         if (!importedModuleAliasDecl) {
             return false;
         }
+        // The imported symbol may be both an implicitly-imported submodule and a
+        // class/function/variable of the same name (e.g. a package that re-exports
+        // a class whose name matches a submodule). In that case the non-module
+        // declaration appears later in the declaration list and "wins" when the
+        // symbol is resolved. Only treat this wildcard re-export as a pure submodule
+        // re-export when the module alias is the symbol's last declaration;
+        // otherwise fall through so a normal alias declaration is created that
+        // resolves to the winning symbol.
+        //
+        // We compare against the raw last declaration (not getLastTypedDeclarationForSymbol)
+        // on purpose: a module alias is a DeclarationType.Alias, which hasTypeForDeclaration
+        // treats as untyped, so it never appears among a symbol's typed declarations.
+        // The evaluator resolves alias symbols (like this one, whose declarations are all
+        // imports) by declaration order, so the last declaration is the relevant "winner"
+        // here. When this guard falls through, the alias created by the caller resolves to
+        // the winning (e.g. class) declaration and intentionally has no submoduleFallback:
+        // the class shadows the submodule, so submodule member access through the
+        // re-exported name is no longer offered. The genuine-submodule case (where the
+        // module alias is the last declaration) keeps its module/submodule behavior.
+        const importedDecls = importedSymbol.getDeclarations();
+        if (importedDecls[importedDecls.length - 1] !== importedModuleAliasDecl) {
+            return false;
+        }
         const existingModuleAliasDecl = this._getMultipartModuleAliasDeclaration(localSymbol, importedModuleAliasDecl.moduleName, importedModuleAliasDecl.firstNamePart);
         if (existingModuleAliasDecl) {
             this._mergeModuleLoaderActions(existingModuleAliasDecl, importedModuleAliasDecl);