Add unsafeConstants parameter to CompileContext

Author: adazem009

include/scratchcpp/compilercontext.h

@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <unordered_set>
+
 #include "global.h"
 #include "spimpl.h"
 
@@ -16,7 +18,7 @@ class CompilerContextPrivate;
 class LIBSCRATCHCPP_EXPORT CompilerContext
 {
     public:
-        CompilerContext(IEngine *engine, Target *target);
+        CompilerContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants = {});
         CompilerContext(const CompilerContext &) = delete;
         virtual ~CompilerContext() { }
 

src/engine/compilercontext.cpp

@@ -7,8 +7,8 @@
 using namespace libscratchcpp;
 
 /*! Constructs CompilerContext. */
-CompilerContext::CompilerContext(IEngine *engine, Target *target) :
-    impl(spimpl::make_unique_impl<CompilerContextPrivate>(engine, target))
+CompilerContext::CompilerContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) :
+    impl(spimpl::make_unique_impl<CompilerContextPrivate>(engine, target, unsafeConstants))
 {
 }
 

src/engine/compilercontext_p.cpp

@@ -4,8 +4,9 @@
 
 using namespace libscratchcpp;
 
-CompilerContextPrivate::CompilerContextPrivate(IEngine *engine, Target *target) :
+CompilerContextPrivate::CompilerContextPrivate(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) :
     engine(engine),
-    target(target)
+    target(target),
+    unsafeConstants(unsafeConstants)
 {
 }

src/engine/compilercontext_p.h

@@ -2,6 +2,9 @@
 
 #pragma once
 
+#include <unordered_set>
+#include <string>
+
 namespace libscratchcpp
 {
 
@@ -10,10 +13,11 @@ class Target;
 
 struct CompilerContextPrivate
 {
-        CompilerContextPrivate(IEngine *engine, Target *target);
+        CompilerContextPrivate(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants);
 
         IEngine *engine = nullptr;
         Target *target = nullptr;
+        const std::unordered_set<std::string> unsafeConstants;
 };
 
 } // namespace libscratchcpp

src/engine/internal/codegen/codebuilderfactory.cpp

@@ -19,8 +19,8 @@ std::shared_ptr<ICodeBuilder> CodeBuilderFactory::create(CompilerContext *ctx, B
     return std::make_shared<LLVMCodeBuilder>(static_cast<LLVMCompilerContext *>(ctx), procedurePrototype, codeType);
 }
 
-std::shared_ptr<CompilerContext> CodeBuilderFactory::createCtx(IEngine *engine, Target *target) const
+std::shared_ptr<CompilerContext> CodeBuilderFactory::createCtx(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) const
 {
-    auto ptr = std::make_shared<LLVMCompilerContext>(engine, target);
+    auto ptr = std::make_shared<LLVMCompilerContext>(engine, target, unsafeConstants);
     return ptr;
 }

src/engine/internal/codegen/codebuilderfactory.h

@@ -13,7 +13,7 @@ class LIBSCRATCHCPP_TEST_EXPORT CodeBuilderFactory : public ICodeBuilderFactory
     public:
         static std::shared_ptr<CodeBuilderFactory> instance();
         std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype, Compiler::CodeType codeType) const override;
-        std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target) const override;
+        std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants = {}) const override;
 
     private:
         static std::shared_ptr<CodeBuilderFactory> m_instance;

src/engine/internal/codegen/icodebuilderfactory.h

@@ -16,7 +16,7 @@ class ICodeBuilderFactory
         virtual ~ICodeBuilderFactory() { }
 
         virtual std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr, Compiler::CodeType codeType = Compiler::CodeType::Script) const = 0;
-        virtual std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target) const = 0;
+        virtual std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants = {}) const = 0;
 };
 
 } // namespace libscratchcpp

src/engine/internal/codegen/llvm/llvmcompilercontext.cpp

@@ -17,8 +17,8 @@
 
 using namespace libscratchcpp;
 
-LLVMCompilerContext::LLVMCompilerContext(IEngine *engine, Target *target) :
-    CompilerContext(engine, target),
+LLVMCompilerContext::LLVMCompilerContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) :
+    CompilerContext(engine, target, unsafeConstants),
     m_llvmCtx(std::make_unique<llvm::LLVMContext>()),
     m_module(std::make_unique<llvm::Module>(target ? target->name() : "", *m_llvmCtx)),
     m_llvmCtxPtr(m_llvmCtx.get()),

src/engine/internal/codegen/llvm/llvmcompilercontext.h

@@ -28,7 +28,7 @@ using function_id_t = unsigned int;
 class LIBSCRATCHCPP_TEST_EXPORT LLVMCompilerContext : public CompilerContext
 {
     public:
-        LLVMCompilerContext(IEngine *engine, Target *target);
+        LLVMCompilerContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants = {});
 
         void preoptimize() override;
 

test/compiler/compiler_test.cpp

@@ -31,7 +31,7 @@ class CompilerTest : public testing::Test
             m_ctx = std::make_shared<CompilerContext>(&m_engine, &m_target);
             CompilerPrivate::setBuilderFactory(&m_builderFactory);
 
-            EXPECT_CALL(m_builderFactory, createCtx(&m_engine, &m_target)).WillOnce(Return(m_ctx));
+            EXPECT_CALL(m_builderFactory, createCtx(&m_engine, &m_target, _)).WillOnce(Return(m_ctx));
             m_compiler = std::make_unique<Compiler>(&m_engine, &m_target);
 
             m_builder = std::make_shared<CodeBuilderMock>();
@@ -1873,7 +1873,7 @@ TEST_F(CompilerTest, Preoptimize)
 {
     auto ctx = std::make_shared<CompilerContextMock>(&m_engine, &m_target);
 
-    EXPECT_CALL(m_builderFactory, createCtx(&m_engine, &m_target)).WillOnce(Return(ctx));
+    EXPECT_CALL(m_builderFactory, createCtx(&m_engine, &m_target, _)).WillOnce(Return(ctx));
     Compiler compiler(&m_engine, &m_target);
 
     EXPECT_CALL(*ctx, preoptimize());