@zzzen/pyright-internal 1.2.0-dev.20230827 → 1.2.0-dev.20230910

package/dist/analyzer/typeUtils.js

@@ -33,12 +33,15 @@ var ClassMemberLookupFlags;
     // By default, both class and instance variables are searched.
     // If this flag is set, the instance variables are skipped.
     ClassMemberLookupFlags[ClassMemberLookupFlags["SkipInstanceVariables"] = 8] = "SkipInstanceVariables";
+    // By default, both class and instance variables are searched.
+    // If this flag is set, the class variables are skipped.
+    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipClassVariables"] = 16] = "SkipClassVariables";
     // By default, the first symbol is returned even if it has only
     // an inferred type associated with it. If this flag is set,
     // the search looks only for symbols with declared types.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["DeclaredTypesOnly"] = 16] = "DeclaredTypesOnly";
+    ClassMemberLookupFlags[ClassMemberLookupFlags["DeclaredTypesOnly"] = 32] = "DeclaredTypesOnly";
     // Skip the 'type' base class in particular.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipTypeBaseClass"] = 32] = "SkipTypeBaseClass";
+    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipTypeBaseClass"] = 64] = "SkipTypeBaseClass";
 })(ClassMemberLookupFlags = exports.ClassMemberLookupFlags || (exports.ClassMemberLookupFlags = {}));
 var ClassIteratorFlags;
 (function (ClassIteratorFlags) {
@@ -100,6 +103,10 @@ var AssignTypeFlags;
     // default type arguments (typically "Unknown"). This flag skips
     // this step.
     AssignTypeFlags[AssignTypeFlags["AllowUnspecifiedTypeArguments"] = 2048] = "AllowUnspecifiedTypeArguments";
+    // PEP 544 says that if the dest type is a type[Proto] class,
+    // the source must be a "concrete" (non-protocol) class. This
+    // flag skips this check.
+    AssignTypeFlags[AssignTypeFlags["IgnoreProtocolAssignmentCheck"] = 4096] = "IgnoreProtocolAssignmentCheck";
 })(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
@@ -198,14 +205,15 @@ exports.makeInferenceContext = makeInferenceContext;
 // Calls a callback for each subtype and combines the results
 // into a final type. It performs no memory allocations if the
 // transformed type is the same as the original.
-function mapSubtypes(type, callback) {
+function mapSubtypes(type, callback, sortSubtypes = false) {
     if ((0, types_1.isUnion)(type)) {
-        for (let i = 0; i < type.subtypes.length; i++) {
-            const subtype = type.subtypes[i];
+        const subtypes = sortSubtypes ? sortTypes(type.subtypes) : type.subtypes;
+        for (let i = 0; i < subtypes.length; i++) {
+            const subtype = subtypes[i];
             const transformedType = callback(subtype);
             // Avoid doing any memory allocations until a change is detected.
             if (subtype !== transformedType) {
-                const typesToCombine = type.subtypes.slice(0, i);
+                const typesToCombine = subtypes.slice(0, i);
                 // Create a helper lambda that accumulates transformed subtypes.
                 const accumulateSubtype = (newSubtype) => {
                     if (newSubtype) {
@@ -213,8 +221,8 @@ function mapSubtypes(type, callback) {
                     }
                 };
                 accumulateSubtype(transformedType);
-                for (i++; i < type.subtypes.length; i++) {
-                    accumulateSubtype(callback(type.subtypes[i]));
+                for (i++; i < subtypes.length; i++) {
+                    accumulateSubtype(callback(subtypes[i]));
                 }
                 const newType = (0, types_1.combineTypes)(typesToCombine);
                 // Do our best to retain type aliases.
@@ -240,8 +248,12 @@ function sortTypes(types) {
     });
 }
 exports.sortTypes = sortTypes;
-function compareTypes(a, b) {
+function compareTypes(a, b, recursionCount = 0) {
     var _a, _b;
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return 0;
+    }
+    recursionCount++;
     if (a.category !== b.category) {
         return b.category - a.category;
     }
@@ -331,7 +343,29 @@ function compareTypes(a, b) {
             // Sort by class name.
             const aName = a.details.name;
             const bName = b.details.name;
-            return aName < bName ? -1 : aName === bName ? 0 : 1;
+            if (aName < bName) {
+                return -1;
+            }
+            else if (aName > bName) {
+                return 1;
+            }
+            // Sort by type argument count.
+            const aTypeArgCount = a.typeArguments ? a.typeArguments.length : 0;
+            const bTypeArgCount = bClass.typeArguments ? bClass.typeArguments.length : 0;
+            if (aTypeArgCount < bTypeArgCount) {
+                return -1;
+            }
+            else if (aTypeArgCount > bTypeArgCount) {
+                return 1;
+            }
+            // Sort by type argument.
+            for (let i = 0; i < aTypeArgCount; i++) {
+                const typeComparison = compareTypes(a.typeArguments[i], bClass.typeArguments[i], recursionCount);
+                if (typeComparison !== 0) {
+                    return typeComparison;
+                }
+            }
+            return 0;
         }
         case 8 /* Module */: {
             const aName = a.moduleName;
@@ -991,7 +1025,7 @@ exports.lookUpClassMember = lookUpClassMember;
 // If skipMroClass is defined, all MRO classes up to and including that class
 // are skipped.
 function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */, skipMroClass) {
-    const declaredTypesOnly = (flags & 16 /* DeclaredTypesOnly */) !== 0;
+    const declaredTypesOnly = (flags & 32 /* DeclaredTypesOnly */) !== 0;
     let skippedUndeclaredType = false;
     if ((0, types_1.isClass)(classType)) {
         let classFlags = 0 /* Default */;
@@ -1006,7 +1040,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
         if (flags & 4 /* SkipObjectBaseClass */) {
             classFlags = classFlags | 2 /* SkipObjectBaseClass */;
         }
-        if (flags & 32 /* SkipTypeBaseClass */) {
+        if (flags & 64 /* SkipTypeBaseClass */) {
             classFlags = classFlags | 4 /* SkipTypeBaseClass */;
         }
         const classItr = getClassIterator(classType, classFlags, skipMroClass);
@@ -1055,39 +1089,41 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
                 }
             }
             // Next look at class members.
-            const symbol = memberFields.get(memberName);
-            if (symbol && symbol.isClassMember()) {
-                const hasDeclaredType = symbol.hasTypedDeclarations();
-                if (!declaredTypesOnly || hasDeclaredType) {
-                    let isInstanceMember = symbol.isInstanceMember();
-                    let isClassMember = true;
-                    // For data classes and typed dicts, variables that are declared
-                    // within the class are treated as instance variables. This distinction
-                    // is important in cases where a variable is a callable type because
-                    // we don't want to bind it to the instance like we would for a
-                    // class member.
-                    const isDataclass = types_1.ClassType.isDataClass(specializedMroClass);
-                    const isTypedDict = types_1.ClassType.isTypedDictClass(specializedMroClass);
-                    if (hasDeclaredType && (isDataclass || isTypedDict)) {
-                        const decls = symbol.getDeclarations();
-                        if (decls.length > 0 && decls[0].type === 1 /* Variable */) {
-                            isInstanceMember = true;
-                            isClassMember = isDataclass;
+            if ((flags & 16 /* SkipClassVariables */) === 0) {
+                const symbol = memberFields.get(memberName);
+                if (symbol && symbol.isClassMember()) {
+                    const hasDeclaredType = symbol.hasTypedDeclarations();
+                    if (!declaredTypesOnly || hasDeclaredType) {
+                        let isInstanceMember = symbol.isInstanceMember();
+                        let isClassMember = true;
+                        // For data classes and typed dicts, variables that are declared
+                        // within the class are treated as instance variables. This distinction
+                        // is important in cases where a variable is a callable type because
+                        // we don't want to bind it to the instance like we would for a
+                        // class member.
+                        const isDataclass = types_1.ClassType.isDataClass(specializedMroClass);
+                        const isTypedDict = types_1.ClassType.isTypedDictClass(specializedMroClass);
+                        if (hasDeclaredType && (isDataclass || isTypedDict)) {
+                            const decls = symbol.getDeclarations();
+                            if (decls.length > 0 && decls[0].type === 1 /* Variable */) {
+                                isInstanceMember = true;
+                                isClassMember = isDataclass;
+                            }
                         }
+                        const cm = {
+                            symbol,
+                            isInstanceMember,
+                            isClassMember,
+                            isClassVar: symbol.isClassVar(),
+                            classType: specializedMroClass,
+                            isTypeDeclared: hasDeclaredType,
+                            skippedUndeclaredType,
+                        };
+                        yield cm;
+                    }
+                    else {
+                        skippedUndeclaredType = true;
                     }
-                    const cm = {
-                        symbol,
-                        isInstanceMember,
-                        isClassMember,
-                        isClassVar: symbol.isClassVar(),
-                        classType: specializedMroClass,
-                        isTypeDeclared: hasDeclaredType,
-                        skippedUndeclaredType,
-                    };
-                    yield cm;
-                }
-                else {
-                    skippedUndeclaredType = true;
                 }
             }
         }
@@ -1335,7 +1371,8 @@ function specializeClassType(type) {
     const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeId(type));
     const typeParams = types_1.ClassType.getTypeParameters(type);
     typeParams.forEach((typeParam) => {
-        typeVarContext.setTypeVarType(typeParam, types_1.UnknownType.create());
+        var _a;
+        typeVarContext.setTypeVarType(typeParam, applySolvedTypeVars((_a = typeParam.details.defaultType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), typeVarContext));
     });
     return applySolvedTypeVars(type, typeVarContext);
 }
@@ -1788,6 +1825,12 @@ function containsAnyOrUnknown(type, recurse) {
         }
         visitFunction(type) {
             if (this._recurse) {
+                // A function with a "..." type is effectively an "Any".
+                if (types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(type)) {
+                    this.anyOrUnknownType = this.anyOrUnknownType
+                        ? preserveUnknown(this.anyOrUnknownType, types_1.AnyType.create())
+                        : types_1.AnyType.create();
+                }
                 super.visitFunction(type);
             }
         }
@@ -2461,11 +2504,10 @@ class TypeVarTransformer {
                 return type;
             }
             let replacementType = type;
-            // Recursively transform the results, but ensure that we don't replace the
-            // same type variable recursively by setting it in the
+            // Recursively transform the results, but ensure that we don't replace any
+            // type variables in the same scope recursively by setting it the scope in the
             // _pendingTypeVarTransformations set.
-            const typeVarName = types_1.TypeVarType.getNameWithScope(type);
-            if (!this._pendingTypeVarTransformations.has(typeVarName)) {
+            if (!this._isTypeVarScopePending(type.scopeId)) {
                 if (type.details.isParamSpec) {
                     if (!type.paramSpecAccess) {
                         const paramSpecValue = this.transformParamSpec(type, recursionCount);
@@ -2477,9 +2519,13 @@ class TypeVarTransformer {
                 else {
                     replacementType = (_b = this.transformTypeVar(type, recursionCount)) !== null && _b !== void 0 ? _b : type;
                     if (!this._isTransformingTypeArg) {
-                        this._pendingTypeVarTransformations.add(typeVarName);
+                        if (type.scopeId) {
+                            this._pendingTypeVarTransformations.add(type.scopeId);
+                        }
                         replacementType = this.apply(replacementType, recursionCount);
-                        this._pendingTypeVarTransformations.delete(typeVarName);
+                        if (type.scopeId) {
+                            this._pendingTypeVarTransformations.delete(type.scopeId);
+                        }
                     }
                     // If we're transforming a variadic type variable that was in a union,
                     // expand the union types.
@@ -2682,8 +2728,7 @@ class TypeVarTransformer {
                         }
                     }
                     else {
-                        const typeParamName = types_1.TypeVarType.getNameWithScope(typeParam);
-                        if (!this._pendingTypeVarTransformations.has(typeParamName)) {
+                        if (!this._isTypeVarScopePending(typeParam.scopeId)) {
                             const transformedType = this.transformTypeVar(typeParam, recursionCount);
                             replacementType = transformedType !== null && transformedType !== void 0 ? transformedType : typeParam;
                             if (replacementType !== typeParam) {
@@ -2857,6 +2902,9 @@ class TypeVarTransformer {
             return newFunctionType;
         });
     }
+    _isTypeVarScopePending(typeVarScopeId) {
+        return !!typeVarScopeId && this._pendingTypeVarTransformations.has(typeVarScopeId);
+    }
 }
 // For a TypeVar with a default type, validates whether the default type is using
 // any other TypeVars that are not currently in scope.
@@ -2947,16 +2995,6 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         // don't transform that type variable.
         if (typeVar.scopeId && this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
             let replacement = signatureContext.getTypeVarType(typeVar, !!this._options.useNarrowBoundOnly);
-            // If the type is unknown, see if there's a known wide bound that we can use.
-            if (replacement &&
-                (0, types_1.isUnknown)(replacement) &&
-                !this._options.useNarrowBoundOnly &&
-                this._options.unknownIfNotFound) {
-                const entry = signatureContext.getTypeVar(typeVar);
-                if (entry === null || entry === void 0 ? void 0 : entry.wideBound) {
-                    replacement = entry === null || entry === void 0 ? void 0 : entry.wideBound;
-                }
-            }
             // If there was no narrow bound but there is a wide bound that
             // contains literals or a TypeVar, we'll use the wide bound even if
             // "useNarrowBoundOnly" is specified.
@@ -2994,7 +3032,10 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                         });
                     }
                 }
-                if ((0, types_1.isTypeVar)(replacement) && typeVar.isVariadicInUnion && !replacement.isVariadicInUnion) {
+                if ((0, types_1.isTypeVar)(replacement) &&
+                    typeVar.isVariadicInUnion &&
+                    replacement.details.isVariadic &&
+                    !replacement.isVariadicInUnion) {
                     return types_1.TypeVarType.cloneForUnpacked(replacement, /* isInUnion */ true);
                 }
                 return replacement;