@zzzen/pyright-internal 1.2.0-dev.20220904 → 1.2.0-dev.20220918

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) {
@@ -8963,8 +8970,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 +9065,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 +9074,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 &&
@@ -10729,29 +10741,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // See if there's already a non-synthesized __init__ method.
             // We shouldn't override it.
             if (!skipSynthesizedInit) {
-                const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 4 /* SkipObjectBaseClass */);
+                const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 2 /* SkipBaseClasses */);
                 if (initSymbol) {
-                    if (!(0, types_1.isClass)(initSymbol.classType) || !types_1.ClassType.isBuiltIn(initSymbol.classType, 'NamedTuple')) {
-                        const initSymbolType = getTypeOfMember(initSymbol);
-                        if ((0, types_1.isFunction)(initSymbolType)) {
-                            if (!types_1.FunctionType.isSynthesizedMethod(initSymbolType)) {
-                                hasExistingInitMethod = true;
-                            }
-                        }
-                        else {
+                    const initSymbolType = getTypeOfMember(initSymbol);
+                    if ((0, types_1.isFunction)(initSymbolType)) {
+                        if (!types_1.FunctionType.isSynthesizedMethod(initSymbolType)) {
                             hasExistingInitMethod = true;
                         }
                     }
+                    else {
+                        hasExistingInitMethod = true;
+                    }
                 }
             }
             let skipSynthesizeHash = false;
-            const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 4 /* SkipObjectBaseClass */);
+            const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* SkipBaseClasses */);
             if (hashSymbol) {
-                if (!(0, types_1.isClass)(hashSymbol.classType) || !types_1.ClassType.isBuiltIn(hashSymbol.classType, 'NamedTuple')) {
-                    const hashSymbolType = getTypeOfMember(hashSymbol);
-                    if ((0, types_1.isFunction)(hashSymbolType) && !types_1.FunctionType.isSynthesizedMethod(hashSymbolType)) {
-                        skipSynthesizeHash = true;
-                    }
+                const hashSymbolType = getTypeOfMember(hashSymbol);
+                if ((0, types_1.isFunction)(hashSymbolType) && !types_1.FunctionType.isSynthesizedMethod(hashSymbolType)) {
+                    skipSynthesizeHash = true;
                 }
             }
             (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
@@ -11001,12 +11009,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.
@@ -12410,7 +12418,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.
@@ -12471,7 +12479,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.
@@ -12582,8 +12592,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;
                 }
@@ -12594,10 +12604,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;
@@ -12615,7 +12625,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;
@@ -13026,8 +13036,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);
@@ -13164,6 +13174,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;
     }
@@ -14115,6 +14131,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;
                 }
             }
@@ -16300,10 +16327,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;
                     }
@@ -16767,6 +16791,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             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(),