@zzzen/pyright-internal 1.2.0-dev.20230101 → 1.2.0-dev.20230108

package/dist/analyzer/checker.js

@@ -531,17 +531,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitReturn(node) {
-        let returnType;
+        var _a, _b;
+        let returnTypeResult;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         const declaredReturnType = enclosingFunctionNode
             ? this._evaluator.getFunctionDeclaredReturnType(enclosingFunctionNode)
             : undefined;
         if (node.returnExpression) {
-            returnType = this._evaluator.getType(node.returnExpression) || types_1.UnknownType.create();
+            returnTypeResult = (_a = this._evaluator.getTypeResult(node.returnExpression)) !== null && _a !== void 0 ? _a : { type: types_1.UnknownType.create() };
         }
         else {
             // There is no return expression, so "None" is assumed.
-            returnType = types_1.NoneType.createInstance();
+            returnTypeResult = { type: types_1.NoneType.createInstance() };
         }
         // If the enclosing function is async and a generator, the return
         // statement is not allowed to have an argument. A syntax error occurs
@@ -558,9 +559,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsReturn(), node);
                 }
                 else {
-                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
-                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, new typeVarContext_1.TypeVarContext(), 
+                    if (this._evaluator.assignType(declaredReturnType, returnTypeResult.type, diagAddendum, new typeVarContext_1.TypeVarContext(), 
                     /* srcTypeVarContext */ undefined, 64 /* AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
@@ -582,7 +583,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             }
                             if (!typeVarContext.isEmpty()) {
                                 const adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
-                                if (this._evaluator.assignType(adjustedReturnType, returnType, diagAddendum, 
+                                if (this._evaluator.assignType(adjustedReturnType, returnTypeResult.type, diagAddendum, 
                                 /* destTypeVarContext */ undefined, 
                                 /* srcTypeVarContext */ undefined, 64 /* AllowBoolTypeGuard */)) {
                                     returnTypeMatches = true;
@@ -591,19 +592,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     if (!returnTypeMatches) {
+                        // If we have more detailed diagnostic information from
+                        // bidirectional type inference, use that.
+                        if (returnTypeResult.expectedTypeDiagAddendum) {
+                            diagAddendum = returnTypeResult.expectedTypeDiagAddendum;
+                        }
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeMismatch().format({
-                            exprType: this._evaluator.printType(returnType),
+                            exprType: this._evaluator.printType(returnTypeResult.type),
                             returnType: this._evaluator.printType(declaredReturnType),
-                        }) + diagAddendum.getString(), node.returnExpression ? node.returnExpression : node);
+                        }) + diagAddendum.getString(), node.returnExpression ? node.returnExpression : node, (_b = returnTypeResult.expectedTypeDiagAddendum) === null || _b === void 0 ? void 0 : _b.getEffectiveTextRange());
                     }
                 }
             }
-            if ((0, types_1.isUnknown)(returnType)) {
+            if ((0, types_1.isUnknown)(returnTypeResult.type)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.returnExpression);
             }
-            else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
+            else if ((0, typeUtils_1.isPartlyUnknown)(returnTypeResult.type)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
-                    returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
+                    returnType: this._evaluator.printType(returnTypeResult.type, { expandTypeAlias: true }),
                 }), node.returnExpression);
             }
         }