Symbol -> NamedSymbol

spec/compiler/prepare_grammar/expand_repeats_spec.cc

@@ -1,7 +1,6 @@
 #include "compiler_spec_helper.h"
 #include "compiler/prepared_grammar.h"
 #include "compiler/prepare_grammar/expand_repeats.h"
-#include "compiler/rules/symbol.h"
 
 START_TEST
 

spec/compiler/prepare_grammar/extract_tokens_spec.cc

@@ -1,7 +1,6 @@
 #include "compiler_spec_helper.h"
 #include "compiler/prepared_grammar.h"
 #include "compiler/prepare_grammar/extract_tokens.h"
-#include "compiler/rules/symbol.h"
 
 START_TEST
 

spec/compiler/prepare_grammar/intern_symbols_spec.cc

@@ -1,7 +1,7 @@
 #include "compiler_spec_helper.h"
 #include "compiler/prepared_grammar.h"
 #include "compiler/prepare_grammar/intern_symbols.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/named_symbol.h"
 #include "compiler/rules/interned_symbol.h"
 
 START_TEST

src/compiler/build_tables/conflict_manager.cc

@@ -7,7 +7,6 @@
 
 namespace tree_sitter {
     namespace build_tables {
-        using rules::Symbol;
         using std::string;
         using std::to_string;
         using std::map;

src/compiler/build_tables/first_set.h

@@ -3,7 +3,7 @@
 
 #include <set>
 #include "compiler/build_tables/parse_item.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/interned_symbol.h"
 
 namespace tree_sitter {
     class PreparedGrammar;

src/compiler/build_tables/follow_sets.h

@@ -4,7 +4,7 @@
 #include <set>
 #include <map>
 #include "compiler/build_tables/parse_item.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/interned_symbol.h"
 
 namespace tree_sitter {
     class PreparedGrammar;

src/compiler/build_tables/lex_item.cc

@@ -1,6 +1,6 @@
 #include "compiler/build_tables/lex_item.h"
 #include "compiler/build_tables/rule_can_be_blank.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/interned_symbol.h"
 #include "compiler/rules/metadata.h"
 #include "compiler/rules/seq.h"
 #include "compiler/rules/visitor.h"

src/compiler/build_tables/rule_can_be_blank.cc

@@ -2,7 +2,7 @@
 #include <set>
 #include "tree_sitter/compiler.h"
 #include "compiler/prepared_grammar.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/interned_symbol.h"
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/seq.h"
 #include "compiler/rules/choice.h"

src/compiler/prepare_grammar/expand_repeats.cc

@@ -5,7 +5,7 @@
 #include "compiler/prepared_grammar.h"
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/seq.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/interned_symbol.h"
 #include "compiler/rules/choice.h"
 #include "compiler/rules/blank.h"
 #include "compiler/rules/repeat.h"

src/compiler/prepare_grammar/extract_tokens.cc

@@ -9,7 +9,7 @@
 #include "compiler/rules/choice.h"
 #include "compiler/rules/repeat.h"
 #include "compiler/rules/blank.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/interned_symbol.h"
 #include "compiler/rules/string.h"
 #include "compiler/rules/pattern.h"
 

src/compiler/prepare_grammar/intern_symbols.cc

@@ -3,7 +3,7 @@
 #include "tree_sitter/compiler.h"
 #include "compiler/prepared_grammar.h"
 #include "compiler/rules/visitor.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/named_symbol.h"
 #include "compiler/rules/interned_symbol.h"
 
 namespace tree_sitter {
@@ -32,7 +32,7 @@ namespace tree_sitter {
                 return -1;
             }
 
-            rule_ptr apply_to(const rules::Symbol *rule)  {
+            rule_ptr apply_to(const rules::NamedSymbol *rule)  {
                 long index = index_of(rule->name);
                 if (index == -1)
                     missing_rule_name = rule->name;

src/compiler/rules/interned_symbol.h

@@ -1,7 +1,7 @@
 #ifndef COMPILER_RULES_INTERNED_SYMBOL_H_
 #define COMPILER_RULES_INTERNED_SYMBOL_H_
 
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/rule.h"
 
 namespace tree_sitter  {
     namespace rules {

src/compiler/rules/named_symbol.cc

@@ -0,0 +1,33 @@
+#include "compiler/rules/named_symbol.h"
+#include <string>
+#include "compiler/rules/visitor.h"
+
+namespace tree_sitter  {
+    using std::string;
+    using std::hash;
+
+    namespace rules {
+        NamedSymbol::NamedSymbol(const std::string &name) : name(name) {}
+
+        bool NamedSymbol::operator==(const Rule &rule) const {
+            auto other = dynamic_cast<const NamedSymbol *>(&rule);
+            return other && other->name == name;
+        }
+
+        size_t NamedSymbol::hash_code() const {
+            return hash<string>()(name);
+        }
+
+        rule_ptr NamedSymbol::copy() const {
+            return std::make_shared<NamedSymbol>(*this);
+        }
+
+        string NamedSymbol::to_string() const {
+            return string("#<sym '") + name + "'>";
+        }
+
+        void NamedSymbol::accept(Visitor *visitor) const {
+            visitor->visit(this);
+        }
+    }
+}

src/compiler/rules/named_symbol.h

@@ -7,31 +7,19 @@
 
 namespace tree_sitter  {
     namespace rules {
-        class Symbol : public Rule {
+        class NamedSymbol : public Rule {
         public:
-            explicit Symbol(const std::string &name);
+            explicit NamedSymbol(const std::string &name);
 
             bool operator==(const Rule& other) const;
-            bool operator==(const Symbol &other) const;
-
             size_t hash_code() const;
             rule_ptr copy() const;
             std::string to_string() const;
             void accept(Visitor *visitor) const;
-            bool operator<(const Symbol &other) const;
 
             std::string name;
         };
     }
 }
 
-namespace std {
-    template<>
-    struct hash<tree_sitter::rules::Symbol> {
-        size_t operator()(const tree_sitter::rules::Symbol &rule) const {
-            return rule.hash_code();
-        }
-    };
-}
-
 #endif  // COMPILER_RULES_SYMBOL_H_

src/compiler/rules/rules.cc

@@ -5,7 +5,7 @@
 #include "tree_sitter/compiler.h"
 #include "compiler/rules/rule.h"
 #include "compiler/rules/blank.h"
-#include "compiler/rules/symbol.h"
+#include "compiler/rules/named_symbol.h"
 #include "compiler/rules/choice.h"
 #include "compiler/rules/seq.h"
 #include "compiler/rules/string.h"
@@ -40,7 +40,7 @@ namespace tree_sitter {
         }
 
         rule_ptr sym(const string &name) {
-            return make_shared<Symbol>(name);
+            return make_shared<NamedSymbol>(name);
         }
 
         rule_ptr pattern(const string &value) {

src/compiler/rules/symbol.cc

@@ -1,42 +0,0 @@
-#include "compiler/rules/symbol.h"
-#include <map>
-#include <string>
-#include "compiler/rules/visitor.h"
-
-namespace tree_sitter  {
-    using std::string;
-    using std::hash;
-
-    namespace rules {
-        Symbol::Symbol(const std::string &name) : name(name) {}
-
-        bool Symbol::operator==(const Rule &rule) const {
-            const Symbol *other = dynamic_cast<const Symbol *>(&rule);
-            return other && this->operator==(*other);
-        }
-
-        bool Symbol::operator==(const Symbol &other) const {
-            return other.name == name;
-        }
-
-        size_t Symbol::hash_code() const {
-            return hash<string>()(name);
-        }
-
-        rule_ptr Symbol::copy() const {
-            return std::make_shared<Symbol>(*this);
-        }
-
-        string Symbol::to_string() const {
-            return string("#<sym '") + name + "'>";
-        }
-
-        bool Symbol::operator<(const Symbol &other) const {
-            return name < other.name;
-        }
-
-        void Symbol::accept(Visitor *visitor) const {
-            visitor->visit(this);
-        }
-    }
-}

src/compiler/rules/visitor.cc

@@ -1,7 +1,6 @@
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/rule.h"
 #include "compiler/rules/blank.h"
-#include "compiler/rules/symbol.h"
 #include "compiler/rules/character_set.h"
 #include "compiler/rules/choice.h"
 #include "compiler/rules/seq.h"

src/compiler/rules/visitor.h

@@ -6,7 +6,7 @@
 namespace tree_sitter {
     namespace rules {
         class Blank;
-        class Symbol;
+        class NamedSymbol;
         class CharacterSet;
         class Choice;
         class Repeat;
@@ -26,7 +26,7 @@ namespace tree_sitter {
             virtual void visit(const Repeat *rule) = 0;
             virtual void visit(const Seq *rule) = 0;
             virtual void visit(const String *rule) = 0;
-            virtual void visit(const Symbol *rule) = 0;
+            virtual void visit(const NamedSymbol *rule) = 0;
             virtual void visit(const ISymbol *rule) = 0;
             virtual ~Visitor();
         };
@@ -50,7 +50,7 @@ namespace tree_sitter {
             virtual T apply_to(const Repeat *rule) { return default_apply((const Rule *)rule); }
             virtual T apply_to(const Seq *rule) { return default_apply((const Rule *)rule); }
             virtual T apply_to(const String *rule) { return default_apply((const Rule *)rule); }
-            virtual T apply_to(const Symbol *rule) { return default_apply((const Rule *)rule); }
+            virtual T apply_to(const NamedSymbol *rule) { return default_apply((const Rule *)rule); }
             virtual T apply_to(const ISymbol *rule) { return default_apply((const Rule *)rule); }
 
             void visit(const Blank *rule) { value_ = apply_to(rule); }
@@ -61,7 +61,7 @@ namespace tree_sitter {
             void visit(const Repeat *rule) { value_ = apply_to(rule); }
             void visit(const Seq *rule) { value_ = apply_to(rule); }
             void visit(const String *rule) { value_ = apply_to(rule); }
-            void visit(const Symbol *rule) { value_ = apply_to(rule); }
+            void visit(const NamedSymbol *rule) { value_ = apply_to(rule); }
             void visit(const ISymbol *rule) { value_ = apply_to(rule); }
 
         private: