From c49913a6b1bb143212bbbe18b3bbe976bd01be0c Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <pair+mbrunsfeld@pivotallabs.com>
Date: Tue, 17 Dec 2013 19:54:16 -0800
Subject: [PATCH] Simplify item_set -> state index map data in parse table
 builder

---
 spec/compiler/lr/item_set_spec.cpp      |  4 ++--
 src/compiler/lr/item_set.h              |  2 +-
 src/compiler/lr/parse_table_builder.cpp | 18 +++++++++---------
 src/compiler/lr/parse_table_builder.h   | 12 ++----------
 4 files changed, 14 insertions(+), 22 deletions(-)

diff --git a/spec/compiler/lr/item_set_spec.cpp b/spec/compiler/lr/item_set_spec.cpp
index bfe468c3..76696d53 100644
--- a/spec/compiler/lr/item_set_spec.cpp
+++ b/spec/compiler/lr/item_set_spec.cpp
@@ -56,9 +56,9 @@ Describe(item_sets) {
     It(can_be_hashed) {
         ItemSet set1 = ItemSet(Item::at_beginning_of_rule("factor", grammar), grammar);
         ItemSet set2 = ItemSet(Item::at_beginning_of_rule("factor", grammar), grammar);
-        AssertThat(std::hash<ItemSet>()(set1), Equals(std::hash<ItemSet>()(set2)));
+        AssertThat(std::hash<const ItemSet>()(set1), Equals(std::hash<const ItemSet>()(set2)));
 
         ItemSet set3 = ItemSet(Item::at_beginning_of_rule("term", grammar), grammar);
-        AssertThat(std::hash<ItemSet>()(set1), !Equals(std::hash<ItemSet>()(set3)));
+        AssertThat(std::hash<const ItemSet>()(set1), !Equals(std::hash<const ItemSet>()(set3)));
     }
 };
diff --git a/src/compiler/lr/item_set.h b/src/compiler/lr/item_set.h
index c049f47b..43d580f4 100644
--- a/src/compiler/lr/item_set.h
+++ b/src/compiler/lr/item_set.h
@@ -35,7 +35,7 @@ namespace tree_sitter {
 
 namespace std {
     template<>
-    struct hash<tree_sitter::lr::ItemSet> {
+    struct hash<const tree_sitter::lr::ItemSet> {
         size_t operator()(const tree_sitter::lr::ItemSet &item_set) const {
             size_t result = hash<size_t>()(item_set.size());
             for (auto item : item_set)
diff --git a/src/compiler/lr/parse_table_builder.cpp b/src/compiler/lr/parse_table_builder.cpp
index d45726e2..c7734276 100644
--- a/src/compiler/lr/parse_table_builder.cpp
+++ b/src/compiler/lr/parse_table_builder.cpp
@@ -17,27 +17,27 @@ namespace tree_sitter {
         ParseTableBuilder::ParseTableBuilder(const Grammar &grammar) :
             grammar(grammar),
             table(ParseTable(grammar.rule_names())),
-            state_indices(unordered_map<size_t, size_t>()) {};
+            state_indices(unordered_map<const ItemSet, size_t>()) {};
 
         void ParseTableBuilder::build() {
             auto item = Item(ParseTable::START, rules::sym(grammar.start_rule_name), 0);
-            auto item_set = std::make_shared<ItemSet>(item, grammar);
+            auto item_set = ItemSet(item, grammar);
             add_item_set(item_set);
         }
         
-        size_t ParseTableBuilder::add_item_set(const shared_ptr<const ItemSet> item_set) {
-            auto state_index = state_index_for_item_set(*item_set);
+        size_t ParseTableBuilder::add_item_set(const ItemSet &item_set) {
+            auto state_index = state_index_for_item_set(item_set);
             if (state_index == NOT_FOUND) {
                 state_index = table.add_state();
-                state_indices[std::hash<ItemSet>()(*item_set)] = state_index;
+                state_indices[item_set] = state_index;
 
-                for (auto transition : item_set->sym_transitions(grammar)) {
+                for (auto transition : item_set.sym_transitions(grammar)) {
                     rules::sym_ptr symbol = static_pointer_cast<const rules::Symbol>(transition.first);
-                    size_t new_state_index = add_item_set(transition.second);
+                    size_t new_state_index = add_item_set(*transition.second);
                     table.add_action(state_index, symbol->name, ParseAction::Shift(new_state_index));
                 }
                 
-                for (Item item : *item_set) {
+                for (Item item : item_set) {
                     if (item.is_done()) {
                         if (item.rule_name == ParseTable::START) {
                             table.add_action(state_index, ParseTable::END_OF_INPUT, ParseAction::Accept());
@@ -52,7 +52,7 @@ namespace tree_sitter {
         }
         
         long ParseTableBuilder::state_index_for_item_set(const ItemSet &item_set) const {
-            auto entry = state_indices.find(std::hash<ItemSet>()(item_set));
+            auto entry = state_indices.find(item_set);
             return (entry == state_indices.end()) ? NOT_FOUND : entry->second;
         }
     }
diff --git a/src/compiler/lr/parse_table_builder.h b/src/compiler/lr/parse_table_builder.h
index a2d24ca9..88bca265 100644
--- a/src/compiler/lr/parse_table_builder.h
+++ b/src/compiler/lr/parse_table_builder.h
@@ -8,20 +8,12 @@
 
 namespace tree_sitter {
     namespace lr {
-        class ItemSet;
-
-        struct ItemSetPointerHasher {
-            std::size_t operator()(const std::shared_ptr<const ItemSet> &item_set) const {
-                return std::hash<ItemSet>()(*item_set);
-            }
-        };
-        
         class ParseTableBuilder {
             const Grammar grammar;
             ParseTable table;
-            std::unordered_map<size_t, size_t> state_indices;
+            std::unordered_map<const ItemSet, size_t> state_indices;
 
-            size_t add_item_set(const std::shared_ptr<const ItemSet> item_set);
+            size_t add_item_set(const ItemSet &item_set);
             long state_index_for_item_set(const ItemSet &item_set) const;
         public:
             ParseTableBuilder(const Grammar &grammar);