@zzzen/pyright-internal 1.2.0-dev.20240714 → 1.2.0-dev.20240721

package/dist/analyzer/checker.js

@@ -547,7 +547,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let returnTypeResult;
         let returnType;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-        const declaredReturnType = enclosingFunctionNode
+        let declaredReturnType = enclosingFunctionNode
             ? this._evaluator.getFunctionDeclaredReturnType(enclosingFunctionNode)
             : undefined;
         if (node.d.expr) {
@@ -577,10 +577,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnContainsReturn(), node);
                 }
                 else {
+                    const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                    declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
                     if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, 
-                    /* destTypeVarContext */ undefined, 
+                    /* destTypeVarContext */ new typeVarContext_1.TypeVarContext(), 
                     /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
@@ -1851,12 +1853,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.shared.name === '__get__') {
             return false;
         }
-        let flags = 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */;
+        let flags = 64 /* AssignTypeFlags.SkipReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlap */;
         if (partialOverlap) {
-            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */;
+            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
         return this._evaluator.assignType(functionType, prevOverload, 
-        /* diag */ undefined, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType)), 
+        /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
         /* srcTypeVarContext */ undefined, flags);
     }
     _isLegalOverloadImplementation(overload, implementation, diag) {
@@ -1864,7 +1866,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
         const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
             2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
             512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
@@ -3628,15 +3630,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         this._evaluator.validateCallArguments(errorNode, argList, newMemberTypeResult, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
+                        /* inferenceContext */ undefined);
                     }
                     if (initMemberTypeResult) {
                         this._evaluator.validateCallArguments(errorNode, argList, initMemberTypeResult, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
+                        /* inferenceContext */ undefined);
                     }
                 }
             }
@@ -4047,11 +4047,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) ||
+        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
+            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.shared.declaration;
             const newDecl = newMemberType.shared.declaration;
@@ -4208,10 +4208,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         let overriddenType = this._evaluator.getEffectiveTypeOfSymbol(overriddenClassAndSymbol.symbol);
-        overriddenType = (0, typeUtils_1.partiallySpecializeType)(overriddenType, overriddenClassAndSymbol.classType);
+        overriddenType = (0, typeUtils_1.partiallySpecializeType)(overriddenType, overriddenClassAndSymbol.classType, this._evaluator.getTypeClassType());
         const overrideSymbol = overrideClassAndSymbol.symbol;
         let overrideType = this._evaluator.getEffectiveTypeOfSymbol(overrideSymbol);
-        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType, this._evaluator.getTypeClassType());
         const childOverrideSymbol = types_1.ClassType.getSymbolTable(childClassType).get(memberName);
         const childOverrideType = childOverrideSymbol
             ? this._evaluator.getEffectiveTypeOfSymbol(childOverrideSymbol)
@@ -4352,7 +4352,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const subclassPropMethod = methodAccessor(overrideSymbolType);
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
-                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, overriddenClassType);
+                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, overriddenClassType, this._evaluator.getTypeClassType());
                 if ((0, types_1.isFunction)(baseClassMethodType)) {
                     if (!subclassPropMethod) {
                         // The method is missing.
@@ -4373,7 +4373,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     else {
-                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, overrideClassType);
+                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, overrideClassType, this._evaluator.getTypeClassType());
                         if ((0, types_1.isFunction)(subclassMethodType)) {
                             if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, overrideClassType, diagAddendum.createAddendum())) {
                                 diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodIncompatible().format({
@@ -4665,8 +4665,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const baseClass = baseClassAndSymbol.classType;
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType));
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, childClassSelf);
-        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, childClassSelf);
+        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, this._evaluator.getTypeClassType(), childClassSelf);
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             // Determine whether this is an attempt to override a method marked @final.
@@ -4912,7 +4912,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const subclassPropMethod = methodAccessor(childType);
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
-                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType);
+                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType, this._evaluator.getTypeClassType());
                 if ((0, types_1.isFunction)(baseClassMethodType)) {
                     if (!subclassPropMethod) {
                         // The method is missing.
@@ -4933,7 +4933,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     else {
-                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType);
+                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType, this._evaluator.getTypeClassType());
                         if ((0, types_1.isFunction)(subclassMethodType)) {
                             if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
                                 diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodIncompatible().format({
@@ -5193,10 +5193,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!functionTypeResult) {
             return;
         }
-        const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
+        let declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
         if (!declaredReturnType) {
             return;
         }
+        const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
         let generatorType;
         if (!enclosingFunctionNode.d.isAsync &&
             (0, types_1.isClassInstance)(declaredReturnType) &&