@zzzen/pyright-internal 1.2.0-dev.20230604 → 1.2.0-dev.20230611

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -236,6 +236,7 @@ export interface TypeEvaluator {
     verifyRaiseExceptionType: (node: RaiseNode) => void;
     verifyDeleteExpression: (node: ExpressionNode) => void;
     validateOverloadedFunctionArguments: (errorNode: ExpressionNode, argList: FunctionArgument[], typeResult: TypeResult<OverloadedFunctionType>, typeVarContext: TypeVarContext | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
+    validateInitSubclassArgs: (node: ClassNode, classType: ClassType) => void;
     isAfterNodeReachable: (node: ParseNode) => boolean;
     isNodeReachable: (node: ParseNode, sourceNode?: ParseNode | undefined) => boolean;
     isAsymmetricDescriptorAssignment: (node: ParseNode) => boolean;
@@ -285,6 +286,7 @@ export interface TypeEvaluator {
     inferReturnTypeIfNecessary: (type: Type) => void;
     inferTypeParameterVarianceForClass: (type: ClassType) => void;
     verifyTypeArgumentsAssignable: (destType: ClassType, srcType: ClassType, diag: DiagnosticAddendum | undefined, destTypeVarContext: TypeVarContext | undefined, srcTypeVarContext: TypeVarContext | undefined, flags: AssignTypeFlags, recursionCount: number) => boolean;
+    reportMissingTypeArguments: (node: ExpressionNode, type: Type, flags: EvaluatorFlags) => Type;
     isFinalVariable: (symbol: Symbol) => boolean;
     isFinalVariableDeclaration: (decl: Declaration) => boolean;
     isExplicitTypeAliasDeclaration: (decl: Declaration) => boolean;

package/dist/analyzer/typeUtils.d.ts

@@ -52,23 +52,24 @@ export interface ApplyTypeVarOptions {
 export interface InferenceContext {
     expectedType: Type;
     isTypeIncomplete?: boolean;
+    signatureTracker?: UniqueSignatureTracker;
 }
-export interface SignatureWithCount {
+export interface SignatureWithOffsets {
     type: FunctionType;
-    count: number;
+    expressionOffsets: number[];
 }
 export declare class UniqueSignatureTracker {
-    signaturesSeen: SignatureWithCount[];
+    private _signaturesSeen;
     constructor();
-    findSignature(signature: FunctionType): SignatureWithCount | undefined;
-    addSignature(signature: FunctionType): void;
+    findSignature(signature: FunctionType): SignatureWithOffsets | undefined;
+    addSignature(signature: FunctionType, offset: number): void;
 }
 export declare function isOptionalType(type: Type): boolean;
 export declare function isIncompleteUnknown(type: Type): boolean;
 export declare function isTypeVarSame(type1: TypeVarType, type2: Type): boolean;
-export declare function makeInferenceContext(expectedType: undefined, isTypeIncomplete?: boolean): undefined;
-export declare function makeInferenceContext(expectedType: Type, isTypeIncomplete?: boolean): InferenceContext;
-export declare function makeInferenceContext(expectedType: Type | undefined, isTypeIncomplete?: boolean): InferenceContext | undefined;
+export declare function makeInferenceContext(expectedType: undefined, isTypeIncomplete?: boolean, signatureTracker?: UniqueSignatureTracker): undefined;
+export declare function makeInferenceContext(expectedType: Type, isTypeIncomplete?: boolean, signatureTracker?: UniqueSignatureTracker): InferenceContext;
+export declare function makeInferenceContext(expectedType: Type | undefined, isTypeIncomplete?: boolean, signatureTracker?: UniqueSignatureTracker): InferenceContext | undefined;
 export declare function mapSubtypes(type: Type, callback: (type: Type) => Type | undefined): Type;
 export declare function sortTypes(types: Type[]): Type[];
 export declare function doForEachSubtype(type: Type, callback: (type: Type, index: number, allSubtypes: Type[]) => void, sortSubtypes?: boolean): void;
@@ -100,7 +101,7 @@ export declare function isTupleClass(type: ClassType): boolean;
 export declare function isUnboundedTupleClass(type: ClassType): boolean | undefined;
 export declare function partiallySpecializeType(type: Type, contextClassType: ClassType, selfClass?: ClassType, typeClassType?: Type): Type;
 export declare function populateTypeVarContextForSelfType(typeVarContext: TypeVarContext, contextClassType: ClassType, selfClass: ClassType): void;
-export declare function ensureFunctionSignaturesAreUnique(type: Type, signatureTracker: UniqueSignatureTracker): Type;
+export declare function ensureFunctionSignaturesAreUnique(type: Type, signatureTracker: UniqueSignatureTracker, expressionOffset: number): Type;
 export declare function applySolvedTypeVars(type: Type, typeVarContext: TypeVarContext, options?: ApplyTypeVarOptions): Type;
 export declare function applySourceContextTypeVars(destContext: TypeVarContext, srcContext: TypeVarContext): void;
 export declare function applySourceContextTypeVarsToSignature(destSignature: TypeVarSignatureContext, srcContext: TypeVarContext): void;
@@ -135,11 +136,10 @@ export declare function convertToInstantiable(type: Type): Type;
 export declare function getMembersForClass(classType: ClassType, symbolTable: SymbolTable, includeInstanceVars: boolean): void;
 export declare function getMembersForModule(moduleType: ModuleType, symbolTable: SymbolTable): void;
 export declare function containsAnyOrUnknown(type: Type, recurse: boolean): AnyType | UnknownType | undefined;
-export declare function isPartlyUnknown(type: Type, allowUnknownTypeArgsForClasses?: boolean): boolean;
+export declare function isPartlyUnknown(type: Type, allowUnknownTypeArgsForClasses?: boolean, recursionCount?: number): boolean;
 export declare function explodeGenericClass(classType: ClassType): Type;
 export declare function combineSameSizedTuples(type: Type, tupleType: Type | undefined): Type;
 export declare function specializeTupleClass(classType: ClassType, typeArgs: TupleTypeArgument[], isTypeArgumentExplicit?: boolean, isUnpackedTuple?: boolean): ClassType;
-export declare function getCommonErasedType(types: Type[]): ClassType | undefined;
 export declare function removeParamSpecVariadicsFromSignature(type: FunctionType | OverloadedFunctionType): FunctionType | OverloadedFunctionType;
 export declare function removeParamSpecVariadicsFromFunction(type: FunctionType): FunctionType;
 export declare function getGeneratorTypeArgs(returnType: Type): Type[] | undefined;

package/dist/analyzer/typeUtils.js

@@ -9,7 +9,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSubtype = exports.sortTypes = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
-exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.getCommonErasedType = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = void 0;
+exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const symbol_1 = require("./symbol");
@@ -100,22 +100,30 @@ var AssignTypeFlags;
     // employing narrowing or widening, and don't strip literals.
     AssignTypeFlags[AssignTypeFlags["PopulatingExpectedType"] = 1024] = "PopulatingExpectedType";
 })(AssignTypeFlags = exports.AssignTypeFlags || (exports.AssignTypeFlags = {}));
+// Tracks whether a function signature has been seen before within
+// an expression. For example, in the expression "foo(foo, foo)", the
+// signature for "foo" will be seen three times at three different
+// file offsets. If the signature is generic, we need to create unique
+// type variables for each instance because they are independent of
+// each other.
 class UniqueSignatureTracker {
     constructor() {
-        this.signaturesSeen = [];
+        this._signaturesSeen = [];
     }
     findSignature(signature) {
-        return this.signaturesSeen.find((s) => {
+        return this._signaturesSeen.find((s) => {
             return (0, types_1.isTypeSame)(signature, s.type);
         });
     }
-    addSignature(signature) {
+    addSignature(signature, offset) {
         const existingSignature = this.findSignature(signature);
         if (existingSignature) {
-            existingSignature.count++;
+            if (!existingSignature.expressionOffsets.some((o) => o === offset)) {
+                existingSignature.expressionOffsets.push(offset);
+            }
         }
         else {
-            this.signaturesSeen.push({ type: signature, count: 1 });
+            this._signaturesSeen.push({ type: signature, expressionOffsets: [offset] });
         }
     }
 }
@@ -161,11 +169,11 @@ function isTypeVarSame(type1, type2) {
     return isCompatible;
 }
 exports.isTypeVarSame = isTypeVarSame;
-function makeInferenceContext(expectedType, isTypeIncomplete) {
+function makeInferenceContext(expectedType, isTypeIncomplete, signatureTracker) {
     if (!expectedType) {
         return undefined;
     }
-    return { expectedType, isTypeIncomplete };
+    return { expectedType, isTypeIncomplete, signatureTracker };
 }
 exports.makeInferenceContext = makeInferenceContext;
 // Calls a callback for each subtype and combines the results
@@ -726,8 +734,8 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
 exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
 // Looks for duplicate function types within the type and ensures that
 // if they are generic, they have unique type variables.
-function ensureFunctionSignaturesAreUnique(type, signatureTracker) {
-    const transformer = new UniqueFunctionSignatureTransformer(signatureTracker);
+function ensureFunctionSignaturesAreUnique(type, signatureTracker, expressionOffset) {
+    const transformer = new UniqueFunctionSignatureTransformer(signatureTracker, expressionOffset);
     return transformer.apply(type, 0);
 }
 exports.ensureFunctionSignaturesAreUnique = ensureFunctionSignaturesAreUnique;
@@ -1692,27 +1700,71 @@ function containsAnyOrUnknown(type, recurse) {
 }
 exports.containsAnyOrUnknown = containsAnyOrUnknown;
 // Determines if any part of the type contains "Unknown", including any type arguments.
-function isPartlyUnknown(type, allowUnknownTypeArgsForClasses = false) {
-    class PartlyUnknownWalker extends typeWalker_1.TypeWalker {
-        constructor(_allowUnknownTypeArgsForClasses) {
-            super();
-            this._allowUnknownTypeArgsForClasses = _allowUnknownTypeArgsForClasses;
-            this.isPartlyUnknown = false;
+// This function does not use the TypeWalker because it is called very frequently,
+// and allocating a memory walker object for every call significantly increases
+// peak memory usage.
+function isPartlyUnknown(type, allowUnknownTypeArgsForClasses = false, recursionCount = 0) {
+    var _a, _b;
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return false;
+    }
+    recursionCount++;
+    if ((0, types_1.isUnknown)(type)) {
+        return true;
+    }
+    // If this is a generic type alias, see if any of its type arguments
+    // are either unspecified or are partially known.
+    if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) {
+        if (type.typeAliasInfo.typeArguments.some((typeArg) => isPartlyUnknown(typeArg, allowUnknownTypeArgsForClasses, recursionCount))) {
+            return true;
         }
-        visitUnknown(type) {
-            this.isPartlyUnknown = true;
-            // No need to keep walking.
-            this.cancelWalk();
+    }
+    // See if a union contains an unknown type.
+    if ((0, types_1.isUnion)(type)) {
+        return ((0, types_1.findSubtype)(type, (subtype) => isPartlyUnknown(subtype, allowUnknownTypeArgsForClasses, recursionCount)) !==
+            undefined);
+    }
+    // See if an object or class has an unknown type argument.
+    if ((0, types_1.isClass)(type)) {
+        if (types_1.TypeBase.isInstance(type)) {
+            allowUnknownTypeArgsForClasses = false;
+        }
+        if (!allowUnknownTypeArgsForClasses && !types_1.ClassType.isPseudoGenericClass(type)) {
+            const typeArgs = ((_b = type.tupleTypeArguments) === null || _b === void 0 ? void 0 : _b.map((t) => t.type)) || type.typeArguments;
+            if (typeArgs) {
+                for (const argType of typeArgs) {
+                    if (isPartlyUnknown(argType, allowUnknownTypeArgsForClasses, recursionCount)) {
+                        return true;
+                    }
+                }
+            }
         }
-        visitClass(type) {
-            if (!this._allowUnknownTypeArgsForClasses || !types_1.TypeBase.isInstantiable(type)) {
-                super.visitClass(type);
+        return false;
+    }
+    // See if a function has an unknown type.
+    if ((0, types_1.isOverloadedFunction)(type)) {
+        return types_1.OverloadedFunctionType.getOverloads(type).some((overload) => {
+            return isPartlyUnknown(overload, /* allowUnknownTypeArgsForClasses */ false, recursionCount);
+        });
+    }
+    if ((0, types_1.isFunction)(type)) {
+        for (let i = 0; i < type.details.parameters.length; i++) {
+            // Ignore parameters such as "*" that have no name.
+            if (type.details.parameters[i].name) {
+                const paramType = types_1.FunctionType.getEffectiveParameterType(type, i);
+                if (isPartlyUnknown(paramType, /* allowUnknownTypeArgsForClasses */ false, recursionCount)) {
+                    return true;
+                }
             }
         }
+        if (type.details.declaredReturnType &&
+            !types_1.FunctionType.isParamSpecValue(type) &&
+            isPartlyUnknown(type.details.declaredReturnType, /* allowUnknownTypeArgsForClasses */ false, recursionCount)) {
+            return true;
+        }
+        return false;
     }
-    const walker = new PartlyUnknownWalker(allowUnknownTypeArgsForClasses);
-    walker.walk(type);
-    return walker.isPartlyUnknown;
+    return false;
 }
 exports.isPartlyUnknown = isPartlyUnknown;
 // If the specified type is a generic class with a single type argument
@@ -1800,31 +1852,6 @@ function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true
     return clonedClassType;
 }
 exports.specializeTupleClass = specializeTupleClass;
-// If the array contains two or more class types that are all the same
-// generic type, return the common "erased" type — a type that
-// replaces all of the type arguments with Unknown.
-function getCommonErasedType(types) {
-    if (types.length < 2) {
-        return undefined;
-    }
-    if (!(0, types_1.isClass)(types[0])) {
-        return undefined;
-    }
-    for (let i = 1; i < types.length; i++) {
-        const candidate = types[i];
-        if (!(0, types_1.isClass)(candidate) ||
-            types_1.TypeBase.isInstance(candidate) !== types_1.TypeBase.isInstance(types[0]) ||
-            !types_1.ClassType.isSameGenericClass(types[0], candidate)) {
-            return undefined;
-        }
-    }
-    if (isTupleClass(types[0])) {
-        return specializeTupleClass(types[0], [{ type: types_1.UnknownType.create(), isUnbounded: true }]);
-    }
-    return types_1.ClassType.cloneForSpecialization(types[0], types[0].details.typeParameters.map((t) => types_1.UnknownType.create()), 
-    /* isTypeArgumentExplicit */ true);
-}
-exports.getCommonErasedType = getCommonErasedType;
 // If the type is a function or overloaded function that has a paramSpec
 // associated with it and P.args and P.kwargs at the end of the signature,
 // it removes these parameters from the function.
@@ -2758,9 +2785,18 @@ class TypeVarDefaultValidator extends TypeVarTransformer {
     }
 }
 class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
-    constructor(_signatureTracker) {
+    constructor(_signatureTracker, _expressionOffset) {
         super();
         this._signatureTracker = _signatureTracker;
+        this._expressionOffset = _expressionOffset;
+    }
+    transformGenericTypeAlias(type, recursionCount) {
+        // Don't transform type aliases.
+        return type;
+    }
+    transformTypeVarsInClassType(classType, recursionCount) {
+        // Don't transform classes.
+        return classType;
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
         // If this function is not generic, there's no need to check for uniqueness.
@@ -2771,19 +2807,25 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
         const existingSignature = this._signatureTracker.findSignature(sourceType);
         if (existingSignature) {
             const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeId(sourceType));
-            // Create new type variables with the same scope but with
-            // different (unique) names.
-            sourceType.details.typeParameters.forEach((typeParam) => {
-                let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.details.name}(${existingSignature.count})`);
-                if (replacement.details.isParamSpec) {
-                    replacement = convertTypeToParamSpecValue(replacement);
-                }
-                typeVarContext.setTypeVarType(typeParam, replacement);
-            });
-            updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
-            (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloadedFunction)(updatedSourceType));
+            let offsetIndex = existingSignature.expressionOffsets.findIndex((offset) => offset === this._expressionOffset);
+            if (offsetIndex < 0) {
+                offsetIndex = existingSignature.expressionOffsets.length;
+            }
+            if (offsetIndex > 0) {
+                // Create new type variables with the same scope but with
+                // different (unique) names.
+                sourceType.details.typeParameters.forEach((typeParam) => {
+                    let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.details.name}(${offsetIndex})`);
+                    if (replacement.details.isParamSpec) {
+                        replacement = convertTypeToParamSpecValue(replacement);
+                    }
+                    typeVarContext.setTypeVarType(typeParam, replacement);
+                });
+                updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
+                (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloadedFunction)(updatedSourceType));
+            }
         }
-        this._signatureTracker.addSignature(sourceType);
+        this._signatureTracker.addSignature(sourceType, this._expressionOffset);
         return updatedSourceType;
     }
 }