runtime: flush std file descriptors at exit

Author: gf712

src/interpreter/Interpreter.cpp

@@ -227,13 +227,30 @@ void Interpreter::internal_setup(const std::string &name,
 					return buffered_writer->call(PyTuple::create(stderr).unwrap(), nullptr);
 				})
 				.and_then([text_io_wrapper](PyObject *stderr_buffer_writer) {
+					auto *line_buffering = py_true();
 					return text_io_wrapper->call(
-						PyTuple::create(stderr_buffer_writer).unwrap(), nullptr);
+						PyTuple::create(
+							stderr_buffer_writer, py_none(), py_none(), py_none(), line_buffering)
+							.unwrap(),
+						nullptr);
 				});
 		ASSERT(py_stderr.is_ok());
-		sys->add_symbol(PyString::create("stdin").unwrap(), py_stdin.unwrap());
-		sys->add_symbol(PyString::create("stdout").unwrap(), py_stdout.unwrap());
-		sys->add_symbol(PyString::create("stderr").unwrap(), py_stderr.unwrap());
+
+		for (auto [name, obj] : std::views::zip(std::array{ "stdin", "stdout", "stderr" },
+				 std::array{ py_stdin.unwrap(), py_stdout.unwrap(), py_stderr.unwrap() })) {
+			sys->add_symbol(PyString::create(name).unwrap(), obj);
+			register_callback(PyNativeFunction::create(
+								  std::string{ name } + "_exit",
+								  [obj](PyTuple *, PyDict *) -> PyResult<PyObject *> {
+									  return obj->get_method(PyString::create("flush").unwrap())
+										  .and_then([](PyObject *flush) {
+											  return flush->call(nullptr, nullptr);
+										  });
+								  },
+								  obj)
+								  .unwrap(),
+				nullptr);
+		}
 	}
 
 	if (config.requires_importlib) {

src/runtime/modules/BuiltinsModule.cpp

@@ -92,9 +92,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
 		// sys.stdout may be None when FILE* stdout isn't connected
 		if (!file || file == py_none()) { return Ok(py_none()); }
 	}
-	// TODO: flush should be false, but for now we keep it as true, since there is no flush at
-	// interpreter shutdown
-	bool flush = true;
+	bool flush = false;
 	if (kwargs) {
 		static const Value separator_keyword = String{ "sep" };
 		static const Value end_keyword = String{ "end" };

src/runtime/modules/IOModule.cpp

@@ -2959,8 +2959,7 @@ class TextIOWrapper : public TextIOBase
 
 	std::optional<Bytes> m_buffer_bytes;
 	size_t m_position{ 0 };
-	std::optional<Bytes> m_pending_bytes;// bytes to be written
-	size_t m_pending_bytes_count{ 0 };
+	Bytes m_pending_bytes;
 
 	size_t m_chunk_size{ 8192 };
 
@@ -3230,18 +3229,17 @@ class TextIOWrapper : public TextIOBase
 		return Ok(result);
 	}
 
-	PyResult<size_t> writeflush()
+	PyResult<std::monostate> writeflush()
 	{
-		if (!m_pending_bytes.has_value()) { return Ok(0); }
+		if (m_pending_bytes.b.empty()) { return Ok(std::monostate{}); }
 		auto written =
 			m_buffer->get_method(PyString::create("write").unwrap())
 				.and_then([this](PyObject *write) {
-					return write->call(PyTuple::create(m_pending_bytes.value()).unwrap(), nullptr);
+					return write->call(PyTuple::create(m_pending_bytes).unwrap(), nullptr);
 				});
 		if (written.is_err()) { return Err(written.unwrap_err()); }
 		m_pending_bytes = {};
-		m_pending_bytes_count = 0;
-		return Ok(0);
+		return Ok(std::monostate{});
 	}
 
 
@@ -3252,26 +3250,25 @@ class TextIOWrapper : public TextIOBase
 		auto *text = PyObject::from(args->elements()[0]).unwrap();
 		ASSERT(as<PyString>(text));
 		const auto text_len = as<PyString>(text)->size();
+
 		// TODO: Should use encoder
-		m_pending_bytes = Bytes::from_unescaped_string(as<PyString>(text)->to_string());
-		m_pending_bytes_count = m_pending_bytes->b.size();
+		auto new_bytes = Bytes::from_unescaped_string(as<PyString>(text)->to_string());
+		m_pending_bytes.b.insert(m_pending_bytes.b.end(), new_bytes.b.begin(), new_bytes.b.end());
+
 		const auto should_flush = [this]() -> bool {
 			if (!m_line_buffering) { return false; }
-			if (std::ranges::find(m_pending_bytes->b, std::byte{ '\n' })
-				!= m_pending_bytes->b.end()) {
+			if (std::ranges::find(m_pending_bytes.b, std::byte{ '\n' })
+				!= m_pending_bytes.b.end()) {
 				return true;
 			}
-			return std::ranges::find(m_pending_bytes->b, std::byte{ '\r' })
-				   != m_pending_bytes->b.end();
+			return std::ranges::find(m_pending_bytes.b, std::byte{ '\r' })
+				   != m_pending_bytes.b.end();
 		}();
-		auto result = writeflush();
-		while (result.is_ok()) {
-			ASSERT(m_pending_bytes_count >= result.unwrap());
-			m_pending_bytes_count -= result.unwrap();
-			if (m_pending_bytes_count == 0) { break; }
-			result = writeflush();
+
+		if (m_pending_bytes.b.size() >= m_chunk_size || should_flush || m_write_through) {
+			auto result = writeflush();
+			if (result.is_err()) { return Err(result.unwrap_err()); }
 		}
-		if (result.is_err()) { return Err(result.unwrap_err()); }
 
 		if (should_flush) {
 			if (auto r = m_buffer->get_method(PyString::create("flush").unwrap())
@@ -3337,8 +3334,7 @@ class TextIOWrapper : public TextIOBase
 
 		m_line_buffering = line_buffering;
 		m_write_through = write_through;
-		m_newline = newline.value_or("'\n");
-		m_pending_bytes_count = 0;
+		m_newline = newline.value_or("\n");
 
 		return Ok(1);
 	}