diff --git a/src/compiler/build_tables/first_set.cc b/src/compiler/build_tables/first_set.cc
index 37459fde..2a8d722d 100644
--- a/src/compiler/build_tables/first_set.cc
+++ b/src/compiler/build_tables/first_set.cc
@@ -8,7 +8,7 @@
 
 namespace tree_sitter {
     using std::set;
-    using namespace rules;
+    using rules::Symbol;
 
     namespace build_tables {
         set<Symbol> set_union(const set<Symbol> &left, const set<Symbol> &right) {
@@ -17,10 +17,10 @@ namespace tree_sitter {
             return result;
         }
 
-        class FirstSet : public RuleFn<set<Symbol>> {
+        class FirstSet : public rules::RuleFn<set<Symbol>> {
             const PreparedGrammar grammar;
         public:
-            FirstSet(const PreparedGrammar &grammar) : grammar(grammar) {}
+            explicit FirstSet(const PreparedGrammar &grammar) : grammar(grammar) {}
 
             void visit(const Symbol *rule) {
                 if (grammar.has_definition(*rule)) {
@@ -30,11 +30,11 @@ namespace tree_sitter {
                 }
             }
 
-            void visit(const Choice *rule) {
+            void visit(const rules::Choice *rule) {
                 value = set_union(apply(rule->left), apply(rule->right));
             }
 
-            void visit(const Seq *rule) {
+            void visit(const rules::Seq *rule) {
                 auto result = apply(rule->left);
                 if (rule_can_be_blank(rule->left, grammar)) {
                     result = set_union(result, apply(rule->right));
@@ -43,7 +43,7 @@ namespace tree_sitter {
             }
         };
 
-        set<Symbol> first_set(const rule_ptr &rule, const PreparedGrammar &grammar) {
+        set<Symbol> first_set(const rules::rule_ptr &rule, const PreparedGrammar &grammar) {
             return FirstSet(grammar).apply(rule);
         }
 
diff --git a/src/compiler/build_tables/item_set_closure.cc b/src/compiler/build_tables/item_set_closure.cc
index e384a6e7..9710f384 100644
--- a/src/compiler/build_tables/item_set_closure.cc
+++ b/src/compiler/build_tables/item_set_closure.cc
@@ -1,5 +1,6 @@
 #include "compiler/build_tables/item_set_closure.h"
 #include <algorithm>
+#include <set>
 #include "tree_sitter/compiler.h"
 #include "compiler/build_tables/follow_sets.h"
 #include "compiler/build_tables/item.h"
diff --git a/src/compiler/build_tables/item_set_transitions.cc b/src/compiler/build_tables/item_set_transitions.cc
index 1c00a3d9..af37ba26 100644
--- a/src/compiler/build_tables/item_set_transitions.cc
+++ b/src/compiler/build_tables/item_set_transitions.cc
@@ -1,4 +1,5 @@
 #include "compiler/build_tables/item_set_transitions.h"
+#include <set>
 #include "compiler/build_tables/item_set_closure.h"
 #include "compiler/build_tables/rule_transitions.h"
 #include "compiler/build_tables/merge_transitions.h"
diff --git a/src/compiler/build_tables/rule_can_be_blank.cc b/src/compiler/build_tables/rule_can_be_blank.cc
index 94335dd4..35ff51a8 100644
--- a/src/compiler/build_tables/rule_can_be_blank.cc
+++ b/src/compiler/build_tables/rule_can_be_blank.cc
@@ -8,28 +8,26 @@
 #include "compiler/rules/blank.h"
 
 namespace tree_sitter  {
-    using namespace rules;
-
     namespace build_tables {
-        class CanBeBlank : public RuleFn<bool> {
+        class CanBeBlank : public rules::RuleFn<bool> {
         protected:
-            void default_visit(const Rule *) {
+            void default_visit(const rules::Rule *) {
                 value = false;
             }
 
-            virtual void visit(const Blank *) {
+            virtual void visit(const rules::Blank *) {
                 value = true;
             }
 
-            virtual void visit(const Repeat *rule) {
+            virtual void visit(const rules::Repeat *rule) {
                 value = true;
             }
 
-            virtual void visit(const Choice *rule) {
+            virtual void visit(const rules::Choice *rule) {
                 value = apply(rule->left) || apply(rule->right);
             }
 
-            virtual void visit(const Seq *rule) {
+            virtual void visit(const rules::Seq *rule) {
                 value = apply(rule->left) && apply(rule->right);
             }
         };
@@ -41,16 +39,16 @@ namespace tree_sitter  {
         public:
             CanBeBlankRecursive(const PreparedGrammar &grammar) : grammar(grammar) {}
 
-            void visit(const Symbol *rule) {
+            void visit(const rules::Symbol *rule) {
                 value = grammar.has_definition(*rule) && apply(grammar.rule(*rule));
             }
         };
 
-        bool rule_can_be_blank(const rule_ptr &rule) {
+        bool rule_can_be_blank(const rules::rule_ptr &rule) {
             return CanBeBlank().apply(rule);
         }
 
-        bool rule_can_be_blank(const rule_ptr &rule, const PreparedGrammar &grammar) {
+        bool rule_can_be_blank(const rules::rule_ptr &rule, const PreparedGrammar &grammar) {
             return CanBeBlankRecursive(grammar).apply(rule);
         }
     }
diff --git a/src/compiler/build_tables/rule_transitions.cc b/src/compiler/build_tables/rule_transitions.cc
index 68d2e52c..8a296af7 100644
--- a/src/compiler/build_tables/rule_transitions.cc
+++ b/src/compiler/build_tables/rule_transitions.cc
@@ -1,4 +1,5 @@
 #include "compiler/build_tables/rule_transitions.h"
+#include <set>
 #include "compiler/build_tables/rule_can_be_blank.h"
 #include "compiler/build_tables/merge_transitions.h"
 #include "compiler/rules/blank.h"
@@ -14,7 +15,9 @@ namespace tree_sitter {
     using std::map;
     using std::set;
     using std::make_shared;
-    using namespace rules;
+    using rules::rule_ptr;
+    using rules::Symbol;
+    using rules::CharacterSet;
 
     namespace build_tables {
         template<typename T>
@@ -23,7 +26,7 @@ namespace tree_sitter {
         template<>
         map<CharacterSet, rule_ptr> merge_transitions(const map<CharacterSet, rule_ptr> &left, const map<CharacterSet, rule_ptr> &right) {
             auto transitions = merge_char_transitions<rule_ptr>(left, right, [](rule_ptr left, rule_ptr right) {
-                return make_shared<Choice>(left, right);
+                return make_shared<rules::Choice>(left, right);
             });
             return *static_cast<map<CharacterSet, rule_ptr> *>(&transitions);
         }
@@ -31,7 +34,7 @@ namespace tree_sitter {
         template<>
         map<Symbol, rule_ptr> merge_transitions(const map<Symbol, rule_ptr> &left, const map<Symbol, rule_ptr> &right) {
             auto transitions = merge_sym_transitions<rule_ptr>(left, right, [](rule_ptr left, rule_ptr right) {
-                return make_shared<Choice>(left, right);
+                return make_shared<rules::Choice>(left, right);
             });
             return *static_cast<map<Symbol, rule_ptr> *>(&transitions);
         }
@@ -45,11 +48,11 @@ namespace tree_sitter {
         }
 
         template<typename T>
-        class RuleTransitions : public RuleFn<map<T, rule_ptr>> {
-            void visit_atom(const Rule *rule) {
+        class RuleTransitions : public rules::RuleFn<map<T, rule_ptr>> {
+            void visit_atom(const rules::Rule *rule) {
                 auto atom = dynamic_cast<const T *>(rule);
                 if (atom)
-                    this->value = map<T, rule_ptr>({{ *atom, make_shared<Blank>() }});
+                    this->value = map<T, rule_ptr>({{ *atom, make_shared<rules::Blank>() }});
             }
 
             void visit(const CharacterSet *rule) {
@@ -60,34 +63,34 @@ namespace tree_sitter {
                 visit_atom(rule);
             }
 
-            void visit(const Choice *rule) {
+            void visit(const rules::Choice *rule) {
                 this->value = merge_transitions<T>(this->apply(rule->left),
                                                    this->apply(rule->right));
             }
 
-            void visit(const Seq *rule) {
+            void visit(const rules::Seq *rule) {
                 auto result = map_transitions(this->apply(rule->left), [&](const rule_ptr left_rule) {
-                    return Seq::Build({ left_rule, rule->right });
+                    return rules::Seq::Build({ left_rule, rule->right });
                 });
                 if (rule_can_be_blank(rule->left))
                     result = merge_transitions<T>(result, this->apply(rule->right));
                 this->value = result;
             }
 
-            void visit(const Repeat *rule) {
+            void visit(const rules::Repeat *rule) {
                 this->value = map_transitions(this->apply(rule->content), [&](const rule_ptr &value) {
-                    return Seq::Build({ value, make_shared<Choice>(rule->copy(), make_shared<Blank>()) });
+                    return rules::Seq::Build({ value, make_shared<rules::Choice>(rule->copy(), make_shared<rules::Blank>()) });
                 });
             }
 
-            void visit(const String *rule) {
-                rule_ptr result = make_shared<Blank>();
+            void visit(const rules::String *rule) {
+                rule_ptr result = make_shared<rules::Blank>();
                 for (char val : rule->value)
-                    result = Seq::Build({ result, make_shared<CharacterSet>(set<CharacterRange>({ val })) });
+                    result = rules::Seq::Build({ result, make_shared<CharacterSet>(set<rules::CharacterRange>({ val })) });
                 this->value = this->apply(result);
             }
 
-            void visit(const Pattern *rule) {
+            void visit(const rules::Pattern *rule) {
                 this->value = this->apply(rule->to_rule_tree());
             }
         };
diff --git a/src/compiler/generate_code/c_code.cc b/src/compiler/generate_code/c_code.cc
index 52e9fe1e..b200e2a3 100644
--- a/src/compiler/generate_code/c_code.cc
+++ b/src/compiler/generate_code/c_code.cc
@@ -1,6 +1,8 @@
 #include <map>
-#include <vector>
 #include <set>
+#include <string>
+#include <utility>
+#include <vector>
 #include "compiler/generate_code/c_code.h"
 #include "compiler/generate_code/helpers.h"
 #include "compiler/rules/built_in_symbols.h"
diff --git a/src/compiler/generate_code/c_code.h b/src/compiler/generate_code/c_code.h
index 7ead594c..b747921d 100644
--- a/src/compiler/generate_code/c_code.h
+++ b/src/compiler/generate_code/c_code.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_GENERATE_CODE_C_CODE_H_
 #define COMPILER_GENERATE_CODE_C_CODE_H_
 
+#include <string>
 #include "compiler/parse_table.h"
 #include "compiler/lex_table.h"
 
diff --git a/src/compiler/parse_table.cc b/src/compiler/parse_table.cc
index 6f3b76df..fe3821d8 100644
--- a/src/compiler/parse_table.cc
+++ b/src/compiler/parse_table.cc
@@ -1,4 +1,5 @@
 #include "compiler/parse_table.h"
+#include <string>
 
 namespace tree_sitter {
     using std::string;
diff --git a/src/compiler/parse_table.h b/src/compiler/parse_table.h
index 6bfabfc9..2b73eebf 100644
--- a/src/compiler/parse_table.h
+++ b/src/compiler/parse_table.h
@@ -2,8 +2,9 @@
 #define COMPILER_PARSE_TABLE_H_
 
 #include <map>
-#include <vector>
 #include <set>
+#include <utility>
+#include <vector>
 #include "compiler/lex_table.h"
 #include "compiler/rules/symbol.h"
 
diff --git a/src/compiler/prepare_grammar/expand_repeats.cc b/src/compiler/prepare_grammar/expand_repeats.cc
index c21190f6..356c3faa 100644
--- a/src/compiler/prepare_grammar/expand_repeats.cc
+++ b/src/compiler/prepare_grammar/expand_repeats.cc
@@ -1,5 +1,6 @@
 #include "compiler/prepare_grammar/expand_repeats.h"
 #include <map>
+#include <string>
 #include "compiler/prepared_grammar.h"
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/seq.h"
@@ -13,32 +14,32 @@ namespace tree_sitter {
     using std::to_string;
     using std::map;
     using std::make_shared;
-    using namespace rules;
+    using rules::rule_ptr;
 
     namespace prepare_grammar {
-        class ExpandRepeats : public RuleFn<rule_ptr> {
+        class ExpandRepeats : public rules::RuleFn<rule_ptr> {
             rule_ptr make_repeat_helper(string name, const rule_ptr &rule) {
-                return Choice::Build({
-                    Seq::Build({ rule, make_shared<Symbol>(name, SymbolTypeAuxiliary) }),
-                    make_shared<Blank>() });
+                return rules::Choice::Build({
+                    rules::Seq::Build({ rule, make_shared<rules::Symbol>(name, rules::SymbolTypeAuxiliary) }),
+                    make_shared<rules::Blank>() });
             }
 
-            void visit(const Repeat *rule) {
+            void visit(const rules::Repeat *rule) {
                 rule_ptr inner_rule = apply(rule->content);
                 string helper_rule_name = string("repeat_helper") + to_string(aux_rules.size() + 1);
                 aux_rules.insert({ helper_rule_name, make_repeat_helper(helper_rule_name, inner_rule) });
-                value = make_shared<Symbol>(helper_rule_name, SymbolTypeAuxiliary);
+                value = make_shared<rules::Symbol>(helper_rule_name, rules::SymbolTypeAuxiliary);
             }
 
-            void visit(const Seq *rule) {
-                value = Seq::Build({ apply(rule->left), apply(rule->right) });
+            void visit(const rules::Seq *rule) {
+                value = rules::Seq::Build({ apply(rule->left), apply(rule->right) });
             }
 
-            void visit(const Choice *rule) {
-                value = Choice::Build({ apply(rule->left), apply(rule->right) });
+            void visit(const rules::Choice *rule) {
+                value = rules::Choice::Build({ apply(rule->left), apply(rule->right) });
             }
 
-            void default_visit(const Rule *rule) {
+            void default_visit(const rules::Rule *rule) {
                 value = rule->copy();
             }
 
diff --git a/src/compiler/prepare_grammar/extract_tokens.cc b/src/compiler/prepare_grammar/extract_tokens.cc
index 9cb86e90..649952be 100644
--- a/src/compiler/prepare_grammar/extract_tokens.cc
+++ b/src/compiler/prepare_grammar/extract_tokens.cc
@@ -1,5 +1,6 @@
 #include "compiler/prepare_grammar/extract_tokens.h"
 #include <map>
+#include <string>
 #include "tree_sitter/compiler.h"
 #include "compiler/prepared_grammar.h"
 #include "compiler/rules/visitor.h"
@@ -17,24 +18,24 @@ namespace tree_sitter {
     using std::to_string;
     using std::map;
     using std::make_shared;
-    using namespace rules;
+    using rules::rule_ptr;
 
     namespace prepare_grammar {
-        class IsToken : public RuleFn<bool> {
-            void default_visit(const Rule *rule) {
+        class IsToken : public rules::RuleFn<bool> {
+            void default_visit(const rules::Rule *rule) {
                 value = false;
             }
 
-            void visit(const String *rule) {
+            void visit(const rules::String *rule) {
                 value = true;
             }
 
-            void visit(const Pattern *rule) {
+            void visit(const rules::Pattern *rule) {
                 value = true;
             }
         };
 
-        class TokenExtractor : public RuleFn<rule_ptr> {
+        class TokenExtractor : public rules::RuleFn<rule_ptr> {
             string add_token(const rule_ptr &rule) {
                 for (auto pair : tokens)
                     if (*pair.second == *rule)
@@ -44,25 +45,25 @@ namespace tree_sitter {
                 return name;
             }
 
-            void default_visit(const Rule *rule) {
+            void default_visit(const rules::Rule *rule) {
                 auto result = rule->copy();
                 if (IsToken().apply(result)) {
-                    value = make_shared<Symbol>(add_token(result), SymbolTypeAuxiliary);
+                    value = make_shared<rules::Symbol>(add_token(result), rules::SymbolTypeAuxiliary);
                 } else {
                     value = result;
                 }
             }
 
-            void visit(const Choice *rule) {
-                value = Choice::Build({ apply(rule->left), apply(rule->right) });
+            void visit(const rules::Choice *rule) {
+                value = rules::Choice::Build({ apply(rule->left), apply(rule->right) });
             }
 
-            void visit(const Seq *rule) {
-                value = Seq::Build({ apply(rule->left), apply(rule->right) });
+            void visit(const rules::Seq *rule) {
+                value = rules::Seq::Build({ apply(rule->left), apply(rule->right) });
             }
 
-            void visit(const Repeat *rule) {
-                value = make_shared<Repeat>(apply(rule->content));
+            void visit(const rules::Repeat *rule) {
+                value = make_shared<rules::Repeat>(apply(rule->content));
             }
 
         public:
diff --git a/src/compiler/prepared_grammar.cc b/src/compiler/prepared_grammar.cc
index 6c370ed8..ec6386ab 100644
--- a/src/compiler/prepared_grammar.cc
+++ b/src/compiler/prepared_grammar.cc
@@ -1,4 +1,7 @@
 #include "compiler/prepared_grammar.h"
+#include <map>
+#include <string>
+#include <utility>
 #include "compiler/rules/symbol.h"
 
 namespace tree_sitter {
diff --git a/src/compiler/prepared_grammar.h b/src/compiler/prepared_grammar.h
index 35e14b19..ee2804fa 100644
--- a/src/compiler/prepared_grammar.h
+++ b/src/compiler/prepared_grammar.h
@@ -1,6 +1,9 @@
 #ifndef COMPILER_PREPARED_GRAMMAR_H_
 #define COMPILER_PREPARED_GRAMMAR_H_
 
+#include <map>
+#include <string>
+#include <utility>
 #include "tree_sitter/compiler.h"
 #include "compiler/rules/symbol.h"
 
diff --git a/src/compiler/rules/blank.cc b/src/compiler/rules/blank.cc
index 0a499076..8853bd11 100644
--- a/src/compiler/rules/blank.cc
+++ b/src/compiler/rules/blank.cc
@@ -1,4 +1,5 @@
 #include "compiler/rules/blank.h"
+#include <string>
 #include "compiler/rules/visitor.h"
 
 namespace tree_sitter  {
diff --git a/src/compiler/rules/blank.h b/src/compiler/rules/blank.h
index bdfb58e9..91e9bc7b 100644
--- a/src/compiler/rules/blank.h
+++ b/src/compiler/rules/blank.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_RULES_BLANK_H_
 #define COMPILER_RULES_BLANK_H_
 
+#include <string>
 #include "compiler/rules/rule.h"
 
 namespace tree_sitter  {
diff --git a/src/compiler/rules/character_range.cc b/src/compiler/rules/character_range.cc
index e1fa216e..96e9d29f 100644
--- a/src/compiler/rules/character_range.cc
+++ b/src/compiler/rules/character_range.cc
@@ -1,4 +1,5 @@
 #include "compiler/rules/character_range.h"
+#include <algorithm>
 #include <string>
 
 namespace tree_sitter {
diff --git a/src/compiler/rules/character_set.cc b/src/compiler/rules/character_set.cc
index b01a03de..2d6b9915 100644
--- a/src/compiler/rules/character_set.cc
+++ b/src/compiler/rules/character_set.cc
@@ -1,4 +1,6 @@
 #include "compiler/rules/character_set.h"
+#include <string>
+#include <utility>
 #include "compiler/rules/visitor.h"
 
 using std::string;
diff --git a/src/compiler/rules/character_set.h b/src/compiler/rules/character_set.h
index 2bfa6252..a79496bf 100644
--- a/src/compiler/rules/character_set.h
+++ b/src/compiler/rules/character_set.h
@@ -3,6 +3,8 @@
 
 #include <initializer_list>
 #include <set>
+#include <string>
+#include <utility>
 #include "compiler/rules/rule.h"
 #include "compiler/rules/character_range.h"
 
diff --git a/src/compiler/rules/choice.cc b/src/compiler/rules/choice.cc
index ecc41b87..32aaba16 100644
--- a/src/compiler/rules/choice.cc
+++ b/src/compiler/rules/choice.cc
@@ -1,4 +1,5 @@
 #include "compiler/rules/choice.h"
+#include <string>
 #include "compiler/rules/visitor.h"
 
 namespace tree_sitter  {
diff --git a/src/compiler/rules/choice.h b/src/compiler/rules/choice.h
index dbf6c37f..dc7bf6df 100644
--- a/src/compiler/rules/choice.h
+++ b/src/compiler/rules/choice.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_RULES_CHOICE_H_
 #define COMPILER_RULES_CHOICE_H_
 
+#include <string>
 #include <vector>
 #include "compiler/rules/rule.h"
 
diff --git a/src/compiler/rules/pattern.cc b/src/compiler/rules/pattern.cc
index 3d25069a..2bf36662 100644
--- a/src/compiler/rules/pattern.cc
+++ b/src/compiler/rules/pattern.cc
@@ -1,5 +1,6 @@
 #include "compiler/rules/pattern.h"
 #include <set>
+#include <string>
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/choice.h"
 #include "compiler/rules/seq.h"
diff --git a/src/compiler/rules/pattern.h b/src/compiler/rules/pattern.h
index 00560125..0e857697 100644
--- a/src/compiler/rules/pattern.h
+++ b/src/compiler/rules/pattern.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_RULES_PATTERN_H_
 #define COMPILER_RULES_PATTERN_H_
 
+#include <string>
 #include "compiler/rules/rule.h"
 
 namespace tree_sitter {
diff --git a/src/compiler/rules/repeat.cc b/src/compiler/rules/repeat.cc
index a0e4445b..c2284ed0 100644
--- a/src/compiler/rules/repeat.cc
+++ b/src/compiler/rules/repeat.cc
@@ -1,4 +1,5 @@
 #include "compiler/rules/repeat.h"
+#include <string>
 #include "compiler/rules/visitor.h"
 
 namespace tree_sitter {
diff --git a/src/compiler/rules/repeat.h b/src/compiler/rules/repeat.h
index 52673662..b1ea4d2e 100644
--- a/src/compiler/rules/repeat.h
+++ b/src/compiler/rules/repeat.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_RULES_REPEAT_H_
 #define COMPILER_RULES_REPEAT_H_
 
+#include <string>
 #include "compiler/rules/rule.h"
 
 namespace tree_sitter  {
diff --git a/src/compiler/rules/seq.cc b/src/compiler/rules/seq.cc
index 46ecd658..738b524e 100644
--- a/src/compiler/rules/seq.cc
+++ b/src/compiler/rules/seq.cc
@@ -1,4 +1,5 @@
 #include "compiler/rules/seq.h"
+#include <string>
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/blank.h"
 
diff --git a/src/compiler/rules/seq.h b/src/compiler/rules/seq.h
index 6a92044c..56b0793c 100644
--- a/src/compiler/rules/seq.h
+++ b/src/compiler/rules/seq.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_RULES_SEQ_H_
 #define COMPILER_RULES_SEQ_H_
 
+#include <string>
 #include <vector>
 #include "compiler/rules/rule.h"
 
diff --git a/src/compiler/rules/string.cc b/src/compiler/rules/string.cc
index 8721c887..69da1e5a 100644
--- a/src/compiler/rules/string.cc
+++ b/src/compiler/rules/string.cc
@@ -1,4 +1,5 @@
 #include "compiler/rules/string.h"
+#include <string>
 #include "compiler/rules/visitor.h"
 
 namespace tree_sitter  {
diff --git a/src/compiler/rules/string.h b/src/compiler/rules/string.h
index 5cf3cd4a..8f8d38be 100644
--- a/src/compiler/rules/string.h
+++ b/src/compiler/rules/string.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_RULES_STRING_H_
 #define COMPILER_RULES_STRING_H_
 
+#include <string>
 #include "compiler/rules/rule.h"
 
 namespace tree_sitter  {
diff --git a/src/compiler/rules/symbol.cc b/src/compiler/rules/symbol.cc
index 03729669..d601396f 100644
--- a/src/compiler/rules/symbol.cc
+++ b/src/compiler/rules/symbol.cc
@@ -1,5 +1,6 @@
 #include "compiler/rules/symbol.h"
 #include <map>
+#include <string>
 #include "compiler/rules/visitor.h"
 
 namespace tree_sitter  {
diff --git a/src/compiler/rules/symbol.h b/src/compiler/rules/symbol.h
index 4d76d756..ea4abb22 100644
--- a/src/compiler/rules/symbol.h
+++ b/src/compiler/rules/symbol.h
@@ -1,6 +1,7 @@
 #ifndef COMPILER_RULES_SYMBOL_H_
 #define COMPILER_RULES_SYMBOL_H_
 
+#include <string>
 #include <utility>
 #include "compiler/rules/rule.h"