chore(common): wrapper BinaryenModule with AsModule to support more information from frontend to optimizer (#119)

Author: HerrCai0907

frontend/CompilerImpl.cpp

@@ -357,25 +357,25 @@ warpo::frontend::CompilationResult FrontendCompiler::compile(std::vector<std::st
       }
     }
     if (checkDiag(program, config.useColorfulDiagMessage))
-      return {.m = nullptr, .errorMessage = errorMessage_};
+      return {.m = {}, .errorMessage = errorMessage_};
     parseStat.release();
 
     support::PerfRAII compileStat{support::PerfItemKind::CompilationHIR_Compilation};
     m.callExportedFunctionWithName<0>(stackTop, "initializeProgram", program);
     int32_t const compiled = m.callExportedFunctionWithName<1>(stackTop, "compile", program)[0].i32;
     if (checkDiag(program, config.useColorfulDiagMessage))
-      return {.m = nullptr, .errorMessage = errorMessage_};
+      return {.m = {}, .errorMessage = errorMessage_};
     wasm::Module *binaryen_module = reinterpret_cast<wasm::Module *>(
         m.callExportedFunctionWithName<1>(stackTop, "getBinaryenModuleRef", compiled)[0].i64);
     compileStat.release();
-    return {.m = BinaryenModule{binaryen_module}, .errorMessage = std::nullopt};
+    return {.m = AsModule{binaryen_module}, .errorMessage = errorMessage_};
   } catch (vb::TrapException const &e) {
     logger << "Error: " << e.what() << vb::endStatement;
     m.printStacktrace(logger);
   } catch (std::exception const &e) {
     logger << "Error: " << e.what() << vb::endStatement;
   }
-  return {.m = nullptr, .errorMessage = "AS wasm execution failed"};
+  return {.m = {}, .errorMessage = "AS wasm execution failed"};
 }
 
 } // namespace warpo::frontend

include/warpo/common/AsModule.hpp

@@ -0,0 +1,66 @@
+// Copyright (C) 2025 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <binaryen/src/binaryen-c.h>
+#include <cstddef>
+#include <utility>
+
+namespace warpo {
+
+class BinaryenModule {
+  BinaryenModuleRef ref_;
+
+public:
+  BinaryenModule(BinaryenModule const &) = delete;
+  BinaryenModule(BinaryenModule &&o) noexcept : ref_(o.ref_) {
+    if (&o != this)
+      o.ref_ = nullptr;
+  }
+  BinaryenModule &operator=(BinaryenModule const &) = delete;
+  BinaryenModule &operator=(BinaryenModule &&o) noexcept {
+    BinaryenModuleRef tmp = ref_;
+    ref_ = o.ref_;
+    o.ref_ = ref_;
+    return *this;
+  }
+
+  BinaryenModule() noexcept : BinaryenModule(nullptr) {}
+  BinaryenModule(BinaryenModuleRef ref) noexcept : ref_(ref) {}
+  ~BinaryenModule() noexcept {
+    if (ref_)
+      BinaryenModuleDispose(ref_);
+  }
+
+  BinaryenModuleRef get() const noexcept { return static_cast<BinaryenModuleRef>(ref_); }
+
+  bool operator==(std::nullptr_t) const { return ref_ == nullptr; }
+};
+
+class AsModule {
+  BinaryenModule raw_;
+  // TODO: more information fields
+
+public:
+  AsModule() = default;
+  explicit AsModule(BinaryenModule raw) : raw_(std::move(raw)) {}
+  BinaryenModuleRef get() const { return raw_.get(); }
+  bool valid() const { return raw_ != nullptr; }
+  bool invalid() const { return !valid(); }
+};
+
+} // namespace warpo

include/warpo/common/BinaryenRAII.hpp

@@ -6,7 +6,7 @@
 #include <string>
 #include <vector>
 
-#include "warpo/common/BinaryenRAII.hpp"
+#include "warpo/common/AsModule.hpp"
 #include "warpo/common/Features.hpp"
 
 namespace wasm {
@@ -34,8 +34,8 @@ struct Config {
 Config getDefaultConfig();
 
 struct CompilationResult {
-  BinaryenModule m;
-  std::optional<std::string> errorMessage;
+  AsModule m;
+  std::string errorMessage;
 };
 
 CompilationResult compile();

include/warpo/frontend/Compiler.hpp

@@ -61,12 +61,12 @@ frontend::CompilationResult compile(nlohmann::json const &configJson, std::files
 [[nodiscard]] TestResult runUpdate(nlohmann::json const &configJson, std::filesystem::path const &tsPath,
                                    std::filesystem::path const &expectedOutPath) {
   frontend::CompilationResult const ret = compile(configJson, tsPath);
-  if (ret.m == nullptr) {
+  if (ret.m.invalid()) {
     if (configJson.contains("stderr")) {
       return TestResult::Success;
     } else {
       fmt::println("FAILED '{}': expected to compile successfully\nerror message: {}", tsPath.c_str(),
-                   *ret.errorMessage);
+                   ret.errorMessage);
       return TestResult::Failure;
     }
   }
@@ -80,7 +80,7 @@ frontend::CompilationResult compile(nlohmann::json const &configJson, std::files
 [[nodiscard]] TestResult runCompilationErrorCase(nlohmann::json const &configJson,
                                                  std::filesystem::path const &tsPath) {
   frontend::CompilationResult const ret = compile(configJson, tsPath);
-  if (ret.m != nullptr) {
+  if (ret.m.valid()) {
     fmt::println("'{}' success to compile but expect failed", tsPath.c_str());
     return TestResult::Failure;
   }
@@ -94,12 +94,11 @@ frontend::CompilationResult compile(nlohmann::json const &configJson, std::files
     }
   }
 
-  std::string const &actualStderr = *ret.errorMessage;
   size_t lastIndex = 0;
   bool failed = false;
   for (auto const &expectedErrorMessageLineJson : configJson["stderr"].get<nlohmann::json::array_t>()) {
     std::string const expectedErrorMessageLine = expectedErrorMessageLineJson.get<std::string>();
-    size_t index = actualStderr.find(expectedErrorMessageLine, lastIndex);
+    size_t index = ret.errorMessage.find(expectedErrorMessageLine, lastIndex);
     if (index == std::string::npos) {
       fmt::println("\tmissing pattern '{}' in stderr.", expectedErrorMessageLine);
       failed = true;
@@ -111,7 +110,7 @@ frontend::CompilationResult compile(nlohmann::json const &configJson, std::files
     fmt::println("\t========== actual error message==========\n"
                  "{}"
                  "\t========== actual error message==========",
-                 actualStderr);
+                 ret.errorMessage);
     fmt::println("FAILED '{}': stderr mismatch", tsPath.c_str());
     return TestResult::Failure;
   }
@@ -121,8 +120,8 @@ frontend::CompilationResult compile(nlohmann::json const &configJson, std::files
 [[nodiscard]] TestResult runSnapshotCase(nlohmann::json const &configJson, std::filesystem::path const &tsPath,
                                          std::filesystem::path const &expectedOutPath) {
   frontend::CompilationResult const ret = compile(configJson, tsPath);
-  if (ret.m == nullptr) {
-    fmt::println("FAILED '{}': expected to compile successfully\nerror message: {}", tsPath.c_str(), *ret.errorMessage);
+  if (ret.m.invalid()) {
+    fmt::println("FAILED '{}': expected to compile successfully\nerror message: {}", tsPath.c_str(), ret.errorMessage);
     return TestResult::Failure;
   }
   std::stringstream ss;

tests/frontend/FrontendTest.cpp

@@ -27,9 +27,9 @@ void ascMain(int argc, const char *argv[]) {
   cli::init(cli::Category::Frontend | cli::Category::Optimization, program, argc, argv);
 
   frontend::CompilationResult const result = frontend::compile();
-  if (result.m == nullptr) {
+  if (result.m.invalid()) {
     fmt::println("compilation failed");
-    fmt::println("{}", result.errorMessage.value_or("unknown error"));
+    fmt::println("{}", result.errorMessage);
     throw std::runtime_error("compilation failed");
   }
   passes::runAndEmit(result.m.get(), outputPath.get());

tools/asc/AscMain.cpp

@@ -24,9 +24,9 @@ void compilerMain(int argc, const char *argv[]) {
   cli::init(cli::Category::Frontend, program, argc, argv);
 
   frontend::CompilationResult const result = frontend::compile();
-  if (result.m == nullptr) {
+  if (result.m.invalid()) {
     fmt::println("compilation failed");
-    fmt::println("{}", result.errorMessage.value_or("unknown error"));
+    fmt::println("{}", result.errorMessage);
     throw std::runtime_error("compilation failed");
   }
   char *const wasmText = BinaryenModuleAllocateAndWriteText(result.m.get());