use fmt instead of sstream

CMakeLists.txt

@@ -5,6 +5,7 @@ option(ENABLE_LOGGING "Enable logging support" ON)
 option(ENABLE_STACKTRACE "Enable stacktrace support" ON)
 option(ENABLE_TESTS "Enable tests" ON)
 option(ENABLE_COMPILER "Enables tracing and backend compilers" ON)
+option(USE_EXTERNAL_FMT "Use a externally provided version of fmt" OFF)
 option(USE_EXTERNAL_SPDLOG "Use a externally provided version of spdlog" OFF)
 option(USE_EXTERNAL_MLIR "Use a externally provided version of MLIR" OFF)
 cmake_dependent_option(ENABLE_TRACING "Enable the tracing" ON "ENABLE_COMPILER" OFF)
@@ -66,9 +67,12 @@ if (ENABLE_TESTS)
     list(APPEND EXPORT_TARGETS Catch2)
 endif ()
 
-
-add_subdirectory(${THIRD_PARTY_DIR}/fmt)
-list(APPEND EXPORT_TARGETS fmt)
+if (USE_EXTERNAL_FMT)
+    find_package(fmt CONFIG REQUIRED)
+else ()
+    add_subdirectory(${THIRD_PARTY_DIR}/fmt)
+    list(APPEND EXPORT_TARGETS fmt)
+endif ()
 
 if (ENABLE_LOGGING)
     if (USE_EXTERNAL_SPDLOG)

nautilus/CMakeLists.txt

@@ -32,12 +32,14 @@ set_target_properties(nautilus PROPERTIES
         EXPORT_NAME nautilus
 )
 
+
+disable_target_warnings(fmt)
+target_link_libraries(nautilus PRIVATE fmt::fmt)
+
 if (ENABLE_LOGGING)
     target_link_libraries(nautilus PRIVATE spdlog::spdlog)
 endif ()
 
-disable_target_warnings(fmt)
-target_link_libraries(nautilus PRIVATE fmt::fmt)
 
 if (ENABLE_STACKTRACE)
     # Add Backward to your target (either Backward::Interface, Backward::Object, or Backward::Backward)

nautilus/include/nautilus/common/config.h.in

@@ -1,5 +1,6 @@
 
 #cmakedefine ENABLE_TRACING
+#cmakedefine ENABLE_LOGGING
 #cmakedefine ENABLE_BC_BACKEND
 #cmakedefine ENABLE_C_BACKEND
 #cmakedefine ENABLE_MLIR_BACKEND

nautilus/src/nautilus/compiler/DumpHandler.hpp

@@ -15,7 +15,7 @@ class DumpHandler {
 	[[nodiscard]] bool dumpToConsole() const;
 	[[nodiscard]] bool dumpToFile() const;
 	const engine::Options& options;
-	const CompilationUnitID& id;
+	[[maybe_unused]] const CompilationUnitID& id;
 	const std::filesystem::path rootPath;
 };
 

nautilus/src/nautilus/compiler/ir/IRGraph.cpp

@@ -12,7 +12,6 @@
 #include "nautilus/compiler/ir/operations/FunctionOperation.hpp"
 #include "nautilus/compiler/ir/operations/IfOperation.hpp"
 #include "nautilus/compiler/ir/operations/LoadOperation.hpp"
-#include "nautilus/compiler/ir/operations/LogicalOperations/AndOperation.hpp"
 #include "nautilus/compiler/ir/operations/LogicalOperations/CompareOperation.hpp"
 #include "nautilus/compiler/ir/operations/LogicalOperations/NotOperation.hpp"
 #include "nautilus/compiler/ir/operations/ProxyCallOperation.hpp"
@@ -39,10 +38,6 @@ const FunctionOperation& IRGraph::getRootOperation() const {
 	return *rootOperation;
 }
 
-std::string IRGraph::toString() const {
-	return fmt::to_string(*this);
-}
-
 constexpr const char* binaryOpToString(Operation::OperationType type) {
 	switch (type) {
 	case Operation::OperationType::AddOp:
@@ -111,7 +106,9 @@ constexpr const char* compOpToString(CompareOperation::Comparator type) {
 
 } // namespace nautilus::compiler::ir
 
-#include <fmt/format.h>
+std::string nautilus::compiler::ir::IRGraph::toString() const {
+	return fmt::to_string(*this);
+}
 
 namespace fmt {
 using namespace nautilus::compiler::ir;

nautilus/src/nautilus/tracing/Block.cpp

@@ -2,7 +2,6 @@
 #include "nautilus/tracing/TraceOperation.hpp"
 #include "nautilus/tracing/TracingUtil.hpp"
 #include "nautilus/tracing/Types.hpp"
-#include <fmt/format.h>
 
 namespace nautilus::tracing {
 
@@ -23,38 +22,3 @@ void Block::addArgument(TypedValueRef ref) {
 }
 
 } // namespace nautilus::tracing
-
-namespace fmt {
-template <>
-struct formatter<nautilus::tracing::Block> : formatter<std::string_view> {
-	static auto format(const nautilus::tracing::Block& c, format_context& ctx) -> format_context::iterator;
-};
-} // namespace fmt
-
-namespace fmt {
-template <>
-struct formatter<nautilus::tracing::TraceOperation> : formatter<std::string_view> {
-	static auto format(const nautilus::tracing::TraceOperation& c, format_context& ctx) -> format_context::iterator;
-};
-} // namespace fmt
-
-
-auto fmt::formatter<nautilus::tracing::Block>::format(const nautilus::tracing::Block& block, format_context& ctx) -> format_context::iterator {
-	auto out = ctx.out();
-	fmt::format_to(out, "(");
-	for (size_t i = 0; i < block.arguments.size(); i++) {
-		if (i != 0) {
-			fmt::format_to(out, ",");
-		}
-		fmt::format_to(out, "${}:{}", block.arguments[i].ref, toString(block.arguments[i].type));
-	}
-	fmt::format_to(out, ")");
-	if (block.type == nautilus::tracing::Block::Type::ControlFlowMerge) {
-		fmt::format_to(out, " ControlFlowMerge");
-	}
-	fmt::format_to(out, "\n");
-	for (const auto& operation : block.operations) {
-		fmt::format_to(out, "{}\n", operation);
-	}
-	return out;
-}

nautilus/src/nautilus/tracing/ExecutionTrace.cpp

@@ -238,10 +238,11 @@ void ExecutionTrace::addTag(Snapshot& snapshot, operation_identifier& identifier
 	localTagMap[snapshot] = identifier;
 }
 
-std::string ExecutionTrace::toString() const {
+} // namespace nautilus::tracing
+
+std::string nautilus::tracing::ExecutionTrace::toString() const {
 	return fmt::to_string(*this);
 }
-} // namespace nautilus::tracing
 
 namespace fmt {
 template <>
@@ -253,12 +254,103 @@ template <>
 struct formatter<nautilus::tracing::Block> : formatter<std::string_view> {
 	static auto format(const nautilus::tracing::Block& trace, format_context& ctx) -> format_context::iterator;
 };
-} // namespace fmt
 
-auto fmt::formatter<nautilus::tracing::ExecutionTrace>::format(const nautilus::tracing::ExecutionTrace& trace, fmt::format_context& ctx) -> format_context::iterator {
+template <>
+struct formatter<nautilus::tracing::TraceOperation> : formatter<std::string_view> {
+	static auto format(const nautilus::tracing::TraceOperation& trace, format_context& ctx) -> format_context::iterator;
+};
+
+auto formatter<nautilus::tracing::ExecutionTrace>::format(const nautilus::tracing::ExecutionTrace& trace, fmt::format_context& ctx) -> format_context::iterator {
 	auto out = ctx.out();
 	for (size_t i = 0; i < trace.blocks.size(); i++) {
 		fmt::format_to(out, "B{}{}", i, trace.blocks[i]);
 	}
 	return out;
 }
+
+auto formatter<nautilus::tracing::Block>::format(const nautilus::tracing::Block& block, format_context& ctx) -> format_context::iterator {
+	auto out = ctx.out();
+	fmt::format_to(out, "(");
+	for (size_t i = 0; i < block.arguments.size(); i++) {
+		if (i != 0) {
+			fmt::format_to(out, ",");
+		}
+		fmt::format_to(out, "${}:{}", block.arguments[i].ref, toString(block.arguments[i].type));
+	}
+	fmt::format_to(out, ")");
+	if (block.type == nautilus::tracing::Block::Type::ControlFlowMerge) {
+		fmt::format_to(out, " ControlFlowMerge");
+	}
+	fmt::format_to(out, "\n");
+	for (const auto& operation : block.operations) {
+		fmt::format_to(out, "{}\n", operation);
+	}
+	return out;
+}
+
+template <>
+struct formatter<nautilus::tracing::TypedValueRef> : formatter<std::string_view> {
+	static auto format(const nautilus::tracing::TypedValueRef& typeValRef, format_context& ctx) -> format_context::iterator {
+		auto out = ctx.out();
+		fmt::format_to(out, "${}", typeValRef.ref);
+		return out;
+	}
+};
+
+template <>
+struct formatter<nautilus::tracing::BlockRef> : formatter<std::string_view> {
+	static auto format(const nautilus::tracing::BlockRef& ref, format_context& ctx) -> format_context::iterator {
+		auto out = ctx.out();
+		fmt::format_to(out, "B{}(", ref.block);
+		for (size_t i = 0; i < ref.arguments.size(); i++) {
+			if (i != 0) {
+				fmt::format_to(out, ",");
+			}
+			fmt::format_to(out, "{}", ref.arguments[i]);
+		}
+		fmt::format_to(out, ")");
+		return out;
+	}
+};
+
+template <>
+struct formatter<nautilus::tracing::FunctionCall> : formatter<std::string_view> {
+	static auto format(const nautilus::tracing::FunctionCall& call, format_context& ctx) -> format_context::iterator {
+		auto out = ctx.out();
+		fmt::format_to(out, "{}(", call.functionName);
+		for (size_t i = 0; i < call.arguments.size(); i++) {
+			if (i != 0) {
+				fmt::format_to(out, ",");
+			}
+			fmt::format_to(out, "{}", call.arguments[i]);
+		}
+		fmt::format_to(out, ")");
+		return out;
+	}
+};
+
+template <>
+struct formatter<nautilus::ConstantLiteral> : formatter<std::string_view> {
+	auto format(nautilus::ConstantLiteral c, format_context& ctx) const -> format_context::iterator;
+};
+
+auto formatter<nautilus::tracing::TraceOperation>::format(const nautilus::tracing::TraceOperation& operation, format_context& ctx) -> format_context::iterator {
+	auto out = ctx.out();
+	fmt::format_to(out, "\t{}\t", toString(operation.op));
+	fmt::format_to(out, "{}\t", operation.resultRef);
+	for (const auto& opInput : operation.input) {
+		if (auto inputRef = std::get_if<nautilus::tracing::value_ref>(&opInput)) {
+			fmt::format_to(out, "{}\t", *inputRef);
+		} else if (auto blockRef = std::get_if<nautilus::tracing::BlockRef>(&opInput)) {
+			fmt::format_to(out, "{}\t", *blockRef);
+		} else if (auto fCall = std::get_if<nautilus::tracing::FunctionCall>(&opInput)) {
+			fmt::format_to(out, "{}\t", *fCall);
+		} else if (auto constant = std::get_if<nautilus::ConstantLiteral>(&opInput)) {
+			fmt::format_to(out, "{}", *constant);
+		}
+	}
+	fmt::format_to(out, ":{}", toString(operation.resultType));
+	return out;
+}
+
+} // namespace fmt

nautilus/src/nautilus/tracing/TraceOperation.cpp

@@ -1,5 +1,4 @@
 #include "nautilus/tracing/TraceOperation.hpp"
-#include <fmt/core.h>
 
 namespace nautilus::tracing {
 
@@ -13,83 +12,3 @@ TraceOperation::TraceOperation(Op op, std::vector<InputVariant>&& input) : tag()
 }
 
 } // namespace nautilus::tracing
-
-namespace fmt {
-template <>
-struct formatter<nautilus::tracing::TraceOperation> : formatter<std::string_view> {
-	static auto format(const nautilus::tracing::TraceOperation& c, format_context& ctx) -> format_context::iterator;
-};
-
-template <>
-struct formatter<nautilus::tracing::BlockRef> : formatter<std::string_view> {
-	static auto format(const nautilus::tracing::BlockRef& c, format_context& ctx) -> format_context::iterator;
-};
-
-template <>
-struct formatter<nautilus::tracing::FunctionCall> : formatter<std::string_view> {
-	static auto format(const nautilus::tracing::FunctionCall& c, format_context& ctx) -> format_context::iterator;
-};
-
-template <>
-struct formatter<nautilus::tracing::TypedValueRef> : formatter<std::string_view> {
-	static auto format(const nautilus::tracing::TypedValueRef& c, format_context& ctx) -> format_context::iterator;
-};
-} // namespace fmt
-
-namespace fmt {
-template <>
-struct formatter<nautilus::ConstantLiteral> : formatter<std::string_view> {
-	auto format(nautilus::ConstantLiteral c, format_context& ctx) const -> format_context::iterator;
-};
-} // namespace fmt
-
-auto fmt::formatter<nautilus::tracing::TraceOperation>::format(const nautilus::tracing::TraceOperation& operation, format_context& ctx) -> format_context::iterator {
-	auto out = ctx.out();
-	fmt::format_to(out, "\t{}\t", toString(operation.op));
-	fmt::format_to(out, "{}\t", operation.resultRef);
-	for (const auto& opInput : operation.input) {
-		if (auto inputRef = std::get_if<nautilus::tracing::value_ref>(&opInput)) {
-			fmt::format_to(out, "{}\t", *inputRef);
-		} else if (auto blockRef = std::get_if<nautilus::tracing::BlockRef>(&opInput)) {
-			fmt::format_to(out, "{}\t", *blockRef);
-		} else if (auto fCall = std::get_if<nautilus::tracing::FunctionCall>(&opInput)) {
-			fmt::format_to(out, "{}\t", *fCall);
-		} else if (auto constant = std::get_if<nautilus::ConstantLiteral>(&opInput)) {
-			fmt::format_to(out, "{}", *constant);
-		}
-	}
-	fmt::format_to(out, ":{}", toString(operation.resultType));
-	return out;
-}
-
-auto fmt::formatter<nautilus::tracing::BlockRef>::format(const nautilus::tracing::BlockRef& ref, format_context& ctx) -> format_context::iterator {
-	auto out = ctx.out();
-	fmt::format_to(out, "B{}(", ref.block);
-	for (size_t i = 0; i < ref.arguments.size(); i++) {
-		if (i != 0) {
-			fmt::format_to(out, ",");
-		}
-		fmt::format_to(out, "{}", ref.arguments[i]);
-	}
-	fmt::format_to(out, ")");
-	return out;
-}
-
-auto fmt::formatter<nautilus::tracing::FunctionCall>::format(const nautilus::tracing::FunctionCall& call, format_context& ctx) -> format_context::iterator {
-	auto out = ctx.out();
-	fmt::format_to(out, "{}(", call.functionName);
-	for (size_t i = 0; i < call.arguments.size(); i++) {
-		if (i != 0) {
-			fmt::format_to(out, ",");
-		}
-		fmt::format_to(out, "{}", call.arguments[i]);
-	}
-	fmt::format_to(out, ")");
-	return out;
-}
-
-auto fmt::formatter<nautilus::tracing::TypedValueRef>::format(const nautilus::tracing::TypedValueRef& typeValRef, format_context& ctx) -> format_context::iterator {
-	auto out = ctx.out();
-	fmt::format_to(out, "${}", typeValRef.ref);
-	return out;
-}

nautilus/src/nautilus/tracing/TraceOperation.hpp

@@ -35,9 +35,7 @@ using InputVariant = std::variant<value_ref, None, ConstantLiteral, BlockRef, Fu
 class TraceOperation {
 public:
 	TraceOperation(Snapshot& tag, Op op, Type resultType, value_ref ref, std::vector<InputVariant>&& input);
-
 	TraceOperation(Op op, std::vector<InputVariant>&& input);
-
 	Snapshot tag;
 	Op op;
 	Type resultType;

nautilus/test/execution-tests/CMakeLists.txt

@@ -22,7 +22,7 @@ if (ENABLE_TRACING AND (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang"))
             $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../src>
             $<INSTALL_INTERFACE:src/nautilus/>)
 
-    target_link_libraries(nautilus-tracing-tests PUBLIC nautilus Catch2::Catch2WithMain fmt::fmt-header-only)
+    target_link_libraries(nautilus-tracing-tests PUBLIC nautilus Catch2::Catch2WithMain)
     list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
     catch_discover_tests(nautilus-tracing-tests EXTRA_ARGS --allow-running-no-tests)
 endif ()