Get rid of types for shared pointers to rule subclasses

src/compiler/lr/item.cpp

@@ -23,11 +23,11 @@ namespace tree_sitter {
             });
         };
         
-        vector<rules::sym_ptr> Item::next_symbols() const {
-            vector<rules::sym_ptr> result;
+        vector<rules::Symbol> Item::next_symbols() const {
+            vector<rules::Symbol> result;
             for (auto pair : rules::transitions(rule)) {
                 shared_ptr<const rules::Symbol> sym = dynamic_pointer_cast<const rules::Symbol>(pair.first);
-                if (sym) result.push_back(sym);
+                if (sym) result.push_back(*sym);
             }
             return result;
         }

src/compiler/lr/item.h

@@ -16,7 +16,7 @@ namespace tree_sitter {
             static Item at_beginning_of_rule(const std::string &rule_name, const Grammar &grammar);
 
             TransitionMap<Item> transitions() const;
-            std::vector<rules::sym_ptr> next_symbols() const;
+            std::vector<rules::Symbol> next_symbols() const;
             bool operator==(const Item &other) const;
             bool is_done() const;
 

src/compiler/lr/item_set.cpp

@@ -16,8 +16,8 @@ namespace tree_sitter {
         static void add_item(vector<Item> &vector, const Item &item, const Grammar &grammar) {
             if (!vector_contains(vector, item)) {
                 vector.push_back(item);
-                for (rules::sym_ptr rule : item.next_symbols()) {
-                    Item next_item = Item::at_beginning_of_rule(rule->name, grammar);
+                for (rules::Symbol rule : item.next_symbols()) {
+                    Item next_item = Item::at_beginning_of_rule(rule.name, grammar);
                     add_item(vector, next_item, grammar);
                 }
             }

src/compiler/lr/parse_table_builder.cpp

@@ -23,7 +23,7 @@ namespace tree_sitter {
             
             void add_shift_actions(const ItemSet &item_set, size_t state_index) {
                 for (auto transition : item_set.sym_transitions(grammar)) {
-                    rules::sym_ptr symbol = static_pointer_cast<const rules::Symbol>(transition.first);
+                    auto symbol = static_pointer_cast<const rules::Symbol>(transition.first);
                     size_t new_state_index = add_item_set(*transition.second);
                     table.add_action(state_index, symbol->name, ParseAction::Shift(new_state_index));
                 }

src/compiler/rules/pattern.cpp

@@ -103,7 +103,7 @@ namespace tree_sitter {
         
         Pattern::Pattern(const std::string &string) : value(string) {};
         
-        pattern_ptr pattern(const std::string &value) {
+        rule_ptr pattern(const std::string &value) {
             return std::make_shared<Pattern>(value);
         }
         

src/compiler/rules/pattern.h

@@ -15,8 +15,7 @@ namespace tree_sitter {
             rule_ptr to_rule_tree() const;
         };
 
-        typedef std::shared_ptr<const Pattern> pattern_ptr;
-        pattern_ptr pattern(const std::string &value);
+        rule_ptr pattern(const std::string &value);
     }
 }
 

src/compiler/rules/rule_visitor.cpp

@@ -0,0 +1,15 @@
+#include "rule_visitor.h"
+
+namespace tree_sitter {
+    namespace rules {
+        void RuleVisitor::visit(const Blank *rule) {}
+        void RuleVisitor::visit(const Symbol *rule) {}
+        void RuleVisitor::visit(const Char *rule) {}
+        void RuleVisitor::visit(const CharClass *rule) {}
+        void RuleVisitor::visit(const Choice *rule) {}
+        void RuleVisitor::visit(const Repeat *rule) {}
+        void RuleVisitor::visit(const Seq *rule) {}
+        void RuleVisitor::visit(const String *rule) {}
+        void RuleVisitor::visit(const Pattern *rule) {}
+    }
+}

src/compiler/rules/rule_visitor.h

@@ -7,15 +7,15 @@ namespace tree_sitter {
     namespace rules {
         class RuleVisitor {
         public:
-            virtual void visit(const Blank *rule) = 0;
-            virtual void visit(const Symbol *rule) = 0;
-            virtual void visit(const Char *rule) = 0;
-            virtual void visit(const CharClass *rule) = 0;
-            virtual void visit(const Choice *rule) = 0;
-            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 Pattern *rule) = 0;
+            virtual void visit(const Blank *rule);
+            virtual void visit(const Symbol *rule);
+            virtual void visit(const Char *rule);
+            virtual void visit(const CharClass *rule);
+            virtual void visit(const Choice *rule);
+            virtual void visit(const Repeat *rule);
+            virtual void visit(const Seq *rule);
+            virtual void visit(const String *rule);
+            virtual void visit(const Pattern *rule);
         };
     }
 }

src/compiler/rules/string.cpp

@@ -5,7 +5,7 @@ namespace tree_sitter  {
     namespace rules {
         String::String(std::string value) : value(value) {};
         
-        string_ptr str(const std::string &value) {
+        rule_ptr str(const std::string &value) {
             return std::make_shared<String>(value);
         }
 

src/compiler/rules/string.h

@@ -15,8 +15,7 @@ namespace tree_sitter  {
             const std::string value;
         };
         
-        typedef std::shared_ptr<const String> string_ptr;
-        string_ptr str(const std::string &value);
+        rule_ptr str(const std::string &value);
     }
 }
 

src/compiler/rules/symbol.cpp

@@ -5,7 +5,7 @@ namespace tree_sitter  {
     namespace rules {
         Symbol::Symbol(const std::string &name) : name(name) {};
 
-        sym_ptr sym(const std::string &name) {
+        rule_ptr sym(const std::string &name) {
             return std::make_shared<Symbol>(name);
         }
 

src/compiler/rules/symbol.h

@@ -15,8 +15,7 @@ namespace tree_sitter  {
             const std::string name;
         };
         
-        typedef std::shared_ptr<const Symbol> sym_ptr;
-        sym_ptr sym(const std::string &name);
+        rule_ptr sym(const std::string &name);
     }
 }