@zzzen/pyright-internal 1.2.0-dev.20261101 → 1.2.0-dev.20261108

package/dist/analyzer/typeEvaluator/returnTypeInference.js

@@ -0,0 +1,226 @@
+"use strict";
+/*
+ * returnTypeInference.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Contextual return inference using evaluator-owned cache bindings and inference frames.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReturnTypeInference = createReturnTypeInference;
+const debug_1 = require("../../common/debug");
+const ParseTreeUtils = __importStar(require("../parseTreeUtils"));
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+// Infers contextual call-site returns; the evaluator owns the live caches and inference stack.
+function createReturnTypeInference(context) {
+    const { codeFlowEngine, convertSpecialFormToRuntimeValue, getTypeOfExpression, getTypeOfFunction, inferFunctionReturnType, maxCallSiteReturnTypeCacheSize, maxReturnCallSiteTypeInferenceCodeFlowComplexity, maxReturnTypeInferenceArgCount, maxReturnTypeInferenceStackSize, nodeInfo, returnTypeInferenceContextStack, speculativeTypeTracker, stripLiteralValue, suppressDiagnostics, writeTypeCache, } = context;
+    function isNodeInReturnTypeInferenceContext(node) {
+        const stackSize = returnTypeInferenceContextStack.length;
+        if (stackSize === 0) {
+            return false;
+        }
+        const contextNode = returnTypeInferenceContextStack[stackSize - 1];
+        let curNode = node;
+        while (curNode) {
+            if (curNode === contextNode.functionNode) {
+                return true;
+            }
+            curNode = curNode.parent;
+        }
+        return false;
+    }
+    function getCodeFlowAnalyzerForReturnTypeInferenceContext() {
+        const stackSize = returnTypeInferenceContextStack.length;
+        (0, debug_1.assert)(stackSize > 0);
+        const contextNode = returnTypeInferenceContextStack[stackSize - 1];
+        return contextNode.codeFlowAnalyzer;
+    }
+    function inferReturnTypeForCallSite(type, callSiteInfo) {
+        const args = callSiteInfo.args;
+        let contextualReturnType;
+        if (!type.shared.declaration) {
+            return undefined;
+        }
+        const functionNode = type.shared.declaration.node;
+        const codeFlowComplexity = nodeInfo.getCodeFlowComplexity(functionNode);
+        if (codeFlowComplexity >= maxReturnCallSiteTypeInferenceCodeFlowComplexity) {
+            return undefined;
+        }
+        // If an arg hasn't been matched to a specific named parameter,
+        // it's an unpacked value that corresponds to multiple parameters.
+        // That's an edge case that we don't handle here.
+        if (args.some((arg) => !arg.paramName)) {
+            return undefined;
+        }
+        // Detect recurrence. If a function invokes itself either directly
+        // or indirectly, we won't attempt to infer contextual return
+        // types any further.
+        if (returnTypeInferenceContextStack.some((context) => context.functionNode === functionNode)) {
+            return undefined;
+        }
+        const functionTypeResult = getTypeOfFunction(functionNode);
+        if (!functionTypeResult) {
+            return undefined;
+        }
+        // Very complex functions with many arguments can take a long time to analyze,
+        // so we'll use a heuristic and avoiding this inference technique for any
+        // call site that involves too many arguments.
+        if (args.length > maxReturnTypeInferenceArgCount) {
+            return undefined;
+        }
+        // Don't explore arbitrarily deep in the call graph.
+        if (returnTypeInferenceContextStack.length >= maxReturnTypeInferenceStackSize) {
+            return undefined;
+        }
+        const paramTypes = [];
+        let isResultFromCache = false;
+        // If the call is located in a loop, don't use literal argument types
+        // for the same reason we don't do literal math in loops.
+        const stripLiteralArgTypes = ParseTreeUtils.isWithinLoop(callSiteInfo.errorNode);
+        // Suppress diagnostics because we don't want to generate errors.
+        suppressDiagnostics(functionNode, () => {
+            // Argument expressions belong to the caller's contextual cache.
+            const argTypes = functionNode.d.params.map((param) => {
+                const arg = args.find((arg) => param.d.name?.d.value === arg.paramName);
+                return arg?.argument.valueExpression
+                    ? getTypeOfExpression(arg.argument.valueExpression).type
+                    : undefined;
+            });
+            // Allocate a new temporary type cache for the context of just
+            // this function so we can analyze it separately without polluting
+            // the main type cache.
+            const prevTypeCache = context.returnTypeInferenceTypeCache;
+            const prevTypeFormTypeCache = context.returnTypeInferenceTypeFormTypeCache;
+            returnTypeInferenceContextStack.push({
+                functionNode,
+                codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(),
+            });
+            try {
+                context.returnTypeInferenceTypeCache = new Map();
+                context.returnTypeInferenceTypeFormTypeCache = new Map();
+                let allArgTypesAreUnknown = true;
+                functionNode.d.params.forEach((param, index) => {
+                    if (param.d.name) {
+                        let paramType = argTypes[index];
+                        if (paramType) {
+                            if (!(0, types_1.isUnknown)(paramType)) {
+                                allArgTypesAreUnknown = false;
+                            }
+                        }
+                        else if (param.d.defaultValue) {
+                            paramType = getTypeOfExpression(param.d.defaultValue).type;
+                            if (!(0, types_1.isUnknown)(paramType)) {
+                                allArgTypesAreUnknown = false;
+                            }
+                        }
+                        else if (index === 0) {
+                            // If this is an instance or class method, use the implied
+                            // parameter type for the "self" or "cls" parameter.
+                            if (types_1.FunctionType.isInstanceMethod(functionTypeResult.functionType) ||
+                                types_1.FunctionType.isClassMethod(functionTypeResult.functionType)) {
+                                if (functionTypeResult.functionType.shared.parameters.length > 0) {
+                                    if (functionNode.d.params[0].d.name) {
+                                        paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, 0);
+                                    }
+                                }
+                            }
+                        }
+                        if (!paramType) {
+                            paramType = types_1.UnknownType.create();
+                        }
+                        if (stripLiteralArgTypes) {
+                            paramType = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(paramType), 0 /* EvalFlags.None */, 
+                            /* convertModule */ true));
+                        }
+                        paramTypes.push(paramType);
+                        writeTypeCache(param.d.name, { type: paramType }, 0 /* EvalFlags.None */);
+                    }
+                });
+                // Don't bother trying to determine the contextual return
+                // type if none of the argument types are known.
+                if (!allArgTypesAreUnknown) {
+                    // See if the return type is already cached. If so, skip the
+                    // inference step, which is potentially very expensive.
+                    const cacheEntry = functionTypeResult.functionType.priv.callSiteReturnTypeCache?.find((entry) => {
+                        return (entry.paramTypes.length === paramTypes.length &&
+                            entry.paramTypes.every((t, i) => (0, types_1.isTypeSame)(t, paramTypes[i])));
+                    });
+                    if (cacheEntry) {
+                        contextualReturnType = cacheEntry.returnType;
+                        isResultFromCache = true;
+                    }
+                    else {
+                        // Speculative results also depend on these temporary parameter bindings,
+                        // not just the expected types used during overload resolution.
+                        contextualReturnType = speculativeTypeTracker.useSpeculativeTypeCacheIsolation(() => inferFunctionReturnType(functionNode, types_1.FunctionType.isAbstractMethod(type), callSiteInfo?.errorNode))?.type;
+                    }
+                }
+            }
+            finally {
+                returnTypeInferenceContextStack.pop();
+                context.returnTypeInferenceTypeCache = prevTypeCache;
+                context.returnTypeInferenceTypeFormTypeCache = prevTypeFormTypeCache;
+            }
+        });
+        if (contextualReturnType) {
+            contextualReturnType = (0, types_1.removeUnbound)(contextualReturnType);
+            if (!isResultFromCache) {
+                // Cache the resulting type.
+                if (!functionTypeResult.functionType.priv.callSiteReturnTypeCache) {
+                    functionTypeResult.functionType.priv.callSiteReturnTypeCache = [];
+                }
+                if (functionTypeResult.functionType.priv.callSiteReturnTypeCache.length >=
+                    maxCallSiteReturnTypeCacheSize) {
+                    functionTypeResult.functionType.priv.callSiteReturnTypeCache =
+                        functionTypeResult.functionType.priv.callSiteReturnTypeCache.slice(1);
+                }
+                functionTypeResult.functionType.priv.callSiteReturnTypeCache.push({
+                    paramTypes,
+                    returnType: contextualReturnType,
+                });
+            }
+            return contextualReturnType;
+        }
+        return undefined;
+    }
+    return {
+        isNodeInReturnTypeInferenceContext,
+        getCodeFlowAnalyzerForReturnTypeInferenceContext,
+        inferReturnTypeForCallSite,
+    };
+}
+//# sourceMappingURL=returnTypeInference.js.map

package/dist/analyzer/typeEvaluator/returnTypeInference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"returnTypeInference.js","sourceRoot":"","sources":["../../../../../../src/analyzer/typeEvaluator/returnTypeInference.ts"],"names":[],"mappings":"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"}

package/dist/analyzer/typeEvaluator/specialFormCreation.d.ts

@@ -0,0 +1,39 @@
+import { ClassNode, ExpressionNode, IndexNode, ParseNode, TypeParameterNode } from '../../parser/parseNodes';
+import * as AnalyzerNodeInfo from '../analyzerNodeInfo';
+import { ClassTypeResult, EvalFlags, ExpectedTypeOptions, PrefetchedTypes, TypeEvaluator, TypeResult, TypeResultWithNode, ValidateTypeArgsOptions } from '../typeEvaluatorTypes';
+import { ClassType, Type, TypeCondition, TypeVarScopeId, TypeVarType, UnknownType } from '../types';
+interface Context {
+    readonly addDiagnostic: TypeEvaluator['addDiagnostic'];
+    readonly applyUnpackToTupleLike: (type: Type) => Type | undefined;
+    readonly getScopeIdForNode: (node: ParseNode) => string;
+    readonly getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
+    readonly getTupleClassType: () => ClassType | undefined;
+    readonly getTypeVarScopesForNode: (node: ParseNode) => string[];
+    readonly getTypingType: (node: ParseNode, symbolName: string) => Type | undefined;
+    readonly nodeInfo: AnalyzerNodeInfo.AnalyzerNodeInfoAccessor;
+    readonly prefetched: Partial<PrefetchedTypes> | undefined;
+    readonly validateTypeMetadata: (errorNode: ExpressionNode, baseType: Type, metaArg: TypeResultWithNode) => boolean;
+    readonly assignType: TypeEvaluator['assignType'];
+    readonly convertTypeArgToInstance: (type: Type, flags: EvalFlags) => Type;
+    readonly getTypeOfAnnotation: (node: ExpressionNode, options?: ExpectedTypeOptions) => Type;
+    readonly makeTopLevelTypeVarsConcrete: (type: Type, makeParamSpecsConcrete?: boolean, conditionFilter?: TypeCondition[]) => Type;
+    readonly printType: TypeEvaluator['printType'];
+    readonly getBuiltInType: TypeEvaluator['getBuiltInType'];
+    readonly solveAndApplyConstraints: TypeEvaluator['solveAndApplyConstraints'];
+    readonly getTypeOfExpression: TypeEvaluator['getTypeOfExpression'];
+}
+export declare function createSpecialFormCreation(context: Context): {
+    reportUseOfTypeCheckOnly: (type: Type, node: ExpressionNode) => void;
+    enforceClassTypeVarScope: (node: ExpressionNode, type: TypeVarType) => boolean;
+    adjustTypeArgsForTypeVarTuple: (typeArgs: TypeResultWithNode[], typeParams: TypeVarType[], errorNode: ExpressionNode) => TypeResultWithNode[];
+    validateTypeArg: (argResult: TypeResultWithNode, options?: ValidateTypeArgsOptions) => boolean;
+    createTypeFormType: (classType: ClassType, errorNode: ExpressionNode, typeArgs: TypeResultWithNode[] | undefined) => Type;
+    transformTypeForTypeAlias: (type: Type, errorNode: ExpressionNode, typeAliasPlaceholder: TypeVarType, isPep695TypeVarType: boolean, typeParamNodes?: TypeParameterNode[]) => Type;
+    validateTypeParamDefault: (errorNode: ExpressionNode, typeParam: TypeVarType, otherLiveTypeParams: TypeVarType[], scopeId: TypeVarScopeId) => void;
+    verifyGenericTypeParams: (errorNode: ExpressionNode, typeVars: TypeVarType[], genericTypeVars: TypeVarType[]) => void;
+    transformTypeArgsForParamSpec: (typeParams: TypeVarType[], typeArgs: TypeResultWithNode[] | undefined, errorNode: ExpressionNode) => TypeResultWithNode[] | undefined;
+    createSpecializedClassType: (classType: ClassType, typeArgs: TypeResultWithNode[] | undefined, flags: EvalFlags, errorNode: ExpressionNode) => TypeResult;
+    createSelfType: (classType: ClassType, errorNode: ParseNode, typeArgs: TypeResultWithNode[] | undefined, flags: EvalFlags) => UnknownType | TypeVarType;
+    createLiteralType: (classType: ClassType, node: IndexNode, flags: EvalFlags) => Type;
+};
+export {};