diff --git a/src/compiler/prepare_grammar/initial_syntax_grammar.h b/src/compiler/prepare_grammar/initial_syntax_grammar.h
index 79cc951e..4f21e3cd 100644
--- a/src/compiler/prepare_grammar/initial_syntax_grammar.h
+++ b/src/compiler/prepare_grammar/initial_syntax_grammar.h
@@ -17,7 +17,7 @@ struct InitialSyntaxGrammar {
   std::set<std::set<rules::Symbol>> expected_conflicts;
   std::vector<ExternalToken> external_tokens;
   std::set<rules::Symbol> variables_to_inline;
-  rules::Symbol word_rule = rules::NONE();
+  rules::Symbol word_rule;
 };
 
 }  // namespace prepare_grammar
diff --git a/src/compiler/syntax_grammar.h b/src/compiler/syntax_grammar.h
index ff056e3f..7d2b1be1 100644
--- a/src/compiler/syntax_grammar.h
+++ b/src/compiler/syntax_grammar.h
@@ -60,7 +60,7 @@ struct SyntaxGrammar {
   std::set<std::set<rules::Symbol>> expected_conflicts;
   std::vector<ExternalToken> external_tokens;
   std::set<rules::Symbol> variables_to_inline;
-  rules::Symbol word_rule = rules::NONE();
+  rules::Symbol word_rule;
 };
 
 }  // namespace tree_sitter
diff --git a/src/runtime/node.c b/src/runtime/node.c
index 607cf9de..0855ec66 100644
--- a/src/runtime/node.c
+++ b/src/runtime/node.c
@@ -28,11 +28,11 @@ static inline TSNode ts_node__null() {
 
 // TSNode - accessors
 
-uint32_t ts_node_start_byte(const TSNode self) {
+uint32_t ts_node_start_byte(TSNode self) {
   return self.context[0];
 }
 
-TSPoint ts_node_start_point(const TSNode self) {
+TSPoint ts_node_start_point(TSNode self) {
   return (TSPoint) {self.context[1], self.context[2]};
 }
 
diff --git a/test/compiler/build_tables/parse_item_set_builder_test.cc b/test/compiler/build_tables/parse_item_set_builder_test.cc
index 6cf5bb0e..6c41c3ca 100644
--- a/test/compiler/build_tables/parse_item_set_builder_test.cc
+++ b/test/compiler/build_tables/parse_item_set_builder_test.cc
@@ -25,7 +25,8 @@ describe("ParseItemSetBuilder", []() {
   LexicalGrammar lexical_grammar{lexical_variables, {}};
 
   it("adds items at the beginnings of referenced rules", [&]() {
-    SyntaxGrammar grammar{{
+    SyntaxGrammar grammar;
+    grammar.variables = {
       SyntaxVariable{"rule0", VariableTypeNamed, {
         Production({
           {Symbol::non_terminal(1), 0, AssociativityNone, Alias{}},
@@ -47,7 +48,7 @@ describe("ParseItemSetBuilder", []() {
           {Symbol::terminal(15), 0, AssociativityNone, Alias{}},
         }, 0)
       }},
-    }, {}, {}, {}, {}};
+    };
 
     auto production = [&](int variable_index, int production_index) -> const Production & {
       return grammar.variables[variable_index].productions[production_index];
@@ -84,7 +85,8 @@ describe("ParseItemSetBuilder", []() {
   });
 
   it("handles rules with empty productions", [&]() {
-    SyntaxGrammar grammar{{
+    SyntaxGrammar grammar;
+    grammar.variables = {
       SyntaxVariable{"rule0", VariableTypeNamed, {
         Production({
           {Symbol::non_terminal(1), 0, AssociativityNone, Alias{}},
@@ -98,7 +100,7 @@ describe("ParseItemSetBuilder", []() {
         }, 0),
         Production{{}, 0}
       }},
-    }, {}, {}, {}, {}};
+    };
 
     auto production = [&](int variable_index, int production_index) -> const Production & {
       return grammar.variables[variable_index].productions[production_index];
diff --git a/test/compiler/prepare_grammar/expand_repeats_test.cc b/test/compiler/prepare_grammar/expand_repeats_test.cc
index 250bd59b..f7aaa8fe 100644
--- a/test/compiler/prepare_grammar/expand_repeats_test.cc
+++ b/test/compiler/prepare_grammar/expand_repeats_test.cc
@@ -11,11 +11,9 @@ START_TEST
 
 describe("expand_repeats", []() {
   it("replaces repeat rules with pairs of recursive rules", [&]() {
-    InitialSyntaxGrammar grammar{
-      {
-        Variable{"rule0", VariableTypeNamed, Repeat{Symbol::terminal(0)}},
-      },
-      {}, {}, {}, {}
+    InitialSyntaxGrammar grammar;
+    grammar.variables = {
+      Variable{"rule0", VariableTypeNamed, Repeat{Symbol::terminal(0)}},
     };
 
     auto result = expand_repeats(grammar);
@@ -30,14 +28,12 @@ describe("expand_repeats", []() {
   });
 
   it("replaces repeats inside of sequences", [&]() {
-    InitialSyntaxGrammar grammar{
-      {
-        Variable{"rule0", VariableTypeNamed, Rule::seq({
-          Symbol::terminal(10),
-          Repeat{Symbol::terminal(11)},
-        })},
-      },
-      {}, {}, {}, {}
+    InitialSyntaxGrammar grammar;
+    grammar.variables = {
+      Variable{"rule0", VariableTypeNamed, Rule::seq({
+        Symbol::terminal(10),
+        Repeat{Symbol::terminal(11)},
+      })},
     };
 
     auto result = expand_repeats(grammar);
@@ -55,14 +51,12 @@ describe("expand_repeats", []() {
   });
 
   it("replaces repeats inside of choices", [&]() {
-    InitialSyntaxGrammar grammar{
-      {
-        Variable{"rule0", VariableTypeNamed, Rule::choice({
-          Symbol::terminal(10),
-          Repeat{Symbol::terminal(11)}
-        })},
-      },
-      {}, {}, {}, {}
+    InitialSyntaxGrammar grammar;
+    grammar.variables = {
+      Variable{"rule0", VariableTypeNamed, Rule::choice({
+        Symbol::terminal(10),
+        Repeat{Symbol::terminal(11)}
+      })},
     };
 
     auto result = expand_repeats(grammar);
@@ -80,18 +74,16 @@ describe("expand_repeats", []() {
   });
 
   it("does not create redundant auxiliary rules", [&]() {
-    InitialSyntaxGrammar grammar{
-      {
-        Variable{"rule0", VariableTypeNamed, Rule::choice({
-          Rule::seq({ Symbol::terminal(1), Repeat{Symbol::terminal(4)} }),
-          Rule::seq({ Symbol::terminal(2), Repeat{Symbol::terminal(4)} }),
-        })},
-        Variable{"rule1", VariableTypeNamed, Rule::seq({
-          Symbol::terminal(3),
-          Repeat{Symbol::terminal(4)}
-        })},
-      },
-      {}, {}, {}, {}
+    InitialSyntaxGrammar grammar;
+    grammar.variables = {
+      Variable{"rule0", VariableTypeNamed, Rule::choice({
+        Rule::seq({ Symbol::terminal(1), Repeat{Symbol::terminal(4)} }),
+        Rule::seq({ Symbol::terminal(2), Repeat{Symbol::terminal(4)} }),
+      })},
+      Variable{"rule1", VariableTypeNamed, Rule::seq({
+        Symbol::terminal(3),
+        Repeat{Symbol::terminal(4)}
+      })},
     };
 
     auto result = expand_repeats(grammar);
@@ -113,14 +105,14 @@ describe("expand_repeats", []() {
   });
 
   it("can replace multiple repeats in the same rule", [&]() {
-    InitialSyntaxGrammar grammar{
+    InitialSyntaxGrammar grammar;
+    grammar.variables = {
       {
         Variable{"rule0", VariableTypeNamed, Rule::seq({
           Repeat{Symbol::terminal(10)},
           Repeat{Symbol::terminal(11)},
         })},
-      },
-      {}, {}, {}, {}
+      }
     };
 
     auto result = expand_repeats(grammar);
@@ -142,12 +134,10 @@ describe("expand_repeats", []() {
   });
 
   it("can replace repeats in multiple rules", [&]() {
-    InitialSyntaxGrammar grammar{
-      {
-        Variable{"rule0", VariableTypeNamed, Repeat{Symbol::terminal(10)}},
-        Variable{"rule1", VariableTypeNamed, Repeat{Symbol::terminal(11)}},
-      },
-      {}, {}, {}, {}
+    InitialSyntaxGrammar grammar;
+    grammar.variables = {
+      Variable{"rule0", VariableTypeNamed, Repeat{Symbol::terminal(10)}},
+      Variable{"rule1", VariableTypeNamed, Repeat{Symbol::terminal(11)}},
     };
 
     auto result = expand_repeats(grammar);
diff --git a/test/compiler/prepare_grammar/intern_symbols_test.cc b/test/compiler/prepare_grammar/intern_symbols_test.cc
index 65bad45e..7b7f3624 100644
--- a/test/compiler/prepare_grammar/intern_symbols_test.cc
+++ b/test/compiler/prepare_grammar/intern_symbols_test.cc
@@ -11,13 +11,11 @@ using prepare_grammar::intern_symbols;
 
 describe("intern_symbols", []() {
   it("replaces named symbols with numerically-indexed symbols", [&]() {
-    InputGrammar grammar{
-      {
-        {"x", VariableTypeNamed, Rule::choice({ NamedSymbol{"y"}, NamedSymbol{"_z"} })},
-        {"y", VariableTypeNamed, NamedSymbol{"_z"}},
-        {"_z", VariableTypeNamed, String{"stuff"}}
-      },
-      {}, {}, {}, {}
+    InputGrammar grammar;
+    grammar.variables = {
+      {"x", VariableTypeNamed, Rule::choice({ NamedSymbol{"y"}, NamedSymbol{"_z"} })},
+      {"y", VariableTypeNamed, NamedSymbol{"_z"}},
+      {"_z", VariableTypeNamed, String{"stuff"}}
     };
 
     auto result = intern_symbols(grammar);
@@ -32,11 +30,9 @@ describe("intern_symbols", []() {
 
   describe("when there are symbols that reference undefined rules", [&]() {
     it("returns an error", []() {
-      InputGrammar grammar{
-        {
-          {"x", VariableTypeNamed, NamedSymbol{"y"}},
-        },
-        {}, {}, {}, {}
+      InputGrammar grammar;
+      grammar.variables = {
+        {"x", VariableTypeNamed, NamedSymbol{"y"}},
       };
 
       auto result = intern_symbols(grammar);
@@ -46,16 +42,14 @@ describe("intern_symbols", []() {
   });
 
   it("translates the grammar's optional 'extra_tokens' to numerical symbols", [&]() {
-    InputGrammar grammar{
-      {
-        {"x", VariableTypeNamed, Rule::choice({ NamedSymbol{"y"}, NamedSymbol{"z"} })},
-        {"y", VariableTypeNamed, NamedSymbol{"z"}},
-        {"z", VariableTypeNamed, String{"stuff"}}
-      },
-      {
-        NamedSymbol{"z"}
-      },
-      {}, {}, {}
+    InputGrammar grammar;
+    grammar.variables = {
+      {"x", VariableTypeNamed, Rule::choice({ NamedSymbol{"y"}, NamedSymbol{"z"} })},
+      {"y", VariableTypeNamed, NamedSymbol{"z"}},
+      {"z", VariableTypeNamed, String{"stuff"}}
+    };
+    grammar.extra_tokens = {
+      NamedSymbol{"z"}
     };
 
     auto result = intern_symbols(grammar);
@@ -66,19 +60,15 @@ describe("intern_symbols", []() {
   });
 
   it("records any rule names that match external token names", [&]() {
-    InputGrammar grammar{
-      {
-        {"x", VariableTypeNamed, Rule::choice({ NamedSymbol{"y"}, NamedSymbol{"z"} })},
-        {"y", VariableTypeNamed, NamedSymbol{"z"}},
-        {"z", VariableTypeNamed, String{"stuff"}},
-      },
-      {},
-      {},
-      {
-        NamedSymbol{"w"},
-        NamedSymbol{"z"},
-      },
-      {}
+    InputGrammar grammar;
+    grammar.variables = {
+      {"x", VariableTypeNamed, Rule::choice({ NamedSymbol{"y"}, NamedSymbol{"z"} })},
+      {"y", VariableTypeNamed, NamedSymbol{"z"}},
+      {"z", VariableTypeNamed, String{"stuff"}},
+    };
+    grammar.external_tokens = {
+      NamedSymbol{"w"},
+      NamedSymbol{"z"},
     };
 
     auto result = intern_symbols(grammar);