@zzzen/pyright-internal 1.2.0-dev.20230115 → 1.2.0-dev.20230129

package/dist/analyzer/typeEvaluator.js

@@ -205,6 +205,10 @@ const maxOverloadUnionExpansionCount = 64;
 // Maximum number of recursive function return type inference attempts
 // that can be concurrently pending before we give up.
 const maxInferFunctionReturnRecursionCount = 12;
+// In certain loops, it's possible to construct arbitrarily-deep containers
+// (tuples, lists, sets, or dicts) which can lead to infinite type analysis.
+// This limits the depth.
+const maxInferredContainerDepth = 8;
 // Maximum recursion amount when comparing two recursive type aliases.
 // Increasing this can greatly increase the time required to evaluate
 // two recursive type aliases that have the same definition. Decreasing
@@ -1065,6 +1069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return returnType;
     }
     function canBeFalsy(type, recursionCount = 0) {
+        type = makeTopLevelTypeVarsConcrete(type);
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return true;
         }
@@ -1132,6 +1137,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function canBeTruthy(type, recursionCount = 0) {
+        type = makeTopLevelTypeVarsConcrete(type);
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return true;
         }
@@ -1200,16 +1206,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // and return only the "None".
     function removeTruthinessFromType(type) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            if ((0, types_1.isClassInstance)(subtype)) {
-                if (subtype.literalValue !== undefined) {
+            const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
+            if ((0, types_1.isClassInstance)(concreteSubtype)) {
+                if (concreteSubtype.literalValue !== undefined) {
                     // If the object is already definitely falsy, it's fine to
                     // include, otherwise it should be removed.
-                    return !subtype.literalValue ? subtype : undefined;
+                    return !concreteSubtype.literalValue ? subtype : undefined;
                 }
                 // If the object is a bool, make it "false", since
                 // "true" is a truthy value.
-                if (types_1.ClassType.isBuiltIn(subtype, 'bool')) {
-                    return types_1.ClassType.cloneWithLiteral(subtype, /* value */ false);
+                if (types_1.ClassType.isBuiltIn(concreteSubtype, 'bool')) {
+                    return types_1.ClassType.cloneWithLiteral(concreteSubtype, /* value */ false);
                 }
             }
             // If it's possible for the type to be falsy, include it.
@@ -1225,16 +1232,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // and return only the "int".
     function removeFalsinessFromType(type) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            if ((0, types_1.isClassInstance)(subtype)) {
-                if (subtype.literalValue !== undefined) {
+            const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
+            if ((0, types_1.isClassInstance)(concreteSubtype)) {
+                if (concreteSubtype.literalValue !== undefined) {
                     // If the object is already definitely truthy, it's fine to
                     // include, otherwise it should be removed.
-                    return subtype.literalValue ? subtype : undefined;
+                    return concreteSubtype.literalValue ? subtype : undefined;
                 }
                 // If the object is a bool, make it "true", since
                 // "false" is a falsy value.
-                if (types_1.ClassType.isBuiltIn(subtype, 'bool')) {
-                    return types_1.ClassType.cloneWithLiteral(subtype, /* value */ true);
+                if (types_1.ClassType.isBuiltIn(concreteSubtype, 'bool')) {
+                    return types_1.ClassType.cloneWithLiteral(concreteSubtype, /* value */ true);
                 }
             }
             // If it's possible for the type to be truthy, include it.
@@ -4997,6 +5005,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { type: types_1.UnknownType.create() };
         }
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults)));
+        if (isIncomplete) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+                return { type: types_1.UnknownType.create() };
+            }
+        }
         return { type, isIncomplete };
     }
     function buildTupleTypesList(entryTypeResults) {
@@ -5404,12 +5417,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const matchedOverloads = [];
         let isTypeIncomplete = false;
         const overloadsUsedForCall = [];
+        let isDefinitiveMatchFound = false;
         for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
             let matchedOverload;
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
             const hasArgTypeOverride = argTypeOverride.some((a) => a !== undefined);
             const possibleMatchResults = [];
-            let isDefinitiveMatchFound = false;
+            isDefinitiveMatchFound = false;
             for (let overloadIndex = 0; overloadIndex < argParamMatches.length; overloadIndex++) {
                 const overload = argParamMatches[overloadIndex].overload;
                 let matchResults = argParamMatches[overloadIndex];
@@ -5496,7 +5510,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // resulting type var context back into the caller's type var context.
         // Use the type var context from the last matched overload because it
         // includes the type var solutions for all earlier matched overloads.
-        if (typeVarContext) {
+        if (typeVarContext && isDefinitiveMatchFound) {
             typeVarContext.copyFromClone(matchedOverloads[matchedOverloads.length - 1].typeVarContext);
         }
         // And run through the first expanded argument list one more time to
@@ -8275,6 +8289,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const leftExpression = node.leftExpression;
         let rightExpression = node.rightExpression;
         let isIncomplete = false;
+        let typeErrors = false;
         // If this is a comparison and the left expression is also a comparison,
         // we need to change the behavior to accommodate python's "chained
         // comparisons" feature.
@@ -8429,6 +8444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isTupleAddAllowed = !(0, types_1.isUnion)(leftType);
         let type = validateBinaryOperation(node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
         if (!diag.isEmpty() || !type) {
+            typeErrors = true;
             if (!isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 if (isLeftOptionalType && diag.getMessages().length === 1) {
@@ -8450,7 +8466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             type = types_1.UnknownType.create();
         }
-        return { type, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function customMetaclassSupportsMethod(type, methodName) {
         if (!(0, types_1.isInstantiableClass)(type)) {
@@ -9048,6 +9064,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
+        if (isIncomplete) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+                return { type: types_1.UnknownType.create() };
+            }
+        }
         return { type, isIncomplete };
     }
     function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
@@ -9330,6 +9351,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
+        if (isIncomplete) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+                return { type: types_1.UnknownType.create() };
+            }
+        }
         return { type, isIncomplete, typeErrors };
     }
     function verifySetEntryOrDictKeyIsHashable(entry, type, isDictKey) {
@@ -10959,6 +10985,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let protocolTypeParameters;
         const initSubclassArgs = [];
         let metaclassNode;
+        let isMetaclassDeferred = false;
         let exprFlags = 128 /* ExpectingType */ |
             1024 /* AllowGenericClassType */ |
             262144 /* DisallowNakedGeneric */ |
@@ -10990,14 +11017,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argType = types_1.UnknownType.create();
                     }
                     else {
-                        if (types_1.ClassType.isPartiallyEvaluated(argType)) {
+                        if (types_1.ClassType.isPartiallyEvaluated(argType) ||
+                            argType.details.mro.some((t) => (0, types_1.isClass)(t) && types_1.ClassType.isPartiallyEvaluated(t))) {
                             // If the base class is partially evaluated, install a callback
                             // so we can fix up this class (e.g. compute the MRO) when the
                             // dependent class is completed.
                             classTypeHooks.push({
                                 dependency: argType,
-                                callback: () => completeClassTypeDeferred(classType, node.name),
+                                callback: () => completeClassTypeDeferred(classType, node, node.name),
                             });
+                            isMetaclassDeferred = true;
                         }
                         if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
                             if (!fileInfo.isStubFile &&
@@ -11377,6 +11406,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (types_1.ClassType.isBuiltIn(classType, 'UnionType')) {
             unionType = types_1.ClassType.cloneAsInstance(classType);
         }
+        // Validate that arguments passed to `__init_subclass__` are of the correct type.
+        // Defer this if the metaclass calculation is deferred.
+        if (!isMetaclassDeferred) {
+            validateInitSubclassArgs(node, classType);
+        }
         return { classType, decoratedType };
     }
     // Determines whether the type parameters has a default that refers to another
@@ -11517,6 +11551,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveMetaclass = baseClassMeta ? types_1.UnknownType.create() : undefined;
                         break;
                     }
+                    if (types_1.ClassType.isEnumClass(baseClass)) {
+                        classType.details.flags |= 1048576 /* EnumClass */;
+                    }
                 }
                 else {
                     // If one of the base classes is unknown, then the effective
@@ -11647,15 +11684,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Recomputes the MRO and effective metaclass for the class after dependent
     // classes have been fully constructed.
-    function completeClassTypeDeferred(type, errorNode) {
+    function completeClassTypeDeferred(type, node, errorNode) {
         // Recompute the MRO linearization.
         if (!(0, typeUtils_1.computeMroLinearization)(type)) {
             addError(localize_1.Localizer.Diagnostic.methodOrdering(), errorNode);
         }
         // Recompute the effective metaclass.
         computeEffectiveMetaclass(type, errorNode);
+        validateInitSubclassArgs(node, type);
     }
-    function validateInitSubclassArgs(node, classType, argList) {
+    function validateInitSubclassArgs(node, classType) {
+        // Collect arguments that will be passed to the `__init_subclass__`
+        // method described in PEP 487 and validate it.
+        const argList = [];
+        node.arguments.forEach((arg) => {
+            if (arg.name && arg.name.value !== 'metaclass') {
+                argList.push({
+                    argumentCategory: 0 /* Simple */,
+                    node: arg,
+                    name: arg.name,
+                    valueExpression: arg.valueExpression,
+                });
+            }
+        });
         const errorNode = argList.length > 0 ? argList[0].node.name : node.name;
         const initSubclassMethodInfo = getTypeOfClassMemberName(errorNode, classType, 
         /* isAccessedThroughObject */ false, '__init_subclass__', { method: 'get' }, 
@@ -13208,6 +13259,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     nodeToEvaluate = argumentNode.parent;
                     continue;
                 }
+                if (argumentNode.parent.nodeType === 10 /* Class */) {
+                    // If this is an argument node within a class declaration,
+                    // evaluate the full class declaration node.
+                    getTypeOfClass(argumentNode.parent);
+                    return;
+                }
             }
             let parent = nodeToEvaluate.parent;
             if (!parent) {
@@ -14809,6 +14866,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
+        else {
+            // Handle the case where there are multiple imports — one of them in
+            // a try block and one or more in except blocks. In this case, we'll
+            // use the one in the try block rather than the excepts.
+            if (decls.length > 1 && decls.every((decl) => decl.type === 8 /* Alias */)) {
+                const nonExceptDecls = decls.filter((decl) => decl.type === 8 /* Alias */ && !decl.isInExceptSuite);
+                if (nonExceptDecls.length === 1) {
+                    declIndexToConsider = decls.findIndex((decl) => decl === nonExceptDecls[0]);
+                }
+            }
+        }
         let sawExplicitTypeAlias = false;
         decls.forEach((decl, index) => {
             var _a, _b;
@@ -16164,7 +16232,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isOverloadedFunction)(destType)) {
             const overloadDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
             // All overloads in the dest must be assignable.
-            const isAssignable = types_1.OverloadedFunctionType.getOverloads(destType).every((destOverload) => {
+            const destOverloads = types_1.OverloadedFunctionType.getOverloads(destType);
+            // If the source is also an overload with the same number of overloads,
+            // there's a good chance that there's a one-to-one mapping. Try this
+            // first before using an n^2 algorithm.
+            if ((0, types_1.isOverloadedFunction)(srcType)) {
+                const srcOverloads = types_1.OverloadedFunctionType.getOverloads(srcType);
+                if (destOverloads.length === srcOverloads.length) {
+                    if (destOverloads.every((destOverload, index) => {
+                        const srcOverload = srcOverloads[index];
+                        return assignType(destOverload, srcOverload, 
+                        /* diag */ undefined, destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destOverload)), srcTypeVarContext, flags, recursionCount);
+                    })) {
+                        return true;
+                    }
+                }
+            }
+            const isAssignable = destOverloads.every((destOverload) => {
                 if (destTypeVarContext) {
                     destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destOverload));
                 }
@@ -16549,6 +16633,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (constructorFunction.specializedTypes) {
                         constructorFunction.specializedTypes.returnType = objectType;
                     }
+                    if (!constructorFunction.details.docString && classType.details.docString) {
+                        constructorFunction.details.docString = classType.details.docString;
+                    }
                 }
                 return constructorFunction;
             };
@@ -16577,10 +16664,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (newInfo) {
             const newType = getTypeOfMember(newInfo);
             const convertNewToConstructor = (newSubtype) => {
-                return bindFunctionToClassOrObject(classType, newSubtype, 
+                let constructorFunction = bindFunctionToClassOrObject(classType, newSubtype, 
                 /* memberClass */ undefined, 
                 /* errorNode */ undefined, recursionCount, 
                 /* treatConstructorAsClassMember */ true);
+                if (constructorFunction) {
+                    constructorFunction = types_1.FunctionType.clone(constructorFunction);
+                    if (!constructorFunction.details.docString && classType.details.docString) {
+                        constructorFunction.details.docString = classType.details.docString;
+                    }
+                }
+                return constructorFunction;
             };
             if ((0, types_1.isFunction)(newType)) {
                 return convertNewToConstructor(newType);
@@ -16606,6 +16700,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const constructorFunction = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
         constructorFunction.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
         types_1.FunctionType.addDefaultParameters(constructorFunction);
+        if (!constructorFunction.details.docString && classType.details.docString) {
+            constructorFunction.details.docString = classType.details.docString;
+        }
         return constructorFunction;
     }
     // If the class is a protocol and it has a `__call__` method but no other methods
@@ -17772,10 +17869,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     types_1.OverloadedFunctionType.addOverload(newOverloadType, boundMethod);
                 }
             });
-            if (newOverloadType.overloads.length === 1) {
-                return newOverloadType.overloads[0];
-            }
-            else if (newOverloadType.overloads.length === 0) {
+            if (types_1.OverloadedFunctionType.getOverloads(newOverloadType).length === 0) {
                 // No overloads matched, so rebind with the errorNode
                 // to report the error(s) to the user.
                 if (errorNode) {
@@ -17785,6 +17879,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             }
+            else if (newOverloadType.overloads.length === 1) {
+                return newOverloadType.overloads[0];
+            }
             return newOverloadType;
         }
         return memberType;
@@ -17976,7 +18073,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         narrowConstrainedTypeVar,
         assignType,
         validateOverrideMethod,
-        validateInitSubclassArgs,
         assignTypeToExpression,
         assignClassToSelf,
         getTypedDictClassType,