feat(tests): duplicate lang suite to run with and without the ir inliner

Author: SuperFola

src/arkreactor/Compiler/IntermediateRepresentation/IRInliner.cpp

@@ -185,13 +185,20 @@ namespace Ark::internal
     void IRInliner::inlineBlock(const IR::Block& inlinee, IR::Block& destination)
     {
         if (destination.metadata.addr == 0)
-            m_logger.debug("Inlining call to '{}' ({}) inside global scope", inlinee.debugName(), inlinee.metadataRepr());
+            m_logger.info("Inlining call to '{}' ({}) inside global scope", inlinee.debugName(), inlinee.metadataRepr());
         else
-            m_logger.debug("Inlining call to '{}' ({}) inside '{}' @ {}", inlinee.debugName(), inlinee.metadataRepr(), destination.debugName(), destination.metadata.addr);
+            m_logger.info(
+                "Inlining call to '{}' ({} from '{}') inside '{}' @ {}, from '{}'",
+                inlinee.debugName(),
+                inlinee.metadataRepr(),
+                inlinee.data.front().filename(),
+                destination.debugName(),
+                destination.metadata.addr,
+                destination.data.front().filename());
 
         if (auto inst = isBuiltinProxy(inlinee); inst.has_value())
         {
-            m_logger.debug("  -> builtin proxy with args ({}, {})", inst->primaryArg(), inst->secondaryArg());
+            m_logger.info("  -> builtin proxy with args ({}, {})", inst->primaryArg(), inst->secondaryArg());
             destination.data.emplace_back(CALL_BUILTIN_WITHOUT_RETURN_ADDRESS, inst->primaryArg(), inst->secondaryArg());
             return;
         }

tests/unittests/Suites/LangSuite.cpp

@@ -7,58 +7,57 @@
 
 using namespace boost;
 
-ut::suite<"Lang"> lang_suite = [] {
+void testResource(Ark::State& state, const bool is_res, const std::string& path, const uint16_t features)
+{
     using namespace ut;
 
-    "[run arkscript unittests]"_test = [] {
-        Ark::State state({ lib_path, unittests_path });
+    try
+    {
+        const bool ok = mut(state).doFile(is_res ? getResourcePath(path) : path, features);
+        expect(ok) << fatal << "compilation failed";
+    }
+    catch (const Ark::CodeError&)
+    {
+        expect(false) << fatal << "encountered an exception while compiling";
+    }
+
+    Ark::VM vm(state);
+    should("return exit code 0") = [&] {
+        expect(mut(vm).run() == 0_i);
+    };
+
+    should("have no failures") = [&] {
+        const auto failure_count = mut(vm).operator[]("failure_count");
+        expect(failure_count.valueType() == Ark::ValueType::Number &&
+               failure_count.number() == 0.0)
+            << "failure_count = 0\n";
+    };
+}
 
-        try
-        {
-            const bool ok = mut(state).doFile(getResourcePath("LangSuite/unittests.ark"));
-            expect(ok) << fatal << "compilation failed";
-        }
-        catch (const Ark::CodeError&)
-        {
-            expect(false) << fatal << "encountered an exception while compiling";
-        }
+ut::suite<"Lang"> lang_suite = [] {
+    using namespace ut;
 
-        Ark::VM vm(state);
-        should("return exit code 0") = [&] {
-            expect(mut(vm).run() == 0_i);
+    "run arkscript unittests"_test = [] {
+        "without IR inliner"_test = [] {
+            Ark::State state({ lib_path, unittests_path });
+            testResource(state, /* is_res= */ true, "LangSuite/unittests.ark", Ark::DefaultFeatures & ~Ark::FeatureIRInliner);
         };
 
-        should("have no failures") = [&] {
-            const auto failure_count = mut(vm).operator[]("failure_count");
-            expect(failure_count.valueType() == Ark::ValueType::Number &&
-                   failure_count.number() == 0.0)
-                << "failure_count = 0\n";
+        "with IR inliner"_test = [] {
+            Ark::State state({ lib_path, unittests_path });
+            testResource(state, /* is_res= */ true, "LangSuite/unittests.ark", Ark::DefaultFeatures);
         };
     };
 
-    "[run arkscript stdlib unittests]"_test = [] {
-        Ark::State state({ lib_path });
-
-        try
-        {
-            const bool ok = mut(state).doFile(ARK_TESTS_ROOT "lib/std/tests/all.ark");
-            expect(ok) << fatal << "compilation failed";
-        }
-        catch (const Ark::CodeError&)
-        {
-            expect(false) << fatal << "encountered an exception while compiling";
-        }
-
-        Ark::VM vm(state);
-        should("return exit code 0") = [&] {
-            expect(mut(vm).run() == 0_i);
+    "run arkscript stdlib unittests"_test = [] {
+        "without IR inliner"_test = [] {
+            Ark::State state({ lib_path });
+            testResource(state, /* is_res= */ false, ARK_TESTS_ROOT "lib/std/tests/all.ark", Ark::DefaultFeatures & ~Ark::FeatureIRInliner);
         };
 
-        should("have no failures") = [&] {
-            const auto failure_count = mut(vm).operator[]("failure_count");
-            expect(failure_count.valueType() == Ark::ValueType::Number &&
-                   failure_count.number() == 0.0)
-                << "failure_count = 0\n";
+        "with IR inliner"_test = [] {
+            Ark::State state({ lib_path });
+            testResource(state, /* is_res= */ false, ARK_TESTS_ROOT "lib/std/tests/all.ark", Ark::DefaultFeatures);
         };
     };
 };