@zzzen/pyright-internal 1.2.0-dev.20230730 → 1.2.0-dev.20230806

package/dist/analyzer/typeEvaluator.js

@@ -772,6 +772,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
                 typeResult = {
                     type: iteratorTypeResult.type,
+                    typeErrors: iterTypeResult.typeErrors,
                     unpackedType: iterType,
                     isIncomplete: iteratorTypeResult.isIncomplete,
                 };
@@ -2967,10 +2968,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (decl.type === 2 /* Parameter */) {
                             return true;
                         }
-                        // Assume alias declarations are also always safe to narrow.
-                        if (decl.type === 8 /* Alias */) {
-                            return true;
-                        }
                         const declCodeFlowNode = AnalyzerNodeInfo.getFlowNode(decl.node);
                         if (!declCodeFlowNode) {
                             return false;
@@ -3704,7 +3701,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // to leave the Self type generic (not specialized). We'll also
                 // skip this for __new__ methods because they are not bound
                 // to the class but rather assume the type of the cls argument.
-                const selfClass = bindToType || memberName === '__new__' ? undefined : classType;
+                const selfClass = !!bindToType || memberName === '__new__' ? undefined : classType;
                 const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
                 if (typeResult) {
                     type = typeResult.type;
@@ -7487,13 +7484,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
                     const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start);
-                    const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
-                    /* typeArguments */ undefined, 
-                    /* isTypeArgumentExplicit */ false);
-                    effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
-                        unknownIfNotFound: true,
-                    });
+                    if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start)) {
+                        const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
+                        /* typeArguments */ undefined, 
+                        /* isTypeArgumentExplicit */ false);
+                        effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
+                            unknownIfNotFound: true,
+                        });
+                    }
                 }
             }
             else if ((0, types_1.isFunction)(effectiveReturnType)) {
@@ -7708,8 +7706,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             eliminateUnsolvedInUnions = false;
         }
         // We'll leave TypeVars unsolved if the call is a recursive
-        // call to a generic function.
-        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
+        // call to a generic function or if this isn't a callable
+        // return with type parameters that are rescoped from the original
+        // function to the returned callable.
+        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope)) && !type.details.rescopedTypeParameters;
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
@@ -7775,7 +7775,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useStrictTypeGuardSemantics));
             }
         }
-        specializedReturnType = adjustCallableReturnType(specializedReturnType);
+        specializedReturnType = adjustCallableReturnType(specializedReturnType, signatureTracker.getTrackedSignatures());
         if (specializedInitSelfType) {
             specializedInitSelfType = (0, typeUtils_1.applySolvedTypeVars)(specializedInitSelfType, typeVarContext);
         }
@@ -7817,19 +7817,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return [];
     }
-    function adjustCallableReturnType(returnType) {
-        // If the return type includes a generic Callable type, set the type var
-        // scope to a wildcard to allow these type vars to be solved. This won't
-        // work with overloads or unions of callables. It's intended for a
-        // specific use case. We may need to make this more sophisticated in
-        // the future.
+    // If the return type includes a generic Callable type, set the type var
+    // scope to a wildcard to allow these type vars to be solved. This won't
+    // work with overloads or unions of callables. It's intended for a
+    // specific use case. We may need to make this more sophisticated in
+    // the future.
+    // The trackedSignatures parameter supplies a list of function signatures
+    // that were used for the function and the arguments passed to it. This is
+    // important because the callable return value may be called again with
+    // one of these signatures, so we may need to "uniquify" the type parameters
+    // to avoid conflicts.
+    function adjustCallableReturnType(returnType, trackedSignatures) {
         if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
             const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
             // If there are no unsolved type variables, we're done. If there are
             // unsolved type parameters, treat them as though they are rescoped
             // to the callable.
             if (typeVarsInReturnType.length > 0) {
-                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId, typeVarsInReturnType);
+                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId, typeVarsInReturnType, trackedSignatures);
             }
         }
         return returnType;
@@ -8807,7 +8812,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
                 magicMethodType = (_a = getTypeOfObjectMember(errorNode, concreteSubtype, magicMethodName, 
                 /* usage */ undefined, 
-                /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */, subtype)) === null || _a === void 0 ? void 0 : _a.type;
+                /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === null || _a === void 0 ? void 0 : _a.type;
             }
             else if ((0, types_1.isInstantiableClass)(concreteSubtype)) {
                 magicMethodType = (_b = getTypeOfClassMember(errorNode, concreteSubtype, magicMethodName, 
@@ -12147,7 +12152,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, typeVarsInReturnType);
         // Note that the type parameters have been rescoped so they are not
         // considered valid for the body of this function.
-        functionType.details.rescopedTypeParameters = rescopedTypeVars;
+        if (rescopedTypeVars.length > 0) {
+            functionType.details.rescopedTypeParameters = rescopedTypeVars;
+        }
     }
     function adjustParameterAnnotatedType(param, type) {
         var _a;
@@ -12292,16 +12299,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function createAsyncFunction(node, functionType) {
+        (0, debug_1.assert)(types_1.FunctionType.isAsync(functionType));
         // Clone the original function and replace its return type with an
-        // Awaitable[<returnType>].
-        const awaitableFunctionType = types_1.FunctionType.clone(functionType);
+        // Awaitable[<returnType>]. Mark the new function as no longer async.
+        const awaitableFunctionType = types_1.FunctionType.cloneWithNewFlags(functionType, functionType.details.flags & ~512 /* Async */);
         if (functionType.details.declaredReturnType) {
             awaitableFunctionType.details.declaredReturnType = createAwaitableReturnType(node, functionType.details.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
-        // Note that the inferred type, once lazily computed, needs to wrap the
-        // resulting type in an awaitable.
-        functionType.details.flags |= 1024 /* WrapReturnTypeInAwait */;
-        awaitableFunctionType.details.flags |= 1024 /* WrapReturnTypeInAwait */;
+        else {
+            awaitableFunctionType.inferredReturnType = createAwaitableReturnType(node, getFunctionInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
+        }
         return awaitableFunctionType;
     }
     function createAwaitableReturnType(node, returnType, isGenerator) {
@@ -14957,7 +14964,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getFunctionEffectiveReturnType(type, args, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type);
         if (specializedReturnType) {
-            return adjustCallableReturnType(specializedReturnType);
+            return adjustCallableReturnType(specializedReturnType, /* trackedSignatures */ undefined);
         }
         if (inferTypeIfNeeded) {
             return getFunctionInferredReturnType(type, args);
@@ -14965,7 +14972,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return types_1.UnknownType.create();
     }
     function getFunctionInferredReturnType(type, args) {
-        var _a;
         let returnType;
         let isIncomplete = false;
         let analyzeUnannotatedFunctions = true;
@@ -15012,10 +15018,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (returnTypeResult === null || returnTypeResult === void 0 ? void 0 : returnTypeResult.isIncomplete) {
                             isIncomplete = true;
                         }
-                        // Do we need to wrap this in an awaitable?
-                        if (returnType && types_1.FunctionType.isWrapReturnTypeInAwait(type)) {
-                            returnType = createAwaitableReturnType(functionNode, returnType, !!((_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.isGenerator));
-                        }
                     }
                 }
             }
@@ -15036,7 +15038,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.hasUnannotatedParams(type) &&
             !types_1.FunctionType.isStubDefinition(type) &&
             !types_1.FunctionType.isPyTypedDefinition(type) &&
-            !types_1.FunctionType.isWrapReturnTypeInAwait(type) &&
             args) {
             const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
             if (contextualReturnType) {
@@ -15046,7 +15047,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return returnType;
     }
     function getFunctionInferredReturnTypeUsingArguments(type, args) {
-        var _a;
         let contextualReturnType;
         if (!type.details.declaration) {
             return undefined;
@@ -15158,10 +15158,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         if (contextualReturnType) {
             contextualReturnType = (0, types_1.removeUnbound)(contextualReturnType);
-            // Do we need to wrap this in an awaitable?
-            if (types_1.FunctionType.isWrapReturnTypeInAwait(type) && !(0, types_1.isNever)(contextualReturnType)) {
-                contextualReturnType = createAwaitableReturnType(functionNode, contextualReturnType, !!((_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.isGenerator));
-            }
             if (!isResultFromCache) {
                 // Cache the resulting type.
                 if (!functionType.functionType.callSiteReturnTypeCache) {
@@ -17312,7 +17308,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* exemptSelfClsParam */ false);
             });
             if (matchIndex < 0) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex }));
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex + 1 }));
                 return false;
             }
             if (matchIndex < previousMatchIndex) {
@@ -17471,7 +17467,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
-                    if (!baseParam.isNameSynthesized) {
+                    if (!baseParam.isNameSynthesized &&
+                        baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                             index: i + 1,
                             baseName: baseParam.name || '*',