Apply the implicit conversions in return statements

src/parser/cxx/parser.cc

@@ -3790,6 +3790,8 @@ auto Parser::parse_return_statement(StatementAST*& yyast) -> bool {
     parse_expr_or_braced_init_list(ast->expression, ExprContext{});
 
     expect(TokenKind::T_SEMICOLON, ast->semicolonLoc);
+
+    check(ast);
   }
 
   return true;
@@ -9808,6 +9810,17 @@ void Parser::check(ExpressionAST* ast) {
   check(ast);
 }
 
+void Parser::check(StatementAST* ast) {
+  if (binder_.inTemplate()) return;
+  auto returnStatement = ast_cast<ReturnStatementAST>(ast);
+  if (!returnStatement) return;
+
+  TypeChecker check{unit};
+  check.setScope(scope());
+  check.setReportErrors(config().checkTypes);
+  check.checkReturnStatement(returnStatement);
+}
+
 auto Parser::getFunction(Scope* scope, const Name* name, const Type* type)
     -> FunctionSymbol* {
   auto parentScope = scope;

src/parser/cxx/parser.h

@@ -789,6 +789,7 @@ class Parser final {
   void setScope(ScopedSymbol* symbol);
 
   void check(ExpressionAST* ast);
+  void check(StatementAST* ast);
 
   // lookup
 

src/parser/cxx/type_checker.cc

@@ -2262,4 +2262,28 @@ auto TypeChecker::Visitor::check_pseudo_destructor_access(
   return true;
 }
 
+void TypeChecker::checkReturnStatement(ReturnStatementAST* ast) {
+  const Type* targetType = nullptr;
+  for (auto current = scope_; current; current = current->parent()) {
+    if (auto function = symbol_cast<FunctionSymbol>(current->owner())) {
+      if (auto functionType = type_cast<FunctionType>(function->type())) {
+        targetType = functionType->returnType();
+      }
+      break;
+    }
+
+    if (auto lambda = symbol_cast<LambdaSymbol>(current->owner())) {
+      if (auto functionType = type_cast<FunctionType>(lambda->type())) {
+        targetType = functionType->returnType();
+      }
+      break;
+    }
+  }
+
+  if (!targetType) return;
+
+  Visitor visitor{*this};
+  (void)visitor.implicit_conversion(ast->expression, targetType);
+}
+
 }  // namespace cxx

src/parser/cxx/type_checker.h

@@ -45,6 +45,8 @@ class TypeChecker {
 
   void check(ExpressionAST* ast);
 
+  void checkReturnStatement(ReturnStatementAST* ast);
+
  private:
   struct Visitor;