Drop broadcast block optimization

Author: adazem009

src/blocks/eventblocks.cpp

@@ -96,19 +96,8 @@ void EventBlocks::compileWhenStageClicked(Compiler *compiler)
 
 void EventBlocks::compileBroadcast(Compiler *compiler)
 {
-    auto input = compiler->input(BROADCAST_INPUT);
-
-    if (input->type() != Input::Type::ObscuredShadow) {
-        std::vector<int> broadcasts = compiler->engine()->findBroadcasts(input->primaryValue()->value().toString());
-
-        for (int index : broadcasts) {
-            compiler->addConstValue(index);
-            compiler->addFunctionCall(&broadcastByIndex);
-        }
-    } else {
-        compiler->addInput(input);
-        compiler->addFunctionCall(&broadcast);
-    }
+    compiler->addInput(BROADCAST_INPUT);
+    compiler->addFunctionCall(&broadcast);
 }
 
 void EventBlocks::compileBroadcastAndWait(Compiler *compiler)
@@ -197,12 +186,6 @@ unsigned int EventBlocks::broadcast(VirtualMachine *vm)
     return 1;
 }
 
-unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
-{
-    vm->engine()->broadcast(vm->getInput(0, 1)->toLong(), vm);
-    return 1;
-}
-
 unsigned int EventBlocks::broadcastAndWait(VirtualMachine *vm)
 {
     std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());

src/blocks/eventblocks.h

@@ -56,7 +56,6 @@ class EventBlocks : public IBlockSection
         static unsigned int whenTouchingObjectPredicate(VirtualMachine *vm);
 
         static unsigned int broadcast(VirtualMachine *vm);
-        static unsigned int broadcastByIndex(VirtualMachine *vm);
         static unsigned int broadcastAndWait(VirtualMachine *vm);
 
         static unsigned int whenLoudnessGreaterThanPredicate(VirtualMachine *vm);

test/blocks/event_blocks_test.cpp

@@ -373,9 +373,7 @@ TEST_F(EventBlocksTest, Broadcast)
     notBlock->setCompileFunction(&OperatorBlocks::compileNot);
     addObscuredInput(block2, "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT, notBlock);
 
-    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 0, 3 })));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndex)).Times(2).WillRepeatedly(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcast)).WillOnce(Return(1));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcast)).Times(2).WillRepeatedly(Return(0));
 
     compiler.init();
     compiler.setBlock(block1);
@@ -384,17 +382,16 @@ TEST_F(EventBlocksTest, Broadcast)
     EventBlocks::compileBroadcast(&compiler);
     compiler.end();
 
-    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 1, vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 0, 3 }));
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "test" }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
 
 TEST_F(EventBlocksTest, BroadcastImpl)
 {
     static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &EventBlocks::broadcast, &EventBlocks::broadcastByIndex };
+    static BlockFunc functions[] = { &EventBlocks::broadcast };
     static Value constValues[] = { "test", 2 };
 
     VirtualMachine vm(nullptr, &m_engineMock, nullptr);
@@ -409,13 +406,6 @@ TEST_F(EventBlocksTest, BroadcastImpl)
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-
-    EXPECT_CALL(m_engineMock, broadcast(2, &vm)).Times(1);
-
-    vm.setBytecode(bytecode2);
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
 }
 
 TEST_F(EventBlocksTest, BroadcastAndWait)