#19 Use clang-format

* Some CppFile updates

Author: tzijnge

src/lrpc/codegen/common.py

@@ -4,16 +4,16 @@
 from lrpc.core import LrpcVar
 
 
-def lrpc_var_includes(var: LrpcVar) -> set[str]:
-    includes = set()
+def lrpc_var_includes(var: LrpcVar) -> set[tuple[str, bool]]:
+    includes: set[tuple[str, bool]] = set()
     if var.base_type_is_integral():
-        includes.add("<cstdint>")
+        includes.add(("<cstdint>", True))
 
     if var.base_type_is_custom():
-        includes.add(f'"{var.base_type()}.hpp"')
+        includes.add((f'"{var.base_type()}.hpp"', True))
 
     if var.base_type_is_string() or var.is_array() or var.is_optional():
-        includes.add('"lrpccore/LrpcTypes.hpp"')
+        includes.add(('"lrpccore/LrpcTypes.hpp"', True))
 
     return includes
 

src/lrpc/codegen/cppfile/cpp_file.py

@@ -10,6 +10,8 @@
 
 
 class CppFile:
+    IWYU_EXPORT = " // IWYU pragma: export"
+
     def __init__(self, filename: str, writer: TextIO | None = None, indent: str = "    ") -> None:
         self._indent = indent
         self._level = 0
@@ -26,11 +28,18 @@ def __call__(self, text: str) -> None:
     def newline(self) -> None:
         self._file.write("\n")
 
+    def pragma_once(self) -> None:
+        self.write("#pragma once")
+
+    def include(self, path: str, *, iwyu_export: bool = False) -> None:
+        suffix = self.IWYU_EXPORT if iwyu_export else ""
+        self.write(f"#include {path}{suffix}")
+
     def label(self, text: str) -> None:
         self._file.write(self._indent * (self._level - 1) + text + ":\n")
 
     @contextmanager
-    def block(self, text: str, postfix: str = "") -> Generator[None, None, None]:
+    def block(self, text: str, postfix: str = "", *, trailing_newline: bool = False) -> Generator[None, None, None]:
         self.write(text)
         self._file.write(self._indent * self._level + "{\n")
         self._level += 1
@@ -39,6 +48,8 @@ def block(self, text: str, postfix: str = "") -> Generator[None, None, None]:
         finally:
             self._level -= 1
             self._file.write(self._indent * self._level + "}" + postfix + "\n")
+            if trailing_newline:
+                self._file.write("\n")
 
     def close(self) -> None:
         if self._owns_file:

src/lrpc/codegen/meta_constants_writer.py

@@ -28,9 +28,9 @@ def write_constants(
         self._compressed_definition = compressed_definition
         self._definition_stream_chunk_size = definition_stream_chunk_size
 
-        self._file.write("#pragma once")
-        self._file.write("#include <cstdint>")
-        self._file.write('#include "lrpccore/LrpcTypes.hpp"')
+        self._file.pragma_once()
+        self._file.include("<cstdint>")
+        self._file.include('"lrpccore/LrpcTypes.hpp"')
 
         self._file.newline()
         optionally_in_namespace(self._file, self._write_constants, namespace)

src/lrpc/codegen/meta_service_file_writer.py

@@ -39,9 +39,9 @@ def __init__(self, file: CppFile) -> None:
         self._file = file
 
     def write_service(self, namespace: str | None = None) -> None:
-        self._file.write("#pragma once")
-        self._file.write('#include "LrpcMeta_shim.hpp"')
-        self._file.write('#include "LrpcMeta_constants.hpp"')
+        self._file.pragma_once()
+        self._file.include('"LrpcMeta_shim.hpp"')
+        self._file.include('"LrpcMeta_constants.hpp"')
 
         self._file.newline()
         optionally_in_namespace(self._file, self._write_service_class, namespace)

src/lrpc/codegen/server_include.py

@@ -22,13 +22,13 @@ def visit_lrpc_def(self, lrpc_def: LrpcDef) -> None:
         self._file = CppFile(f"{self._output}/{lrpc_def.name()}.hpp")
 
         write_file_banner(self._file)
-        self._file.write("#pragma once")
-        self._file.write('#include "lrpccore/LrpcTypes.hpp" // IWYU pragma: export')
-        self._file.write('#include "lrpccore/Server.hpp" // IWYU pragma: export')
+        self._file.pragma_once()
+        self._file.include('"lrpccore/LrpcTypes.hpp"', iwyu_export=True)
+        self._file.include('"lrpccore/Server.hpp"', iwyu_export=True)
         if len(lrpc_def.constants()) != 0:
-            self._file.write(f'#include "{lrpc_def.name()}_Constants.hpp" // IWYU pragma: export')
-        self._file.write('#include "LrpcMeta_constants.hpp" // IWYU pragma: export')
-        self._file.write('#include "LrpcMeta_service.hpp" // IWYU pragma: export')
+            self._file.include(f'"{lrpc_def.name()}_Constants.hpp"', iwyu_export=True)
+        self._file.include('"LrpcMeta_constants.hpp"', iwyu_export=True)
+        self._file.include('"LrpcMeta_service.hpp"', iwyu_export=True)
 
     def visit_rpc_settings(self, settings: RpcSettings) -> None:
         rx = settings.rx_buffer_size()
@@ -40,8 +40,8 @@ def visit_rpc_settings(self, settings: RpcSettings) -> None:
 
     def visit_lrpc_service(self, service: LrpcService) -> None:
         if service.name() != "LrpcMeta":
-            self._file.write(f'#include "{service.name()}_includes.hpp" // IWYU pragma: export')
-            self._file.write(f'#include "{service.name()}_shim.hpp" // IWYU pragma: export')
+            self._file.include(f'"{service.name()}_includes.hpp"', iwyu_export=True)
+            self._file.include(f'"{service.name()}_shim.hpp"', iwyu_export=True)
 
     def visit_lrpc_def_end(self) -> None:
         self._file.newline()

src/lrpc/codegen/service_include.py

@@ -10,25 +10,25 @@ class ServiceIncludeVisitor(LrpcVisitor):
     def __init__(self, output: Path) -> None:
         self._output = output
         self._file: CppFile
-        self._includes: set[str] = set()
+        self._includes: set[tuple[str, bool]] = set()
 
     def _create_service_include(self, output: Path, service_name: str) -> None:
         self._includes = set()
 
         self._file = CppFile(f"{output}/{service_name}_includes.hpp")
         write_file_banner(self._file)
-        self._file.write("#pragma once")
+        self._file.pragma_once()
 
     def visit_lrpc_service(self, service: LrpcService) -> None:
         self._create_service_include(self._output, service.name())
 
     def visit_lrpc_service_end(self) -> None:
-        for i in sorted(self._includes):
-            self._file.write(f"#include {i} // IWYU pragma: export")
+        for path, iwyu_export in sorted(self._includes):
+            self._file.include(path, iwyu_export=iwyu_export)
 
     def visit_lrpc_function(self, function: LrpcFun) -> None:
         if function.number_returns() > 1:
-            self._includes.add("<tuple>")
+            self._includes.add(("<tuple>", True))
 
     def visit_lrpc_function_return(self, ret: LrpcVar) -> None:
         self._includes.update(lrpc_var_includes(ret))

src/lrpc/codegen/service_shim.py

@@ -133,25 +133,23 @@ def _write_server_stream_stop_request_shims(self, server_streams: list[LrpcStrea
             self._file.write("// Server stream start/stop shims")
 
         for stream in server_streams:
-            with self._file.block(f"void {stream.name()}_start_stop_shim(Reader& reader)"):
+            with self._file.block(
+                f"void {stream.name()}_start_stop_shim(Reader& reader)", trailing_newline=True,
+            ):
                 self._file.write("const auto start = reader.read_unchecked<bool>();")
                 with self._file.block("if (start)"):
                     self._file.write(f"{stream.name()}();")
                 with self._file.block("else"):
                     self._file.write(f"{stream.name()}_stop();")
 
-            self._file.newline()
-
     def _write_client_stream_stop_requests(self, client_streams: list[LrpcStream]) -> None:
         if len(client_streams) != 0:
             self._file.write("// Client stream stop requests")
 
         for stream in client_streams:
-            with self._file.block(f"void {stream.name()}_requestStop()"):
+            with self._file.block(f"void {stream.name()}_requestStop()", trailing_newline=True):
                 self._file(f"requestStop({stream.id()});")
 
-            self._file.newline()
-
     def _write_shim_array(
         self,
         functions: list[LrpcFun],
@@ -161,16 +159,16 @@ def _write_shim_array(
         max_function_or_stream_id = self._max_function_or_stream_id(functions, client_streams, server_streams)
 
         self._file.write(f"using ShimType = void ({self._class_name()}::*)(Reader &);")
-        with self._file.block("void missingFunction_shim(Reader& reader)"):
+        with self._file.block("void missingFunction_shim(Reader& reader)", trailing_newline=True):
             self._file.write("const auto data = reader.data();")
             self._file.write("const auto functionOrStreamId = static_cast<uint8_t>(data.at(2));")
             self._file.write("server().error(LrpcMetaError::UnknownFunctionOrStream, id(), functionOrStreamId);")
-        self._file.newline()
 
         with self._file.block("static ShimType shim(const size_t functionId)"):
             with self._file.block(
                 f"static constexpr lrpc::array<ShimType, {max_function_or_stream_id + 1}> shims",
                 ";",
+                trailing_newline=True,
             ):
                 function_info = {function.id(): function.name() for function in functions}
                 client_stream_info = {stream.id(): stream.name() for stream in client_streams}
@@ -183,13 +181,9 @@ def _write_shim_array(
                     name = server_stream_info.get(fid, name)
                     self._file(f"&{self._class_name()}::{name}_shim,")
 
-            self._file.newline()
-
-            with self._file.block("if (functionId >= shims.size())"):
+            with self._file.block("if (functionId >= shims.size())", trailing_newline=True):
                 self._file.write(f"return &{self._class_name()}::missingFunction_shim;")
 
-            self._file.newline()
-
             self._file.write("return shims.at(functionId);")
 
     @staticmethod
@@ -219,12 +213,12 @@ def _max_function_or_stream_id(
         return max(server_stream_ids + client_stream_ids + function_ids)
 
     def _write_include_guard(self) -> None:
-        self._file("#pragma once")
+        self._file.pragma_once()
 
     def _write_includes(self) -> None:
-        self._file('#include "lrpccore/Service.hpp"')
-        self._file('#include "lrpccore/EtlRwExtensions.hpp"')
-        self._file(f'#include "{self._service.name()}_includes.hpp"')
+        self._file.include('"lrpccore/Service.hpp"')
+        self._file.include('"lrpccore/EtlRwExtensions.hpp"')
+        self._file.include(f'"{self._service.name()}_includes.hpp"')
 
         self._file.newline()