Merge "Added methods to serialize/deserialize into/from words" am: d52c84b5a7 am: 0f3b23b0e7

am: eafdb925b1

Change-Id: I7b7684dd196b326815b9aba495d27d24f6e8d765

13 files changed, 56 insertions, 112 deletions

diff --git a/rsov/compiler/Builtin_test.cpp b/rsov/compiler/Builtin_test.cpp
index c180add9..256703bb 100644
--- a/rsov/compiler/Builtin_test.cpp
+++ b/rsov/compiler/Builtin_test.cpp
@@ -36,9 +36,7 @@ TEST(BuiltinTest, testBuiltinTranslation) {
   passes.append(rs2spirv::CreateBuiltinPass());
   auto words1 = passes.run(words);
 
-  std::unique_ptr<InputWordStream> IS1(
-      InputWordStream::Create(std::move(words1)));
-  std::unique_ptr<Module> m1(Deserialize<Module>(*IS1));
+  std::unique_ptr<Module> m1(Deserialize<Module>(words1));
 
   ASSERT_NE(nullptr, m1);
 }
diff --git a/rsov/compiler/Wrapper.cpp b/rsov/compiler/Wrapper.cpp
index 66a00fc1..77a78067 100644
--- a/rsov/compiler/Wrapper.cpp
+++ b/rsov/compiler/Wrapper.cpp
@@ -26,7 +26,6 @@
 #include "instructions.h"
 #include "module.h"
 #include "pass.h"
-#include "word_stream.h"
 
 #include <vector>
 
diff --git a/rsov/compiler/Wrapper_test.cpp b/rsov/compiler/Wrapper_test.cpp
index 73a84654..1be643a1 100644
--- a/rsov/compiler/Wrapper_test.cpp
+++ b/rsov/compiler/Wrapper_test.cpp
@@ -21,7 +21,6 @@
 #include "instructions.h"
 #include "module.h"
 #include "test_utils.h"
-#include "word_stream.h"
 #include "gtest/gtest.h"
 
 namespace android {
@@ -63,8 +62,7 @@ TEST_F(WrapperTest, testAddBuffer) {
 }
 
 TEST_F(WrapperTest, testAddWrapper1) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -85,8 +83,7 @@ TEST_F(WrapperTest, testAddWrapper1) {
 }
 
 TEST_F(WrapperTest, testAddWrapper2) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsInvert));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsInvert));
 
   ASSERT_NE(nullptr, m);
 
@@ -105,8 +102,7 @@ TEST_F(WrapperTest, testAddWrapper2) {
 }
 
 TEST_F(WrapperTest, testAddWrapperForRoot) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsInvert));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsInvert));
 
   ASSERT_NE(nullptr, m);
 
diff --git a/rsov/compiler/spirit/builder_test.cpp b/rsov/compiler/spirit/builder_test.cpp
index 111bddb1..48030aeb 100644
--- a/rsov/compiler/spirit/builder_test.cpp
+++ b/rsov/compiler/spirit/builder_test.cpp
@@ -20,7 +20,6 @@
 #include "instructions.h"
 #include "module.h"
 #include "test_utils.h"
-#include "word_stream.h"
 #include "gtest/gtest.h"
 
 namespace android {
@@ -182,17 +181,12 @@ TEST(BuilderTest, testBuildAndSerialize) {
 
   m->consolidateAnnotations();
 
-  std::unique_ptr<WordStream> S(WordStream::Create());
-  m->Serialize(*S);
-  auto words = S->getWords();
+  auto words = Serialize<Module>(m);
 
-  std::unique_ptr<InputWordStream> S1(InputWordStream::Create(words));
-  auto m1 = Deserialize<Module>(*S1);
+  auto m1 = Deserialize<Module>(words);
   ASSERT_NE(nullptr, m1);
 
-  std::unique_ptr<WordStream> S2(WordStream::Create());
-  m1->Serialize(*S2);
-  auto words1 = S2->getWords();
+  auto words1 = Serialize<Module>(m1);
 
   EXPECT_TRUE(words == words1);
 }
@@ -202,9 +196,7 @@ TEST(BuilderTest, testLoadAndModify) {
       "frameworks/rs/rsov/compiler/spirit/test_data/");
   const std::string &fullPath = getAbsolutePath(testDataPath + "greyscale.spv");
 
-  std::unique_ptr<InputWordStream> IS(
-      InputWordStream::Create(fullPath.c_str()));
-  Module *m = Deserialize<Module>(*IS);
+  Module *m = Deserialize<Module>(readFile<uint32_t>(fullPath.c_str()));
 
   ASSERT_NE(nullptr, m);
 
@@ -227,17 +219,12 @@ TEST(BuilderTest, testLoadAndModify) {
 
   m->consolidateAnnotations();
 
-  std::unique_ptr<OutputWordStream> S(OutputWordStream::Create());
-  m->Serialize(*S);
-  auto words = S->getWords();
+  auto words = Serialize<Module>(m);
 
-  std::unique_ptr<InputWordStream> S1(InputWordStream::Create(words));
-  auto m1 = Deserialize<Module>(*S1);
+  auto m1 = Deserialize<Module>(words);
   ASSERT_NE(nullptr, m1);
 
-  std::unique_ptr<OutputWordStream> S2(OutputWordStream::Create());
-  m1->Serialize(*S2);
-  auto words1 = S2->getWords();
+  auto words1 = Serialize<Module>(m1);
 
   EXPECT_TRUE(words == words1);
 }
diff --git a/rsov/compiler/spirit/entity.h b/rsov/compiler/spirit/entity.h
index f6587a93..33c112b4 100644
--- a/rsov/compiler/spirit/entity.h
+++ b/rsov/compiler/spirit/entity.h
@@ -20,13 +20,13 @@
 #include <memory>
 #include <vector>
 
+#include "word_stream.h"
+
 namespace android {
 namespace spirit {
 
 class Builder;
-class InputWordStream;
 class IVisitor;
-class OutputWordStream;
 
 class Entity {
 public:
@@ -54,6 +54,11 @@ template <typename T> T *Deserialize(InputWordStream &IS) {
   return entity.release();
 }
 
+template <typename T> T *Deserialize(const std::vector<uint32_t> &words) {
+  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(words));
+  return Deserialize<T>(*IS);
+}
+
 template <class T>
 void DeserializeZeroOrMore(InputWordStream &IS, std::vector<T *> &all) {
   while (auto entity = Deserialize<T>(IS)) {
@@ -61,6 +66,13 @@ void DeserializeZeroOrMore(InputWordStream &IS, std::vector<T *> &all) {
   }
 }
 
+template <class T>
+std::vector<uint32_t> Serialize(T* e) {
+  std::unique_ptr<OutputWordStream> OS(OutputWordStream::Create());
+  e->Serialize(*OS);
+  return OS->getWords();
+}
+
 } // namespace spirit
 } // namespace android
 
diff --git a/rsov/compiler/spirit/instructions_test.cpp b/rsov/compiler/spirit/instructions_test.cpp
index 7b089caa..ce4325e9 100644
--- a/rsov/compiler/spirit/instructions_test.cpp
+++ b/rsov/compiler/spirit/instructions_test.cpp
@@ -16,7 +16,6 @@
 
 #include "instructions.h"
 
-#include "word_stream.h"
 #include "gtest/gtest.h"
 
 #include <memory>
@@ -27,8 +26,7 @@ namespace spirit {
 
 TEST(InstructionTest, testOpCapability) {
   std::vector<uint32_t> words = {0x00020011, 0x00000001};
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(words));
-  auto *i = Deserialize<CapabilityInst>(*IS);
+  auto *i = Deserialize<CapabilityInst>(words);
   EXPECT_NE(nullptr, i);
 }
 
@@ -37,8 +35,7 @@ TEST(InstructionTest, testOpExtension) {
                      0x43, 0x44, 0x45, 0x46, 'G',  0x00};
   std::vector<uint32_t> words((uint32_t *)bytes,
                               (uint32_t *)(bytes + sizeof(bytes)));
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(words));
-  auto *i = Deserialize<ExtensionInst>(*IS);
+  auto *i = Deserialize<ExtensionInst>(words);
   ASSERT_NE(nullptr, i);
   EXPECT_STREQ("ABCDEFG", i->mOperand1.c_str());
 }
@@ -49,8 +46,7 @@ TEST(InstructionTest, testOpExtInstImport) {
                      0x2e, 0x34, 0x35, 0x30, 0x00, 0x00, 0x00, 0x00};
   std::vector<uint32_t> words((uint32_t *)bytes,
                               (uint32_t *)(bytes + sizeof(bytes)));
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(words));
-  auto *i = Deserialize<ExtInstImportInst>(*IS);
+  auto *i = Deserialize<ExtInstImportInst>(words);
   ASSERT_NE(nullptr, i);
   EXPECT_STREQ("GLSL.std.450", i->mOperand1.c_str());
 }
diff --git a/rsov/compiler/spirit/module_test.cpp b/rsov/compiler/spirit/module_test.cpp
index f24268fa..20b342ce 100644
--- a/rsov/compiler/spirit/module_test.cpp
+++ b/rsov/compiler/spirit/module_test.cpp
@@ -19,7 +19,6 @@
 #include "file_utils.h"
 #include "instructions.h"
 #include "test_utils.h"
-#include "word_stream.h"
 #include "gtest/gtest.h"
 
 #include <fstream>
@@ -50,8 +49,7 @@ private:
 };
 
 TEST_F(ModuleTest, testDeserialization1) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  auto m = Deserialize<Module>(*IS);
+  auto m = Deserialize<Module>(mWordsGreyscale);
 
   ASSERT_NE(nullptr, m);
 
@@ -115,55 +113,44 @@ TEST_F(ModuleTest, testDeserialization1) {
 }
 
 TEST_F(ModuleTest, testDeserialization2) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsInvert));
-  Module *m = Deserialize<Module>(*IS);
+  Module *m = Deserialize<Module>(mWordsInvert);
   ASSERT_NE(nullptr, m);
 
   std::unique_ptr<Module> mDeleter(m);
 
-  std::unique_ptr<OutputWordStream> OS(OutputWordStream::Create());
-  m->Serialize(*OS);
-  auto outwords = OS->getWords();
+  auto outwords = Serialize<Module>(m);
 
   EXPECT_TRUE(mWordsInvert == outwords);
 }
 
 TEST_F(ModuleTest, testSerialization1) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  Module *m = Deserialize<Module>(*IS);
+  Module *m = Deserialize<Module>(mWordsGreyscale);
   ASSERT_NE(nullptr, m);
 
   std::unique_ptr<Module> mDeleter(m);
 
   EXPECT_EQ(2, countEntity<FunctionDefinition>(m));
 
-  std::unique_ptr<OutputWordStream> OS(OutputWordStream::Create());
-  m->Serialize(*OS);
-  auto outwords = OS->getWords();
+  auto outwords = Serialize<Module>(m);
 
   EXPECT_TRUE(mWordsGreyscale == outwords);
 }
 
 TEST_F(ModuleTest, testSerialization2) {
-  std::unique_ptr<InputWordStream> IS(
-      InputWordStream::Create(mWordsGreyscale2));
-  Module *m = Deserialize<Module>(*IS);
+  Module *m = Deserialize<Module>(mWordsGreyscale2);
   ASSERT_NE(nullptr, m);
 
   std::unique_ptr<Module> mDeleter(m);
 
   EXPECT_EQ(1, countEntity<FunctionDefinition>(m));
 
-  std::unique_ptr<OutputWordStream> OS(OutputWordStream::Create());
-  m->Serialize(*OS);
-  auto outwords = OS->getWords();
+  auto outwords = Serialize<Module>(m);
 
   EXPECT_TRUE(mWordsGreyscale2 == outwords);
 }
 
 TEST_F(ModuleTest, testLookupByName) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  Module *m = Deserialize<Module>(*IS);
+  Module *m = Deserialize<Module>(mWordsGreyscale);
 
   ASSERT_NE(nullptr, m);
 
diff --git a/rsov/compiler/spirit/pass.cpp b/rsov/compiler/spirit/pass.cpp
index 6653f96c..d8c3afe1 100644
--- a/rsov/compiler/spirit/pass.cpp
+++ b/rsov/compiler/spirit/pass.cpp
@@ -17,7 +17,6 @@
 #include "pass.h"
 
 #include "module.h"
-#include "word_stream.h"
 
 namespace android {
 namespace spirit {
@@ -31,8 +30,7 @@ Module *Pass::run(Module *module, int *error) {
     }
     return nullptr;
   }
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(words));
-  return Deserialize<Module>(*IS);
+  return Deserialize<Module>(words);
 }
 
 std::vector<uint32_t> Pass::runAndSerialize(Module *module, int *error) {
@@ -44,9 +42,7 @@ std::vector<uint32_t> Pass::runAndSerialize(Module *module, int *error) {
     }
     return std::vector<uint32_t>();
   }
-  std::unique_ptr<OutputWordStream> OS(OutputWordStream::Create());
-  m1->Serialize(*OS);
-  return OS->getWords();
+  return Serialize<Module>(m1);
 }
 
 } // namespace spirit
diff --git a/rsov/compiler/spirit/pass_queue.cpp b/rsov/compiler/spirit/pass_queue.cpp
index 0a37e0a0..1bbdd2c2 100644
--- a/rsov/compiler/spirit/pass_queue.cpp
+++ b/rsov/compiler/spirit/pass_queue.cpp
@@ -17,7 +17,6 @@
 #include "pass_queue.h"
 
 #include "module.h"
-#include "word_stream.h"
 
 namespace android {
 namespace spirit {
@@ -72,9 +71,7 @@ std::vector<uint32_t> PassQueue::run(const std::vector<uint32_t> &spirvWords,
     return spirvWords;
   }
 
-  std::unique_ptr<InputWordStream> IS(
-      InputWordStream::Create(std::move(spirvWords)));
-  Module *module = Deserialize<Module>(*IS);
+  Module *module = Deserialize<Module>(spirvWords);
   if (!module || !module->resolveIds()) {
     return std::vector<uint32_t>();
   }
@@ -85,9 +82,7 @@ std::vector<uint32_t> PassQueue::run(const std::vector<uint32_t> &spirvWords,
 std::vector<uint32_t> PassQueue::runAndSerialize(Module *module, int *error) {
   const int n = mPasses.size();
   if (n < 1) {
-    std::unique_ptr<OutputWordStream> OS(OutputWordStream::Create());
-    module->Serialize(*OS);
-    return OS->getWords();
+    return Serialize<Module>(module);
   }
 
   // A unique ptr to keep intermediate modules from leaking
diff --git a/rsov/compiler/spirit/pass_queue_test.cpp b/rsov/compiler/spirit/pass_queue_test.cpp
index 0e7c183f..23e18e25 100644
--- a/rsov/compiler/spirit/pass_queue_test.cpp
+++ b/rsov/compiler/spirit/pass_queue_test.cpp
@@ -20,7 +20,6 @@
 #include "spirit.h"
 #include "test_utils.h"
 #include "transformer.h"
-#include "word_stream.h"
 #include "gtest/gtest.h"
 
 #include <stdint.h>
@@ -92,8 +91,7 @@ private:
 };
 
 TEST_F(PassQueueTest, testMulToAdd) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -113,8 +111,7 @@ TEST_F(PassQueueTest, testMulToAdd) {
 }
 
 TEST_F(PassQueueTest, testInPlaceModifying) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -136,8 +133,7 @@ TEST_F(PassQueueTest, testInPlaceModifying) {
 }
 
 TEST_F(PassQueueTest, testDeletion) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m.get());
 
@@ -152,8 +148,7 @@ TEST_F(PassQueueTest, testDeletion) {
 }
 
 TEST_F(PassQueueTest, testMulToAddToDiv) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -175,8 +170,7 @@ TEST_F(PassQueueTest, testMulToAddToDiv) {
 }
 
 TEST_F(PassQueueTest, testAMix) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -203,8 +197,7 @@ TEST_F(PassQueueTest, testAMix) {
 }
 
 TEST_F(PassQueueTest, testAnotherMix) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -219,8 +212,7 @@ TEST_F(PassQueueTest, testAnotherMix) {
   passes.append(new AddToDivTransformer());
   auto outputWords = passes.runAndSerialize(m.get());
 
-  std::unique_ptr<InputWordStream> IS1(InputWordStream::Create(outputWords));
-  std::unique_ptr<Module> m1(Deserialize<Module>(*IS1));
+  std::unique_ptr<Module> m1(Deserialize<Module>(outputWords));
 
   ASSERT_NE(nullptr, m1);
 
@@ -238,8 +230,7 @@ TEST_F(PassQueueTest, testMulToAddToDivFromWords) {
   passes.append(new AddToDivTransformer());
   auto outputWords = passes.run(std::move(mWordsGreyscale));
 
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(outputWords));
-  std::unique_ptr<Module> m1(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m1(Deserialize<Module>(outputWords));
 
   ASSERT_NE(nullptr, m1);
 
@@ -251,8 +242,7 @@ TEST_F(PassQueueTest, testMulToAddToDivFromWords) {
 }
 
 TEST_F(PassQueueTest, testMulToAddToDivToWords) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -264,8 +254,7 @@ TEST_F(PassQueueTest, testMulToAddToDivToWords) {
   passes.append(new AddToDivTransformer());
   auto outputWords = passes.runAndSerialize(m.get());
 
-  std::unique_ptr<InputWordStream> IS1(InputWordStream::Create(outputWords));
-  std::unique_ptr<Module> m1(Deserialize<Module>(*IS1));
+  std::unique_ptr<Module> m1(Deserialize<Module>(outputWords));
 
   ASSERT_NE(nullptr, m1);
 
@@ -277,8 +266,7 @@ TEST_F(PassQueueTest, testMulToAddToDivToWords) {
 }
 
 TEST_F(PassQueueTest, testAddMulAfterAdd) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -293,8 +281,7 @@ TEST_F(PassQueueTest, testAddMulAfterAdd) {
   }
   auto outputWords = passes.runAndSerialize(m.get());
 
-  std::unique_ptr<InputWordStream> IS1(InputWordStream::Create(outputWords));
-  std::unique_ptr<Module> m1(Deserialize<Module>(*IS1));
+  std::unique_ptr<Module> m1(Deserialize<Module>(outputWords));
 
   ASSERT_NE(nullptr, m1);
 
diff --git a/rsov/compiler/spirit/transformer.cpp b/rsov/compiler/spirit/transformer.cpp
index 4d2ab1f4..0eb96213 100644
--- a/rsov/compiler/spirit/transformer.cpp
+++ b/rsov/compiler/spirit/transformer.cpp
@@ -23,8 +23,7 @@ namespace spirit {
 
 Module *Transformer::run(Module *module, int *error) {
   auto words = runAndSerialize(module, error);
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(words));
-  return Deserialize<Module>(*IS);
+  return Deserialize<Module>(words);
 }
 
 std::vector<uint32_t> Transformer::runAndSerialize(Module *m, int *error) {
diff --git a/rsov/compiler/spirit/transformer_test.cpp b/rsov/compiler/spirit/transformer_test.cpp
index e5f39a60..a78969f5 100644
--- a/rsov/compiler/spirit/transformer_test.cpp
+++ b/rsov/compiler/spirit/transformer_test.cpp
@@ -19,7 +19,6 @@
 #include "file_utils.h"
 #include "spirit.h"
 #include "test_utils.h"
-#include "word_stream.h"
 #include "gtest/gtest.h"
 
 #include <stdint.h>
@@ -77,8 +76,7 @@ private:
 };
 
 TEST_F(TransformerTest, testMulToAdd) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m);
 
@@ -97,8 +95,7 @@ TEST_F(TransformerTest, testMulToAdd) {
 }
 
 TEST_F(TransformerTest, testDeletion) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m.get());
 
@@ -114,8 +111,7 @@ TEST_F(TransformerTest, testDeletion) {
 }
 
 TEST_F(TransformerTest, testAddInstructionUsingNewDataType) {
-  std::unique_ptr<InputWordStream> IS(InputWordStream::Create(mWordsGreyscale));
-  std::unique_ptr<Module> m(Deserialize<Module>(*IS));
+  std::unique_ptr<Module> m(Deserialize<Module>(mWordsGreyscale));
 
   ASSERT_NE(nullptr, m.get());
 
diff --git a/rsov/compiler/spirit/word_stream.h b/rsov/compiler/spirit/word_stream.h
index 0c740def..94333bbc 100644
--- a/rsov/compiler/spirit/word_stream.h
+++ b/rsov/compiler/spirit/word_stream.h
@@ -28,9 +28,6 @@
 namespace android {
 namespace spirit {
 
-// TODO: this constant might be too small
-constexpr uint32_t MAXIMUM_STRING_LITERAL_LENGTH = 256;
-
 struct IdRef;
 class Instruction;
 
@@ -111,7 +108,6 @@ public:
 
   OutputWordStream &operator<<(const IdRef &RHS) {
     return *this << RHS.mId;
-    ;
   }
 
   OutputWordStream &operator<<(const PairLiteralIntegerIdRef &RHS) {