@zzzen/pyright-internal 1.2.0-dev.20220911 → 1.2.0-dev.20220925

package/dist/analyzer/typeEvaluator.js

@@ -1255,13 +1255,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // it to the class.
     function getTypeOfClassMember(errorNode, classType, memberName, usage = { method: 'get' }, diag = undefined, memberAccessFlags = 0 /* None */, bindToType) {
         let memberInfo;
+        const classDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
+        const metaclassDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         if (types_1.ClassType.isPartiallyEvaluated(classType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: classType.details.name }), errorNode);
             return { type: types_1.UnknownType.create() };
         }
         if ((memberAccessFlags & 32 /* ConsiderMetaclassOnly */) === 0) {
             memberInfo = getTypeOfClassMemberName(errorNode, classType, 
-            /* isAccessedThroughObject */ false, memberName, usage, diag, memberAccessFlags | 1 /* AccessClassMembersOnly */, bindToType);
+            /* isAccessedThroughObject */ false, memberName, usage, classDiag, memberAccessFlags | 1 /* AccessClassMembersOnly */, bindToType);
         }
         // If this is a protocol class X and we're accessing a non ClassVar,
         // emit an error.
@@ -1278,13 +1280,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }), errorNode);
             }
         }
+        const isMemberPresentOnClass = (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.classType) !== undefined;
         // If it wasn't found on the class, see if it's part of the metaclass.
         if (!memberInfo) {
             const metaclass = classType.details.effectiveMetaclass;
             if (metaclass && (0, types_1.isInstantiableClass)(metaclass) && !types_1.ClassType.isSameGenericClass(metaclass, classType)) {
                 memberInfo = getTypeOfClassMemberName(errorNode, metaclass, 
-                /* isAccessedThroughObject */ true, memberName, usage, 
-                /* diag */ undefined, memberAccessFlags, classType);
+                /* isAccessedThroughObject */ true, memberName, usage, metaclassDiag, memberAccessFlags, classType);
             }
         }
         if (memberInfo) {
@@ -1294,6 +1296,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
             };
         }
+        // Determine whether to use the class or metaclass diagnostic addendum.
+        const subDiag = isMemberPresentOnClass ? classDiag : metaclassDiag;
+        if (diag && subDiag) {
+            diag.addAddendum(subDiag);
+        }
         return undefined;
     }
     function getBoundMethod(classType, memberName, recursionCount = 0, treatConstructorAsClassMember = false) {
@@ -5779,7 +5786,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Validates that the arguments can be assigned to the call's parameter
     // list, specializes the call based on arg types, and returns the
     // specialized type of the return value. If it detects an error along
-    // the way, it emits a diagnostic and returns undefined.
+    // the way, it emits a diagnostic and sets argumentErrors to true.
     function validateCallArguments(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck = false, expectedType, recursionCount = 0) {
         let argumentErrors = false;
         let isTypeIncomplete = false;
@@ -6422,6 +6429,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 paramIndex++;
             }
         }
+        // If there weren't enough positional arguments to populate all of the
+        // positional-only parameters and the next positional-only parameter is
+        // an unbounded tuple, skip past it.
+        let skippedArgsParam = false;
+        if (positionalOnlyLimitIndex >= 0 &&
+            paramIndex < positionalOnlyLimitIndex &&
+            paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+            !(0, types_1.isParamSpec)(paramDetails.params[paramIndex].param.type)) {
+            paramIndex++;
+            skippedArgsParam = true;
+        }
         // Check if there weren't enough positional arguments to populate all of
         // the positional-only parameters.
         if (positionalOnlyLimitIndex >= 0 &&
@@ -6431,7 +6449,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const positionOnlyWithoutDefaultsCount = firstParamWithDefault >= 0 && firstParamWithDefault < positionalOnlyLimitIndex
                 ? firstParamWithDefault
                 : positionalOnlyLimitIndex;
-            const argsRemainingCount = positionOnlyWithoutDefaultsCount - positionalArgCount;
+            // Calculate the number of remaining positional parameters to report.
+            let argsRemainingCount = positionOnlyWithoutDefaultsCount - positionalArgCount;
+            if (skippedArgsParam) {
+                // If we skipped an args parameter above, reduce the count by one
+                // because it's permitted to pass zero arguments to *args.
+                argsRemainingCount--;
+            }
+            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* VarArgList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
+            if (firstArgsParam >= paramIndex && firstArgsParam < positionalOnlyLimitIndex) {
+                // If there is another args parameter beyond the current param index,
+                // reduce the count by one because it's permitted to pass zero arguments
+                // to *args.
+                argsRemainingCount--;
+            }
             if (argsRemainingCount > 0) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, argsRemainingCount === 1
                     ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
@@ -8963,8 +8994,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Remove any expected subtypes that don't satisfy the minimum
             // parameter count requirement.
             expectedFunctionTypes = expectedFunctionTypes.filter((functionType) => {
-                const functionParamCount = functionType.details.parameters.filter((param) => !!param.name && !param.hasDefault).length;
-                const hasVarArgs = functionType.details.parameters.some((param) => !!param.name && param.category !== 0 /* Simple */);
+                const params = types_1.FunctionType.getFunctionParameters(functionType);
+                const functionParamCount = params.filter((param) => !param.hasDefault).length;
+                const hasVarArgs = params.some((param) => param.category !== 0 /* Simple */);
                 return (hasVarArgs ||
                     (functionParamCount >= minLambdaParamCount && functionParamCount <= maxLambdaParamCount));
             });
@@ -9057,14 +9089,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfListComprehension(node, expectedType) {
         let isIncomplete = false;
         let typeErrors = false;
-        const elementTypeResult = getElementTypeFromListComprehension(node);
-        if (elementTypeResult.isIncomplete) {
-            isIncomplete = true;
-        }
-        if (elementTypeResult.typeErrors) {
-            typeErrors = true;
-        }
-        const elementType = elementTypeResult.type;
         let isAsync = node.forIfNodes.some((comp) => {
             return ((comp.nodeType === 33 /* ListComprehensionFor */ && comp.isAsync) ||
                 (comp.nodeType === 34 /* ListComprehensionIf */ &&
@@ -9074,6 +9098,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.expression.nodeType === 6 /* Await */) {
             isAsync = true;
         }
+        let expectedElementType;
+        if (expectedType) {
+            expectedElementType = getTypeOfIterator(expectedType, isAsync, /* errorNode */ undefined);
+        }
+        const elementTypeResult = getElementTypeFromListComprehension(node, expectedElementType);
+        if (elementTypeResult.isIncomplete) {
+            isIncomplete = true;
+        }
+        if (elementTypeResult.typeErrors) {
+            typeErrors = true;
+        }
+        const elementType = elementTypeResult.type;
         // Handle the special case where a generator function (e.g. `(await x for x in y)`)
         // is expected to be an AsyncGenerator.
         if (!isAsync &&
@@ -10386,7 +10422,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             512 /* AllowGenericClassType */ |
             262144 /* DisallowNakedGeneric */ |
             2048 /* DisallowTypeVarsWithScopeId */ |
-            8192 /* AssociateTypeVarsWithCurrentScope */;
+            8192 /* AssociateTypeVarsWithCurrentScope */ |
+            16384 /* EnforceTypeVarVarianceConsistency */;
         if (fileInfo.isStubFile) {
             exprFlags |= 4 /* AllowForwardReferences */;
         }
@@ -10997,12 +11034,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // completed.
     function runClassTypeHooks(type) {
         classTypeHooks.forEach((hook) => {
-            if (hook.dependency === type) {
+            if (types_1.ClassType.isSameGenericClass(hook.dependency, type)) {
                 hook.callback();
             }
         });
         // Remove any hooks that depend on this type.
-        classTypeHooks = classTypeHooks.filter((hook) => hook.dependency !== type);
+        classTypeHooks = classTypeHooks.filter((hook) => !types_1.ClassType.isSameGenericClass(hook.dependency, type));
     }
     // Recomputes the MRO and effective metaclass for the class after dependent
     // classes have been fully constructed.
@@ -11326,9 +11363,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // If there was no annotation for the parameter, infer its type if possible.
             let isTypeInferred = false;
-            if (!paramType) {
+            if (!paramTypeNode) {
                 isTypeInferred = true;
-                paramType = inferParameterType(node, functionType.details.flags, index, containingClassType);
+                const inferredType = inferParameterType(node, functionType.details.flags, index, containingClassType);
+                if (inferredType) {
+                    paramType = inferredType;
+                }
             }
             const functionParam = {
                 category: param.category,
@@ -12406,7 +12446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // expression or statement that contains it. This contextual evaluation
     // allows for bidirectional type evaluation.
     function evaluateTypesForExpressionInContext(node) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         // Check for a couple of special cases where the node is a NameNode but
         // is technically not part of an expression. We'll handle these here so
         // callers don't need to include special-case logic.
@@ -12467,7 +12507,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
                 return;
             }
-            getTypeOfAnnotation(annotationNode);
+            getTypeOfAnnotation(annotationNode, {
+                isVariableAnnotation: ((_a = annotationNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* TypeAnnotation */,
+            });
             return;
         }
         // See if the expression is part of a pattern used in a case statement.
@@ -12578,8 +12620,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If this is the name node within a type parameter list, see if it's a type alias
                 // definition. If so, we need to evaluate the type alias contextually.
                 if (nodeToEvaluate === parent.name &&
-                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 76 /* TypeParameterList */ &&
-                    ((_b = parent.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 77 /* TypeAlias */) {
+                    ((_b = parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 76 /* TypeParameterList */ &&
+                    ((_c = parent.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 77 /* TypeAlias */) {
                     getTypeOfTypeAlias(parent.parent.parent);
                     return;
                 }
@@ -12590,10 +12632,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return;
             }
             case 13 /* Decorator */: {
-                if (((_c = parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+                if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* Class */) {
                     getTypeOfClass(parent.parent);
                 }
-                else if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 28 /* Function */) {
+                else if (((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 28 /* Function */) {
                     getTypeOfFunction(parent.parent);
                 }
                 return;
@@ -12611,7 +12653,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // expression, so there's nothing we can evaluate here.
                     return;
                 }
-                if (((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 10 /* Class */) {
+                if (((_f = parent.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 10 /* Class */) {
                     // A class argument must be evaluated in the context of the class declaration.
                     getTypeOfClass(parent.parent);
                     return;
@@ -13022,8 +13064,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             received: typeArgCount,
                         }), typeArgs[typeParameters.length].node);
                     }
+                    typeArgCount = typeParameters.length;
                 }
-                typeArgCount = typeParameters.length;
             }
             else if (typeArgCount < typeParameters.length) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
@@ -13143,7 +13185,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeArgTypes = typeArgTypes.map((typeArgType, index) => {
             if (index < typeArgCount) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
-                const adjustedTypeArgType = applyTypeArgToTypeVar(typeParameters[index], typeArgType, diag);
+                let adjustedTypeArgType = applyTypeArgToTypeVar(typeParameters[index], typeArgType, diag);
+                // Determine if the variance must match.
+                if (adjustedTypeArgType && (flags & 16384 /* EnforceTypeVarVarianceConsistency */) !== 0) {
+                    const destType = typeParameters[index];
+                    if ((0, types_1.isTypeVar)(adjustedTypeArgType) &&
+                        !adjustedTypeArgType.details.isParamSpec &&
+                        !adjustedTypeArgType.details.isVariadic &&
+                        destType.details.declaredVariance !== 0 /* Auto */ &&
+                        adjustedTypeArgType.details.declaredVariance !== 0 /* Auto */) {
+                        if (adjustedTypeArgType.details.declaredVariance !== 2 /* Invariant */ &&
+                            adjustedTypeArgType.details.declaredVariance !== destType.details.declaredVariance) {
+                            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatch().format({
+                                typeVarName: printType(adjustedTypeArgType),
+                                className: classType.details.name,
+                            }));
+                            adjustedTypeArgType = undefined;
+                        }
+                    }
+                }
                 if (adjustedTypeArgType) {
                     typeArgType = adjustedTypeArgType;
                 }
@@ -13160,6 +13220,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return typeArgType;
         });
+        // If the class is partially constructed and doesn't yet have
+        // type parameters, assume that the number and types of supplied type
+        // arguments are correct.
+        if (typeArgs && classType.details.typeParameters.length === 0 && types_1.ClassType.isPartiallyEvaluated(classType)) {
+            typeArgTypes = typeArgs.map((t) => (0, typeUtils_1.convertToInstance)(t.type));
+        }
         const specializedClass = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
         return specializedClass;
     }
@@ -14111,6 +14177,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
+                    // If this resolves to a class decl, we can use a partially-evaluated
+                    // version of the class type.
+                    const resolvedDecl = resolveAliasDeclaration(decl, 
+                    /* resolveLocalNames */ true, 
+                    /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile);
+                    if ((resolvedDecl === null || resolvedDecl === void 0 ? void 0 : resolvedDecl.type) === 6 /* Class */) {
+                        const classTypeInfo = getTypeOfClass(resolvedDecl.node);
+                        if (classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.decoratedType) {
+                            typesToCombine.push(classTypeInfo.decoratedType);
+                        }
+                    }
                     isIncomplete = true;
                 }
             }
@@ -14542,7 +14619,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 1 /* EnforceInvariance */) === 0 || types_1.ClassType.isSameGenericClass(srcType, destType)) {
             if (isDerivedFrom) {
                 (0, debug_1.assert)(inheritanceChain.length > 0);
-                return assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                if (assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    return true;
+                }
             }
         }
         // Everything is assignable to an object.
@@ -16296,10 +16375,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const effectiveDestType = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? destType : srcType;
             const effectiveSrcType = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? srcType : destType;
             if (effectiveDestType.details.paramSpec) {
-                const requiredMatchParamCount = effectiveDestType.details.parameters.filter((p) => {
-                    if (!p.name) {
-                        return false;
-                    }
+                const requiredMatchParamCount = types_1.FunctionType.getFunctionParameters(effectiveDestType).filter((p) => {
                     if (p.category === 0 /* Simple */ && (0, types_1.isParamSpec)(p.type)) {
                         return false;
                     }
@@ -16748,26 +16824,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Validates that the specified source type matches the constraints
     // of the type variable. If successful, it returns the constraint
     // type that applies. If unsuccessful, it returns undefined.
-    function applyTypeArgToTypeVar(destType, srcType, diag, flags = 0 /* Default */, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return srcType;
-        }
-        recursionCount++;
+    function applyTypeArgToTypeVar(destType, srcType, diag) {
         if ((0, types_1.isAnyOrUnknown)(srcType)) {
             return srcType;
         }
         let effectiveSrcType = srcType;
         if ((0, types_1.isTypeVar)(srcType)) {
-            if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
+            if ((0, types_1.isTypeSame)(srcType, destType)) {
                 return srcType;
             }
             effectiveSrcType = makeTopLevelTypeVarsConcrete(srcType);
         }
+        // If this is a partially-evaluated class, don't perform any further
+        // checks. Assume in this case that the type is compatible with the
+        // bound or constraint.
+        if ((0, types_1.isClass)(effectiveSrcType) && types_1.ClassType.isPartiallyEvaluated(effectiveSrcType)) {
+            return srcType;
+        }
         // If there's a bound type, make sure the source is derived from it.
         if (destType.details.boundType) {
             if (!assignType(destType.details.boundType, effectiveSrcType, diag.createAddendum(), 
             /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+            /* srcTypeVarContext */ undefined)) {
                 // Avoid adding a message that will confuse users if the TypeVar was
                 // synthesized for internal purposes.
                 if (!destType.details.isSynthesized) {
@@ -16808,10 +16886,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeVar)(srcType) && srcType.details.constraints.length > 0) {
             // Make sure all the source constraint types map to constraint types in the dest.
             if (srcType.details.constraints.every((sourceConstraint) => {
-                return constraints.some((destConstraint) => assignType(destConstraint, sourceConstraint, 
-                /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount));
+                return constraints.some((destConstraint) => assignType(destConstraint, sourceConstraint));
             })) {
                 return srcType;
             }
@@ -16820,15 +16895,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let bestConstraintSoFar;
             // Try to find the best (narrowest) match among the constraints.
             for (const constraint of constraints) {
-                if (assignType(constraint, effectiveSrcType, 
-                /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
-                    if (!bestConstraintSoFar ||
-                        assignType(bestConstraintSoFar, constraint, 
-                        /* diag */ undefined, 
-                        /* destTypeVarContext */ undefined, 
-                        /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+                if (assignType(constraint, effectiveSrcType)) {
+                    if (!bestConstraintSoFar || assignType(bestConstraintSoFar, constraint)) {
                         bestConstraintSoFar = constraint;
                     }
                 }