@zzzen/pyright-internal 1.2.0-dev.20260222 → 1.2.0-dev.20260422

package/dist/analyzer/typeEvaluator.js

@@ -373,7 +373,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function popSymbolResolution(symbol) {
         const poppedEntry = symbolResolutionStack.pop();
-        (0, debug_1.assert)(poppedEntry.symbolId === symbol.id);
+        (0, debug_1.assert)(poppedEntry !== undefined && poppedEntry.symbolId === symbol.id, `Symbol resolution stack mismatch: expected symbol ${symbol.id}, got ${poppedEntry?.symbolId ?? 'empty stack'}`);
         return poppedEntry.isResultValid;
     }
     function setSymbolResolutionPartialType(symbol, declaration, type) {
@@ -471,8 +471,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const expectedType = expectedTypeCache.get(curNode.id);
             if (expectedType) {
                 return {
-                    type: expectedType,
+                    type: expectedType.type,
                     node: curNode,
+                    candidates: (0, typeEvaluatorTypes_1.ensureExpectedTypeCandidates)(expectedType.type, expectedType.candidates),
                 };
             }
             if (curNode === topExpression) {
@@ -482,6 +483,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
+    function addExpectedTypeCacheEntry(node, expectedType) {
+        const cached = expectedTypeCache.get(node.id);
+        if (!cached) {
+            expectedTypeCache.set(node.id, {
+                type: expectedType,
+                candidates: [expectedType],
+            });
+            return;
+        }
+        cached.type = expectedType;
+        if (!cached.candidates.some((candidate) => (0, types_1.isTypeSame)(candidate, expectedType))) {
+            cached.candidates.push(expectedType);
+        }
+    }
     function initializePrefetchedTypes(node) {
         if (!prefetched) {
             // Some of these types have cyclical dependencies on each other,
@@ -614,7 +629,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (inferenceContext &&
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
             !(0, types_1.isNever)(inferenceContext.expectedType)) {
-            expectedTypeCache.set(node.id, inferenceContext.expectedType);
+            addExpectedTypeCacheEntry(node, inferenceContext.expectedType);
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 // Make sure the resulting type is assignable to the expected type.
@@ -9810,7 +9825,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return result;
             }
         }
-        const result = getTypeOfDictionaryInferred(node, flags, /* hasExpectedType */ !!inferenceContext?.expectedType);
+        // Don't force strict inference when the expected type is a TypeVar that
+        // couldn't constrain the dict's key/value structure. A TypeVar like _T
+        // from sorted(Iterable[_T], key=...) doesn't provide useful type
+        // information for dict inference, and forcing strict inference would
+        // widen heterogeneous value types into a union that can cause false
+        // positives (e.g., dict[str, Path | str | dict[Any, Any]] when the
+        // user meant each key to have a specific type).
+        // Note: bounded/constrained TypeVars with dict-like bounds are handled
+        // by getTypeOfDictionaryWithContext above (via makeTopLevelTypeVarsConcrete),
+        // so they don't reach this fallback.
+        const hasUsefulExpectedType = !!inferenceContext?.expectedType && !(0, types_1.isTypeVar)(inferenceContext.expectedType);
+        const result = getTypeOfDictionaryInferred(node, flags, /* hasExpectedType */ hasUsefulExpectedType);
         return { ...result, expectedTypeDiagAddendum };
     }
     function getTypeOfDictionaryWithContext(node, flags, inferenceContext, expectedDiagAddendum) {
@@ -13883,6 +13909,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                         });
                                         // Do not retain TypeForm types in inferred return types.
                                         returnType = (0, typeUtils_1.stripTypeForm)(returnType);
+                                        // If we're returning a function value (or overload), force
+                                        // lazy return-type inference before caching this function's
+                                        // inferred return. Without this, a partially evaluated
+                                        // function can leak a temporary Any return type (for example,
+                                        // immediately after an edit), and that Any then gets cached
+                                        // as though it were final for the enclosing function.
+                                        inferReturnTypeIfNecessary(returnType);
                                         inferredReturnTypes.push(returnType);
                                     }
                                     else {
@@ -15482,7 +15515,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function lookUpSymbolRecursive(node, name, honorCodeFlow, preferGlobalScope = false) {
         const scopeNodeInfo = ParseTreeUtils.getEvaluationScopeNode(node);
         const scope = AnalyzerNodeInfo.getScope(scopeNodeInfo.node);
-        let symbolWithScope = scope?.lookUpSymbolRecursive(name, { useProxyScope: !!scopeNodeInfo.useProxyScope });
+        let symbolWithScope = scope?.lookUpSymbolRecursive(name, {
+            useProxyScope: !!scopeNodeInfo.useProxyScope,
+            useChainedModuleLevelScopes: !!scopeNodeInfo.useChainedModuleLevelScopes,
+        });
         const scopeType = scope?.type ?? 4 /* ScopeType.Module */;
         // Functions and list comprehensions don't allow access to implicitly
         // aliased symbols in outer scopes if they haven't yet been assigned
@@ -15715,6 +15751,36 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
+    function _shouldFallBackToClassEntryForKeywordArg(baseType, paramName) {
+        return (types_1.ClassType.isDataClass(baseType) ||
+            types_1.ClassType.isTypedDictClass(baseType) ||
+            types_1.ClassType.hasNamedTupleEntry(baseType, paramName));
+    }
+    function _addSymbolDeclInfo(symbol, decls, synthesizedTypes, preferTypedDeclarations = false) {
+        const declCountBeforeAdd = decls.length;
+        const typedDecls = preferTypedDeclarations ? symbol.getTypedDeclarations() : undefined;
+        (0, collectionUtils_1.appendArray)(decls, typedDecls?.length ? typedDecls : symbol.getDeclarations());
+        const synthTypeInfo = symbol.getSynthesizedType();
+        if (synthTypeInfo) {
+            synthesizedTypes.push(synthTypeInfo);
+            // Some module members are represented only by a synthesized module type,
+            // with no concrete declaration node to navigate to. Synthesize a matching
+            // alias declaration so definition/declaration/reference features can still
+            // bind to the submodule's file.
+            if (decls.length === declCountBeforeAdd &&
+                (0, types_1.isModule)(synthTypeInfo.type) &&
+                !synthTypeInfo.type.priv.fileUri.isEmpty()) {
+                decls.push((0, declarationUtils_1.synthesizeAliasDeclaration)(synthTypeInfo.type.priv.fileUri));
+            }
+        }
+    }
+    function _addClassEntryDeclsForKeywordArgIfPresent(baseType, paramName, decls, synthesizedTypes) {
+        const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
+        if (!lookupResults) {
+            return;
+        }
+        _addSymbolDeclInfo(lookupResults.symbol, decls, synthesizedTypes);
+    }
     // In general, string nodes don't have any declarations associated with them, but
     // we need to handle the special case of string literals used as keys within a
     // dictionary expression where those keys are associated with a known TypedDict.
@@ -15733,11 +15799,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (entry) {
                         const symbol = (0, typeUtils_1.lookUpObjectMember)(subtype, node.d.value)?.symbol;
                         if (symbol) {
-                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
-                            const synthTypeInfo = symbol.getSynthesizedType();
-                            if (synthTypeInfo) {
-                                synthesizedTypes.push(synthTypeInfo);
-                            }
+                            _addSymbolDeclInfo(symbol, decls, synthesizedTypes);
                         }
                     }
                 }
@@ -15824,17 +15886,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // By default, report only the declarations that have type annotations.
                         // If there are none, then report all of the unannotated declarations,
                         // which includes every assignment of that symbol.
-                        const typedDecls = symbol.getTypedDeclarations();
-                        if (typedDecls.length > 0) {
-                            (0, collectionUtils_1.appendArray)(decls, typedDecls);
-                        }
-                        else {
-                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
-                        }
-                        const synthTypeInfo = symbol.getSynthesizedType();
-                        if (synthTypeInfo) {
-                            synthesizedTypes.push(synthTypeInfo);
-                        }
+                        _addSymbolDeclInfo(symbol, decls, synthesizedTypes, /* preferTypedDeclarations */ true);
                     }
                 });
             }
@@ -15884,34 +15936,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (paramDecl) {
                                 decls.push(paramDecl);
                             }
-                            else if (types_1.ClassType.isDataClass(baseType) ||
-                                types_1.ClassType.isTypedDictClass(baseType) ||
-                                types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
-                                const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
-                                if (lookupResults) {
-                                    (0, collectionUtils_1.appendArray)(decls, lookupResults.symbol.getDeclarations());
-                                    const synthTypeInfo = lookupResults.symbol.getSynthesizedType();
-                                    if (synthTypeInfo) {
-                                        synthesizedTypes.push(synthTypeInfo);
-                                    }
-                                }
+                            else if (_shouldFallBackToClassEntryForKeywordArg(baseType, paramName)) {
+                                _addClassEntryDeclsForKeywordArgIfPresent(baseType, paramName, decls, synthesizedTypes);
                             }
                         }
-                        else if (types_1.ClassType.isDataClass(baseType) ||
-                            types_1.ClassType.isTypedDictClass(baseType) ||
-                            types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
+                        else if (_shouldFallBackToClassEntryForKeywordArg(baseType, paramName)) {
                             // Some synthesized callables (notably TypedDict "constructors") don't have a
                             // meaningful __init__ signature we can map keyword arguments to. In these cases,
                             // treat the keyword as referring to the class entry so IDE features like
                             // go-to-definition and rename can bind to the field declaration.
-                            const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
-                            if (lookupResults) {
-                                (0, collectionUtils_1.appendArray)(decls, lookupResults.symbol.getDeclarations());
-                                const synthTypeInfo = lookupResults.symbol.getSynthesizedType();
-                                if (synthTypeInfo) {
-                                    synthesizedTypes.push(synthTypeInfo);
-                                }
-                            }
+                            _addClassEntryDeclsForKeywordArgIfPresent(baseType, paramName, decls, synthesizedTypes);
                         }
                     }
                 }
@@ -15934,11 +15968,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
             const symbolWithScope = lookUpSymbolRecursive(node, node.d.value, !allowForwardReferences, isWithinTypeAnnotation);
             if (symbolWithScope) {
-                (0, collectionUtils_1.appendArray)(decls, symbolWithScope.symbol.getDeclarations());
-                const synthTypeInfo = symbolWithScope.symbol.getSynthesizedType();
-                if (synthTypeInfo) {
-                    synthesizedTypes.push(synthTypeInfo);
-                }
+                _addSymbolDeclInfo(symbolWithScope.symbol, decls, synthesizedTypes);
             }
         }
         return { decls, synthesizedTypes };
@@ -16619,7 +16649,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
                     const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
                     if (usageScope === declScope) {
-                        if (!isFlowPathBetweenNodes(decl.node, usageNode)) {
+                        // Skip declarations that appear after the usage in the source.
+                        // Such declarations are typically only reached via loop back-edges,
+                        // and including them causes circular evaluation (producing Unknown).
+                        // Declarations that textually precede the usage are retained so
+                        // that order-independent type aliases resolve correctly; for
+                        // branching constructs (if/else, try/except), a retained
+                        // declaration may be flow-unreachable at the usage site, but the
+                        // code-flow engine overrides the effective type for local
+                        // variables, so the narrowed type at the usage site is correct.
+                        // Note: for the cases filtered out here (decl after usage in same
+                        // scope), the code-flow engine handles loop-carried narrowing when
+                        // it evaluates the type at the actual usage site.
+                        if (decl.node.start >= usageNode.start) {
                             return;
                         }
                     }
@@ -16670,11 +16712,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let includesSpeculativeResult = false;
         decls.forEach((decl) => {
             if (pushSymbolResolution(symbol, decl)) {
+                let symbolPopped = false;
                 try {
                     let type = getInferredTypeOfDeclaration(symbol, decl);
                     if (!popSymbolResolution(symbol)) {
                         isIncomplete = true;
                     }
+                    symbolPopped = true;
                     if (type) {
                         if (decl.type === 1 /* DeclarationType.Variable */) {
                             let isConstant = false;
@@ -16707,8 +16751,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 catch (e) {
-                    // Clean up the stack before rethrowing.
-                    popSymbolResolution(symbol);
+                    // Clean up the stack before rethrowing, but only if we haven't already popped.
+                    if (!symbolPopped) {
+                        popSymbolResolution(symbol);
+                    }
                     throw e;
                 }
             }
@@ -16792,6 +16838,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
                         const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
                         if (usageScope === declScope) {
+                            // For typed declarations we use the precise flow-graph reachability
+                            // check rather than a simple position comparison, because typed decls
+                            // (e.g. explicit annotations) can legitimately appear after the usage
+                            // in the source text (e.g. a class attribute annotated below a method
+                            // that references it) and must not be excluded by position alone.
                             if (!isFlowPathBetweenNodes(decl.node, usageNode, /* allowSelf */ false)) {
                                 return false;
                             }