Implement hat predicates in Compiler

Author: adazem009

include/scratchcpp/compiler.h

@@ -49,7 +49,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         Target *target() const;
         std::shared_ptr<Block> block() const;
 
-        std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock);
+        std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock, bool isHatPredicate = false);
         void preoptimize();
 
         CompilerValue *addFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});

src/engine/compiler.cpp

@@ -44,7 +44,7 @@ std::shared_ptr<libscratchcpp::Block> Compiler::block() const
 }
 
 /*! Compiles the script starting with the given block. */
-std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBlock)
+std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBlock, bool isHatPredicate)
 {
     BlockPrototype *procedurePrototype = nullptr;
 
@@ -60,13 +60,32 @@ std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBl
         }
     }
 
-    impl->builder = impl->builderFactory->create(impl->ctx, procedurePrototype);
+    impl->builder = impl->builderFactory->create(impl->ctx, procedurePrototype, isHatPredicate);
     impl->substackTree.clear();
     impl->substackHit = false;
     impl->emptySubstack = false;
     impl->warp = false;
     impl->block = startBlock;
 
+    if (impl->block && isHatPredicate) {
+        auto f = impl->block->hatPredicateCompileFunction();
+
+        if (f) {
+            CompilerValue *ret = f(this);
+            assert(ret);
+
+            if (!ret)
+                std::cout << "warning: '" << impl->block->opcode() << "' hat predicate compile function doesn't return a valid value" << std::endl;
+        } else {
+            std::cout << "warning: unsupported hat predicate: " << impl->block->opcode() << std::endl;
+            impl->unsupportedBlocks.insert(impl->block->opcode());
+            addConstValue(false); // return false if unsupported
+        }
+
+        impl->block = nullptr;
+        return impl->builder->finalize();
+    }
+
     while (impl->block) {
         if (impl->block->compileFunction()) {
             assert(impl->customIfStatementCount == 0);

src/engine/internal/codebuilderfactory.cpp

@@ -13,10 +13,10 @@ std::shared_ptr<CodeBuilderFactory> CodeBuilderFactory::instance()
     return m_instance;
 }
 
-std::shared_ptr<ICodeBuilder> CodeBuilderFactory::create(CompilerContext *ctx, BlockPrototype *procedurePrototype) const
+std::shared_ptr<ICodeBuilder> CodeBuilderFactory::create(CompilerContext *ctx, BlockPrototype *procedurePrototype, bool isPredicate) const
 {
     assert(dynamic_cast<LLVMCompilerContext *>(ctx));
-    return std::make_shared<LLVMCodeBuilder>(static_cast<LLVMCompilerContext *>(ctx), procedurePrototype);
+    return std::make_shared<LLVMCodeBuilder>(static_cast<LLVMCompilerContext *>(ctx), procedurePrototype, isPredicate);
 }
 
 std::shared_ptr<CompilerContext> CodeBuilderFactory::createCtx(IEngine *engine, Target *target) const

src/engine/internal/codebuilderfactory.h

@@ -11,7 +11,7 @@ class CodeBuilderFactory : public ICodeBuilderFactory
 {
     public:
         static std::shared_ptr<CodeBuilderFactory> instance();
-        std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype) const override;
+        std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype, bool isPredicate) const override;
         std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target) const override;
 
     private:

src/engine/internal/icodebuilderfactory.h

@@ -18,7 +18,7 @@ class ICodeBuilderFactory
     public:
         virtual ~ICodeBuilderFactory() { }
 
-        virtual std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr) const = 0;
+        virtual std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr, bool isPredicate = false) const = 0;
         virtual std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target) const = 0;
 };
 

test/compiler/compiler_test.cpp

@@ -46,12 +46,12 @@ class CompilerTest : public testing::Test
             m_testVar.reset();
         }
 
-        void compile(Compiler *compiler, std::shared_ptr<Block> block, BlockPrototype *procedurePrototype = nullptr)
+        void compile(Compiler *compiler, std::shared_ptr<Block> block, BlockPrototype *procedurePrototype = nullptr, bool isHatPredicate = false)
         {
             ASSERT_EQ(compiler->block(), nullptr);
-            EXPECT_CALL(m_builderFactory, create(m_ctx.get(), procedurePrototype)).WillOnce(Return(m_builder));
+            EXPECT_CALL(m_builderFactory, create(m_ctx.get(), procedurePrototype, isHatPredicate)).WillOnce(Return(m_builder));
             EXPECT_CALL(*m_builder, finalize()).WillOnce(Return(m_code));
-            ASSERT_EQ(compiler->compile(block), m_code);
+            ASSERT_EQ(compiler->compile(block, isHatPredicate), m_code);
             ASSERT_EQ(compiler->block(), nullptr);
         }
 
@@ -1778,7 +1778,23 @@ TEST_F(CompilerTest, UnsupportedBlocks)
     EXPECT_CALL(*m_builder, addConstValue).WillRepeatedly(Return(nullptr));
     compile(m_compiler.get(), block1);
 
-    ASSERT_EQ(m_compiler->unsupportedBlocks(), std::unordered_set<std::string>({ "block1", "block2", "value_block1", "value_block3", "value_block5", "block4" }));
+    // Hat predicates
+    auto block5 = std::make_shared<Block>("b5", "block5");
+    compile(m_compiler.get(), block5, nullptr, true);
+
+    auto block6 = std::make_shared<Block>("b6", "block6");
+    block6->setCompileFunction([](Compiler *) -> CompilerValue * { return nullptr; });
+    compile(m_compiler.get(), block6, nullptr, true);
+
+    auto block7 = std::make_shared<Block>("b7", "block7");
+    CompilerConstant ret(Compiler::StaticType::Bool, Value(true));
+    block7->setCompileFunction([](Compiler *) -> CompilerValue * { return nullptr; });
+    block7->setHatPredicateCompileFunction([](Compiler *compiler) -> CompilerValue * { return compiler->addConstValue(true); });
+    EXPECT_CALL(*m_builder, addConstValue(Value(true))).WillOnce(Return(&ret));
+    compile(m_compiler.get(), block7, nullptr, true);
+
+    // Check
+    ASSERT_EQ(m_compiler->unsupportedBlocks(), std::unordered_set<std::string>({ "block1", "block2", "value_block1", "value_block3", "value_block5", "block4", "block5", "block6" }));
 }
 
 TEST_F(CompilerTest, Procedure)
@@ -1818,3 +1834,21 @@ TEST_F(CompilerTest, Preoptimize)
     EXPECT_CALL(*ctx, preoptimize());
     compiler.preoptimize();
 }
+
+TEST_F(CompilerTest, HatPredicate)
+{
+    auto block = std::make_shared<Block>("", "");
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * { return compiler->addConstValue(true); });
+    block->setHatPredicateCompileFunction([](Compiler *compiler) -> CompilerValue * { return compiler->addConstValue(false); });
+
+    CompilerConstant ret1(Compiler::StaticType::Bool, Value(true));
+    CompilerConstant ret2(Compiler::StaticType::Bool, Value(false));
+
+    // Script
+    EXPECT_CALL(*m_builder, addConstValue(Value(true))).WillOnce(Return(&ret1));
+    compile(m_compiler.get(), block, nullptr, false);
+
+    // Hat predicate
+    EXPECT_CALL(*m_builder, addConstValue(Value(false))).WillOnce(Return(&ret2));
+    compile(m_compiler.get(), block, nullptr, true);
+}

test/mocks/codebuilderfactorymock.h

@@ -8,6 +8,6 @@ using namespace libscratchcpp;
 class CodeBuilderFactoryMock : public ICodeBuilderFactory
 {
     public:
-        MOCK_METHOD(std::shared_ptr<ICodeBuilder>, create, (CompilerContext *, BlockPrototype *), (const, override));
+        MOCK_METHOD(std::shared_ptr<ICodeBuilder>, create, (CompilerContext *, BlockPrototype *, bool), (const, override));
         MOCK_METHOD(std::shared_ptr<CompilerContext>, createCtx, (IEngine *, Target *), (const, override));
 };