diff --git a/spec/fixtures/grammars/arithmetic.cc b/spec/fixtures/grammars/arithmetic.cc
index d76971ed..6f45271f 100644
--- a/spec/fixtures/grammars/arithmetic.cc
+++ b/spec/fixtures/grammars/arithmetic.cc
@@ -4,33 +4,39 @@
 namespace tree_sitter_examples {
 
 extern const Grammar arithmetic = Grammar({
-    { "program", sym("_expression") },
-    { "_expression", choice({
-        sym("sum"),
-        sym("difference"),
-        sym("product"),
-        sym("quotient"),
-        sym("exponent"),
-        sym("group"),
-        sym("number"),
-        sym("variable") }) },
+  { "program", sym("_expression") },
 
-    { "sum", infix_op("+", "_expression", 1) },
-    { "difference", infix_op("-", "_expression", 1) },
-    { "product", infix_op("*", "_expression", 2) },
-    { "quotient", infix_op("/", "_expression", 2) },
-    { "exponent", infix_op("^", "_expression", 3) },
-    { "group", in_parens(err(sym("_expression"))) },
+  { "_expression", choice({
+    sym("sum"),
+    sym("difference"),
+    sym("product"),
+    sym("quotient"),
+    sym("exponent"),
+    sym("group"),
+    sym("number"),
+    sym("variable") }) },
 
-    { "number", pattern("\\d+") },
+  { "sum", infix_op("+", "_expression", 1) },
 
-    // [a-ZA-Zα-ω]+\d*
-    { "variable", pattern("[a-zA-Z\u03b1-\u03c9]+\\d*") },
+  { "difference", infix_op("-", "_expression", 1) },
 
-    { "comment", pattern("#.*") },
+  { "product", infix_op("*", "_expression", 2) },
+
+  { "quotient", infix_op("/", "_expression", 2) },
+
+  { "exponent", infix_op("^", "_expression", 3) },
+
+  { "group", in_parens(err(sym("_expression"))) },
+
+  { "number", pattern("\\d+") },
+
+  // [a-ZA-Zα-ω]+\d*
+  { "variable", pattern("[a-zA-Z\u03b1-\u03c9]+\\d*") },
+
+  { "comment", pattern("#.*") },
 }).ubiquitous_tokens({
-    sym("comment"),
-    pattern("\\s"),
+  sym("comment"),
+  pattern("\\s"),
 });
 
 }  // namespace tree_sitter_examples
diff --git a/spec/fixtures/grammars/c.cc b/spec/fixtures/grammars/c.cc
index 6cceb2e5..36b3e3d5 100644
--- a/spec/fixtures/grammars/c.cc
+++ b/spec/fixtures/grammars/c.cc
@@ -6,163 +6,163 @@ namespace tree_sitter_examples {
 // http://slps.github.io/zoo/c/iso-9899-tc3.html
 
 extern const Grammar c = Grammar({
-    { "program", choice({
-        sym("function_definition"),
-        sym("declaration") }) },
+  { "program", choice({
+    sym("function_definition"),
+    sym("declaration") }) },
 
-    { "function_definition", seq({
-        optional(sym("declaration_specifiers")),
-        sym("_type_specifier"),
-        sym("declarator"),
-        repeat(sym("declaration")),
-        sym("compound_statement") }) },
+  { "function_definition", seq({
+    optional(sym("declaration_specifiers")),
+    sym("_type_specifier"),
+    sym("declarator"),
+    repeat(sym("declaration")),
+    sym("compound_statement") }) },
 
-    { "declaration_specifiers", repeat1(choice({
-        sym("storage_class_specifier"),
-        sym("type_qualifier") })) },
+  { "declaration_specifiers", repeat1(choice({
+    sym("storage_class_specifier"),
+    sym("type_qualifier") })) },
 
-    { "storage_class_specifier", choice({
-        str("typedef"),
-        str("extern"),
-        str("static"),
-        str("auto"),
-        str("register") }) },
+  { "storage_class_specifier", choice({
+    str("typedef"),
+    str("extern"),
+    str("static"),
+    str("auto"),
+    str("register") }) },
 
-    { "_type_specifier", choice({
-        sym("struct_specifier"),
-        sym("type_name") }) },
+  { "_type_specifier", choice({
+    sym("struct_specifier"),
+    sym("type_name") }) },
 
-    { "type_name", seq({
-        repeat(choice({
-            str("signed"),
-            str("unsigned"),
-            str("long"),
-            str("short") })),
-        sym("identifier") }) },
+  { "type_name", seq({
+    repeat(choice({
+      str("signed"),
+      str("unsigned"),
+      str("long"),
+      str("short") })),
+    sym("identifier") }) },
 
-    { "struct_specifier", seq({
-        str("struct"),
-        optional(sym("identifier")),
-        seq({
-            str("{"),
-            repeat(sym("struct_declaration")),
-            str("}") }) }) },
+  { "struct_specifier", seq({
+    str("struct"),
+    optional(sym("identifier")),
+    seq({
+      str("{"),
+      repeat(sym("struct_declaration")),
+      str("}") }) }) },
 
-    { "struct_declaration", seq({
-        sym("_type_specifier"),
-        sym("declarator") }) },
+  { "struct_declaration", seq({
+    sym("_type_specifier"),
+    sym("declarator") }) },
 
-    { "parameter_declaration", seq({
-        optional(sym("declaration_specifiers")),
-        sym("_type_specifier"),
-        sym("declarator") }) },
+  { "parameter_declaration", seq({
+    optional(sym("declaration_specifiers")),
+    sym("_type_specifier"),
+    sym("declarator") }) },
 
-    { "declaration", seq({
-        optional(sym("declaration_specifiers")),
-        sym("_type_specifier"),
-        comma_sep1(sym("_init_declarator")),
-        str(";") }) },
+  { "declaration", seq({
+    optional(sym("declaration_specifiers")),
+    sym("_type_specifier"),
+    comma_sep1(sym("_init_declarator")),
+    str(";") }) },
 
-    { "_init_declarator", choice({
-        sym("declarator"),
-        seq({ sym("declarator"), str("="), sym("initializer") }) }) },
+  { "_init_declarator", choice({
+    sym("declarator"),
+    seq({ sym("declarator"), str("="), sym("initializer") }) }) },
 
-    { "initializer", choice({
+  { "initializer", choice({
+    sym("expression"),
+    seq({
+      str("{"),
+      sym("initializer_list"),
+      optional(str(",")),
+      str("}") }) }) },
+
+  { "initializer_list", choice({
+    seq({
+      optional(sym("designation")),
+      sym("initializer") }),
+    seq({
+      sym("initializer_list"),
+      str(","),
+      optional(sym("designation")),
+      sym("initializer") }) }) },
+
+  { "designation", seq({
+    repeat1(choice({
+      seq({
+        str("["),
         sym("expression"),
-        seq({
-            str("{"),
-            sym("initializer_list"),
-            optional(str(",")),
-            str("}") }) }) },
+        str("]") }),
+      seq({
+        str("."),
+        sym("identifier") }) })),
+    str("=") }) },
 
-    { "initializer_list", choice({
-        seq({
-            optional(sym("designation")),
-            sym("initializer") }),
-        seq({
-            sym("initializer_list"),
-            str(","),
-            optional(sym("designation")),
-            sym("initializer") }) }) },
+  { "declarator", seq({
+    repeat(sym("pointer")),
+    sym("_direct_declarator") }) },
 
-    { "designation", seq({
-        repeat1(choice({
-            seq({
-                str("["),
-                sym("expression"),
-                str("]") }),
-            seq({
-                str("."),
-                sym("identifier") }) })),
-        str("=") }) },
+  { "_direct_declarator", choice({
+    sym("identifier"),
+    seq({
+      str("("),
+      sym("declarator"),
+      str(")") }),
+    seq({
+      sym("_direct_declarator"),
+      str("["),
+      optional(sym("expression")),
+      str("]") }),
+    seq({
+      sym("_direct_declarator"),
+      str("("),
+      comma_sep(sym("parameter_declaration")),
+      str(")") }) }) },
 
-    { "declarator", seq({
-        repeat(sym("pointer")),
-        sym("_direct_declarator") }) },
+  { "type_qualifier", choice({
+    str("const"),
+    str("restrict"),
+    str("volatile") }) },
 
-    { "_direct_declarator", choice({
-        sym("identifier"),
-        seq({
-            str("("),
-            sym("declarator"),
-            str(")") }),
-        seq({
-            sym("_direct_declarator"),
-            str("["),
-            optional(sym("expression")),
-            str("]") }),
-        seq({
-            sym("_direct_declarator"),
-            str("("),
-            comma_sep(sym("parameter_declaration")),
-            str(")") }) }) },
+  { "pointer", str("*") },
 
-    { "type_qualifier", choice({
-        str("const"),
-        str("restrict"),
-        str("volatile") }) },
+  { "compound_statement", seq({
+    str("{"),
+    repeat(choice({ sym("declaration"), sym("statement") })),
+    str("}") }) },
 
-    { "pointer", str("*") },
+  { "expression", choice({
+    sym("math_expression"),
+    sym("call_expression"),
+    sym("string"),
+    sym("identifier"),
+    sym("number") }) },
 
-    { "compound_statement", seq({
-        str("{"),
-        repeat(choice({ sym("declaration"), sym("statement") })),
-        str("}") }) },
+  { "math_expression", choice({
+    prec(1, seq({ sym("expression"), str("+"), sym("expression") })),
+    prec(2, seq({ sym("expression"), str("*"), sym("expression") })) }) },
 
-    { "expression", choice({
-        sym("math_expression"),
-        sym("call_expression"),
-        sym("string"),
-        sym("identifier"),
-        sym("number") }) },
+  { "call_expression", prec(3, seq({
+    sym("expression"),
+    str("("),
+    comma_sep(sym("expression")),
+    str(")") })) },
 
-    { "math_expression", choice({
-        prec(1, seq({ sym("expression"), str("+"), sym("expression") })),
-        prec(2, seq({ sym("expression"), str("*"), sym("expression") })) }) },
+  { "statement", choice({
+    sym("expression_statement") }) },
 
-    { "call_expression", prec(3, seq({
-        sym("expression"),
-        str("("),
-        comma_sep(sym("expression")),
-        str(")") })) },
+  { "expression_statement", seq({
+    sym("expression"),
+    str(";") }) },
 
-    { "statement", choice({
-        sym("expression_statement") }) },
+  { "string", delimited("\"") },
 
-    { "expression_statement", seq({
-        sym("expression"),
-        str(";") }) },
+  { "identifier", pattern("\\a[\\w_]*") },
 
-    { "string", delimited("\"") },
+  { "number", pattern("\\d+(\\.\\d+)?") },
 
-    { "identifier", pattern("\\a[\\w_]*") },
-
-    { "number", pattern("\\d+(\\.\\d+)?") },
-
-    { "comment", pattern("//[^\n]*") },
+  { "comment", pattern("//[^\n]*") },
 }).ubiquitous_tokens({
-    sym("comment"),
-    pattern("[ \t\r\n]"),
+  sym("comment"),
+  pattern("[ \t\r\n]"),
 }).expected_conflicts({
   { "type_name", "expression" },
 });
diff --git a/spec/fixtures/grammars/golang.cc b/spec/fixtures/grammars/golang.cc
index 0ed77df1..e9ada843 100644
--- a/spec/fixtures/grammars/golang.cc
+++ b/spec/fixtures/grammars/golang.cc
@@ -5,167 +5,208 @@ namespace tree_sitter_examples {
 
 static rule_ptr terminated(rule_ptr rule) {
   return seq({ rule, choice({
-        sym("_line_break"),
-        str(";") }) });
+    sym("_line_break"),
+    str(";") }) });
 }
 
 extern const Grammar golang = Grammar({
-    { "program", seq({
-        sym("package_directive"),
-        repeat(sym("imports_block")),
-        repeat(sym("_declaration")) }) },
-    { "package_directive", seq({
-        str("package"),
-        sym("package_name") }) },
-    { "imports_block", seq({
-        str("import"),
-        choice({
-            in_parens(err(repeat(sym("package_import")))),
-            sym("package_import") }) }) },
-    { "package_import", sym("string") },
-    { "_declaration", choice({
-        sym("type_declaration"),
-        sym("var_declaration"),
-        sym("func_declaration") }) },
+  { "program", seq({
+    sym("package_directive"),
+    repeat(sym("imports_block")),
+    repeat(sym("_declaration")) }) },
 
-    // Declarations
-    { "type_declaration", terminated(seq({
-        str("type"),
-        sym("type_name"),
-        sym("_type_expression") })) },
-    { "var_declaration", terminated(seq({
-        str("var"),
-        sym("var_name"),
-        choice({
-            seq({
-                optional(sym("_type_expression")),
-                str("="),
-                sym("_expression") }),
-            sym("_type_expression") }) })) },
-    { "func_declaration", terminated(seq({
-        str("func"),
-        sym("var_name"),
-        sym("_func_signature"),
-        sym("block_statement") })) },
-    { "block_statement", in_braces(err(repeat(sym("_statement")))) },
-    { "_type_expression", choice({
-        sym("pointer_type"),
-        sym("slice_type"),
-        sym("map_type"),
-        sym("interface_type"),
-        sym("struct_type"),
-        sym("type_name") }) },
+  { "package_directive", seq({
+    str("package"),
+    sym("package_name") }) },
 
-    // Type expressions
-    { "pointer_type", seq({
-        str("*"),
-        sym("_type_expression") }) },
-    { "map_type", seq({
-        str("map"),
-        in_brackets(sym("_type_expression")),
-        sym("_type_expression") }) },
-    { "slice_type", seq({
-        in_brackets(blank()),
-        sym("_type_expression") }) },
-    { "struct_type", seq({
-        str("struct"),
-        in_braces(repeat(seq({
-            sym("var_name"),
-            sym("_type_expression") }))) }) },
-    { "interface_type", seq({
-        str("interface"),
-        in_braces(repeat(seq({
-            sym("var_name"),
-            sym("_func_signature") }))) }) },
+  { "imports_block", seq({
+    str("import"),
+    choice({
+      in_parens(err(repeat(sym("package_import")))),
+      sym("package_import") }) }) },
 
-    // Statements
-    { "_statement", choice({
-        sym("expression_statement"),
-        sym("return_statement"),
-        sym("var_declaration"),
-        sym("short_var_declaration"),
-        sym("range_statement"),
-        sym("if_statement") }) },
-    { "return_statement", terminated(seq({
-        str("return"),
-        comma_sep(sym("_expression")) })) },
-    { "short_var_declaration", terminated(seq({
-        comma_sep(sym("var_name")),
-        str(":="),
-        sym("_expression") })) },
-    { "range_statement", seq({
-        str("for"),
-        sym("var_name"),
-        optional(seq({ str(","), sym("var_name") })),
-        str(":="),
-        str("range"),
-        sym("_expression"),
-        sym("block_statement") }) },
-    { "if_statement", seq({
-        str("if"),
-        sym("_expression"),
-        sym("block_statement"),
-        optional(seq({
-            str("else"),
-            choice({
-                sym("if_statement"),
-                sym("block_statement") }) })) }) },
-    { "expression_statement", terminated(sym("_expression")) },
+  { "package_import", sym("string") },
 
-    // Value expressions
-    { "_expression", choice({
-        sym("call_expression"),
-        sym("selector_expression"),
-        sym("math_op"),
-        sym("bool_op"),
-        sym("number"),
-        sym("string"),
-        sym("var_name") }) },
-    { "call_expression", seq({
-        sym("_expression"),
-        in_parens(comma_sep(sym("_expression"))) }) },
-    { "selector_expression", seq({
-        sym("_expression"),
-        str("."),
-        sym("var_name") }) },
-    { "math_op", choice({
-        infix_op("*", "_expression", 2),
-        infix_op("/", "_expression", 2),
-        infix_op("+", "_expression", 1),
-        infix_op("-", "_expression", 1) }) },
-    { "bool_op", choice({
-        infix_op("||", "_expression", 1),
-        infix_op("&&", "_expression", 2),
-        infix_op("==", "_expression", 3),
-        infix_op("<=", "_expression", 3),
-        infix_op("<", "_expression", 3),
-        infix_op(">=", "_expression", 3),
-        infix_op(">", "_expression", 3),
-        prefix_op("!", "_expression", 4) }) },
-    { "_func_signature", prec(10, seq({
-        in_parens(comma_sep(seq({
-            comma_sep1(sym("var_name")),
-            sym("_type_expression") }))),
-        choice({
-            in_parens(choice({
-                comma_sep1(seq({ sym("var_name"), sym("type_name") })),
-                comma_sep1(sym("type_name")) })),
-            sym("type_name"),
-            blank() }) })) },
+  { "_declaration", choice({
+    sym("type_declaration"),
+    sym("var_declaration"),
+    sym("func_declaration") }) },
 
-    { "_line_break", str("\n") },
+  /*
+   *  Declarations
+   */
+
+  { "type_declaration", terminated(seq({
+    str("type"),
+    sym("type_name"),
+    sym("_type_expression") })) },
+
+  { "var_declaration", terminated(seq({
+    str("var"),
+    sym("var_name"),
+    choice({
+      seq({
+        optional(sym("_type_expression")),
+        str("="),
+        sym("_expression") }),
+      sym("_type_expression") }) })) },
+
+  { "func_declaration", terminated(seq({
+    str("func"),
+    sym("var_name"),
+    sym("_func_signature"),
+    sym("block_statement") })) },
+
+  { "block_statement", in_braces(err(repeat(sym("_statement")))) },
+
+  { "_type_expression", choice({
+    sym("pointer_type"),
+    sym("slice_type"),
+    sym("map_type"),
+    sym("interface_type"),
+    sym("struct_type"),
+    sym("type_name") }) },
+
+  /*
+   * Type expressions
+   */
+
+  { "pointer_type", seq({
+    str("*"),
+    sym("_type_expression") }) },
+
+  { "map_type", seq({
+    str("map"),
+    in_brackets(sym("_type_expression")),
+    sym("_type_expression") }) },
+
+  { "slice_type", seq({
+    in_brackets(blank()),
+    sym("_type_expression") }) },
+
+  { "struct_type", seq({
+    str("struct"),
+    in_braces(repeat(seq({
+      sym("var_name"),
+      sym("_type_expression") }))) }) },
+
+  { "interface_type", seq({
+    str("interface"),
+    in_braces(repeat(seq({
+      sym("var_name"),
+      sym("_func_signature") }))) }) },
+
+  /*
+   * Statements
+   */
+
+  { "_statement", choice({
+    sym("expression_statement"),
+    sym("return_statement"),
+    sym("var_declaration"),
+    sym("short_var_declaration"),
+    sym("range_statement"),
+    sym("if_statement") }) },
+
+  { "return_statement", terminated(seq({
+    str("return"),
+    comma_sep(sym("_expression")) })) },
+
+  { "short_var_declaration", terminated(seq({
+    comma_sep(sym("var_name")),
+    str(":="),
+    sym("_expression") })) },
+
+  { "range_statement", seq({
+    str("for"),
+    sym("var_name"),
+    optional(seq({ str(","), sym("var_name") })),
+    str(":="),
+    str("range"),
+    sym("_expression"),
+    sym("block_statement") }) },
+
+  { "if_statement", seq({
+    str("if"),
+    sym("_expression"),
+    sym("block_statement"),
+    optional(seq({
+      str("else"),
+      choice({
+        sym("if_statement"),
+        sym("block_statement") }) })) }) },
+
+  { "expression_statement", terminated(sym("_expression")) },
+
+  /*
+   * Value expressions
+   */
+
+  { "_expression", choice({
+    sym("call_expression"),
+    sym("selector_expression"),
+    sym("math_op"),
+    sym("bool_op"),
+    sym("number"),
+    sym("string"),
+    sym("var_name") }) },
+
+  { "call_expression", seq({
+    sym("_expression"),
+    in_parens(comma_sep(sym("_expression"))) }) },
+
+  { "selector_expression", seq({
+    sym("_expression"),
+    str("."),
+    sym("var_name") }) },
+
+  { "math_op", choice({
+    infix_op("*", "_expression", 2),
+    infix_op("/", "_expression", 2),
+    infix_op("+", "_expression", 1),
+    infix_op("-", "_expression", 1) }) },
+
+  { "bool_op", choice({
+    infix_op("||", "_expression", 1),
+    infix_op("&&", "_expression", 2),
+    infix_op("==", "_expression", 3),
+    infix_op("<=", "_expression", 3),
+    infix_op("<", "_expression", 3),
+    infix_op(">=", "_expression", 3),
+    infix_op(">", "_expression", 3),
+    prefix_op("!", "_expression", 4) }) },
+
+  { "_func_signature", prec(10, seq({
+    in_parens(comma_sep(seq({
+      comma_sep1(sym("var_name")),
+      sym("_type_expression") }))),
+    choice({
+      in_parens(choice({
+        comma_sep1(seq({ sym("var_name"), sym("type_name") })),
+        comma_sep1(sym("type_name")) })),
+      sym("type_name"),
+    blank() }) })) },
+
+  { "_line_break", str("\n") },
+
+  { "string", delimited("\"") },
+
+  { "package_name", sym("_identifier") },
+
+  { "var_name", sym("_identifier") },
+
+  { "type_name", sym("_identifier") },
+
+  { "_identifier", pattern("\\a[\\w_]*") },
+
+  { "number", pattern("\\d+(\\.\\d+)?") },
+
+  { "comment", pattern("//[^\n]*") },
 
-    { "string", delimited("\"") },
-    { "package_name", sym("_identifier") },
-    { "var_name", sym("_identifier") },
-    { "type_name", sym("_identifier") },
-    { "_identifier", pattern("\\a[\\w_]*") },
-    { "number", pattern("\\d+(\\.\\d+)?") },
-    { "comment", pattern("//[^\n]*") },
 }).ubiquitous_tokens({
-    sym("comment"),
-    sym("_line_break"),
-    pattern("[ \t\r]"),
+  sym("comment"),
+  sym("_line_break"),
+  pattern("[ \t\r]"),
 });
 
 }  // namespace tree_sitter_examples
diff --git a/spec/fixtures/grammars/helpers.cc b/spec/fixtures/grammars/helpers.cc
index 69ce9987..4e1ac550 100644
--- a/spec/fixtures/grammars/helpers.cc
+++ b/spec/fixtures/grammars/helpers.cc
@@ -34,30 +34,30 @@ rule_ptr in_brackets(rule_ptr rule) {
 
 rule_ptr infix_op(std::string op, std::string rule_name, int precedence) {
   return prec(precedence, seq({
-      sym(rule_name),
-      str(op),
-      sym(rule_name) }));
+    sym(rule_name),
+    str(op),
+    sym(rule_name) }));
 }
 
 rule_ptr prefix_op(std::string op, std::string rule_name, int precedence) {
   return prec(precedence, seq({
-      str(op),
-      sym(rule_name) }));
+    str(op),
+    sym(rule_name) }));
 }
 
 rule_ptr postfix_op(std::string op, std::string rule_name, int precedence) {
   return prec(precedence, seq({
-      sym(rule_name),
-      str(op) }));
+    sym(rule_name),
+    str(op) }));
 }
 
 rule_ptr delimited(std::string delimiter) {
   return token(seq({
-      str(delimiter),
-      repeat(choice({
-          pattern("[^" + delimiter + "]"),
-          seq({ str("\\"), str(delimiter) }) })),
-      str(delimiter) }));
+    str(delimiter),
+    repeat(choice({
+      pattern("[^" + delimiter + "]"),
+      seq({ str("\\"), str(delimiter) }) })),
+    str(delimiter) }));
 }
 
 }  // namespace tree_sitter_examples
diff --git a/spec/fixtures/grammars/javascript.cc b/spec/fixtures/grammars/javascript.cc
index 82655fd9..b879509e 100644
--- a/spec/fixtures/grammars/javascript.cc
+++ b/spec/fixtures/grammars/javascript.cc
@@ -5,8 +5,8 @@ namespace tree_sitter_examples {
 
 static rule_ptr terminated(rule_ptr rule) {
   return seq({ rule, choice({
-      sym("_line_break"),
-      str(";") }) });
+    sym("_line_break"),
+    str(";") }) });
 }
 
 enum {
@@ -31,326 +31,327 @@ enum {
 };
 
 extern const Grammar javascript = Grammar({
-    { "program", repeat(sym("_statement")) },
+  { "program", repeat(sym("_statement")) },
 
-    /*
-     *  Statements
-     */
+  /*
+   *  Statements
+   */
 
-    { "_statement", choice({
-        sym("expression_statement"),
-        sym("var_declaration"),
-        sym("statement_block"),
-        sym("if_statement"),
-        sym("switch_statement"),
-        sym("for_statement"),
-        sym("while_statement"),
+  { "_statement", choice({
+    sym("expression_statement"),
+    sym("var_declaration"),
+    sym("statement_block"),
+    sym("if_statement"),
+    sym("switch_statement"),
+    sym("for_statement"),
+    sym("while_statement"),
 
-        sym("for_in_statement"),
-        // sym("do_statement"),
+    sym("for_in_statement"),
+    // sym("do_statement"),
 
-        sym("try_statement"),
-        sym("return_statement"),
-        sym("break_statement"),
-        sym("throw_statement"),
-        sym("delete_statement") }) },
+    sym("try_statement"),
+    sym("return_statement"),
+    sym("break_statement"),
+    sym("throw_statement"),
+    sym("delete_statement") }) },
 
-    { "expression_statement", terminated(err(sym("_expression"))) },
+  { "expression_statement", terminated(err(sym("_expression"))) },
 
-    { "var_declaration", terminated(seq({
-        str("var"),
-        comma_sep1(err(choice({
-            sym("identifier"),
-            sym("var_assignment") }))) })) },
+  { "var_declaration", terminated(seq({
+    str("var"),
+    comma_sep1(err(choice({
+      sym("identifier"),
+      sym("var_assignment") }))) })) },
 
-    { "statement_block", prec(PREC_BLOCK,
-        in_braces(err(repeat(sym("_statement"))))) },
+  { "statement_block", prec(PREC_BLOCK,
+    in_braces(err(repeat(sym("_statement"))))) },
 
-    { "if_statement", prec(0, seq({
-        str("if"),
-        sym("_paren_expression"),
-        sym("_statement"),
-        optional(seq({
-            str("else"),
-            sym("_statement") })) }), AssociativityRight) },
+  { "if_statement", prec(0, seq({
+    str("if"),
+    sym("_paren_expression"),
+    sym("_statement"),
+    optional(seq({
+      str("else"),
+      sym("_statement") })) }), AssociativityRight) },
 
-    { "switch_statement", seq({
-        str("switch"),
-        sym("_paren_expression"),
-        str("{"),
-        repeat(choice({ sym("case"), sym("default") })),
-        str("}") }) },
+  { "switch_statement", seq({
+    str("switch"),
+    sym("_paren_expression"),
+    str("{"),
+    repeat(choice({ sym("case"), sym("default") })),
+    str("}") }) },
 
-    { "for_statement", seq({
-        str("for"),
-        str("("),
-        choice({
-            sym("var_declaration"),
-            seq({ sym("_expression"), str(";") }),
-            str(";") }),
-        optional(err(sym("_expression"))), str(";"),
-        optional(err(sym("_expression"))),
-        str(")"),
-        sym("_statement") }) },
+  { "for_statement", seq({
+    str("for"),
+    str("("),
+    choice({
+      sym("var_declaration"),
+      seq({ sym("_expression"), str(";") }),
+      str(";") }),
+    optional(err(sym("_expression"))), str(";"),
+    optional(err(sym("_expression"))),
+    str(")"),
+    sym("_statement") }) },
 
-    { "for_in_statement", seq({
-        str("for"),
-        str("("),
-        optional(str("var")),
-        prec(PREC_REL, seq({
-          sym("identifier"),
-          str("in"),
-          sym("_expression") })),
-        str(")"),
-        sym("_statement") }) },
+  { "for_in_statement", seq({
+    str("for"),
+    str("("),
+    optional(str("var")),
+    prec(PREC_REL, seq({
+      sym("identifier"),
+      str("in"),
+      sym("_expression") })),
+    str(")"),
+    sym("_statement") }) },
 
-    { "while_statement", seq({
-        str("while"),
-        sym("_paren_expression"),
-        sym("_statement") }) },
+  { "while_statement", seq({
+    str("while"),
+    sym("_paren_expression"),
+    sym("_statement") }) },
 
-    // { "do_statement", seq({
-        // str("do"),
-        // sym("_statement"),
-        // str("while"),
-        // sym("_paren_expression") })},
+  // { "do_statement", seq({
+  //   str("do"),
+  //   sym("_statement"),
+  //   str("while"),
+  //   sym("_paren_expression") })},
 
-    { "try_statement", seq({
-        str("try"),
-        sym("statement_block"),
-        optional(sym("catch")),
-        optional(sym("finally")) }) },
+  { "try_statement", seq({
+    str("try"),
+    sym("statement_block"),
+    optional(sym("catch")),
+    optional(sym("finally")) }) },
 
-    { "return_statement", terminated(seq({
-        str("return"),
-        optional(sym("_expression")) })) },
+  { "return_statement", terminated(seq({
+    str("return"),
+    optional(sym("_expression")) })) },
 
-    { "throw_statement", terminated(seq({
-        str("throw"),
-        sym("_expression") })) },
+  { "throw_statement", terminated(seq({
+    str("throw"),
+    sym("_expression") })) },
 
-    { "break_statement", terminated(str("break")) },
+  { "break_statement", terminated(str("break")) },
 
-    { "delete_statement", terminated(seq({
-        str("delete"),
-        choice({ sym("member_access"), sym("subscript_access") }) })) },
+  { "delete_statement", terminated(seq({
+    str("delete"),
+    choice({ sym("member_access"), sym("subscript_access") }) })) },
 
-    /*
-     *  Statement components
-     */
+  /*
+   *  Statement components
+   */
 
-    { "case", seq({
-        str("case"),
-        sym("_expression"),
-        str(":"),
-        repeat(sym("_statement")) }) },
+  { "case", seq({
+    str("case"),
+    sym("_expression"),
+    str(":"),
+    repeat(sym("_statement")) }) },
 
-    { "default", seq({
-        str("default"),
-        str(":"),
-        repeat(sym("_statement")) }) },
+  { "default", seq({
+    str("default"),
+    str(":"),
+    repeat(sym("_statement")) }) },
 
-    { "catch", seq({
-        str("catch"),
-        str("("),
-        err(sym("identifier")),
-        str(")"),
-        sym("statement_block") }) },
+  { "catch", seq({
+    str("catch"),
+    str("("),
+    err(sym("identifier")),
+    str(")"),
+    sym("statement_block") }) },
 
-    { "finally", seq({
-        str("finally"),
-        sym("statement_block") }) },
+  { "finally", seq({
+    str("finally"),
+    sym("statement_block") }) },
 
-    { "var_assignment", seq({
-        sym("identifier"),
-        str("="),
-        sym("_expression") }) },
+  { "var_assignment", seq({
+    sym("identifier"),
+    str("="),
+    sym("_expression") }) },
 
-    { "_paren_expression", in_parens(err(sym("_expression"))) },
+  { "_paren_expression", in_parens(err(sym("_expression"))) },
 
-    /*
-     *  Expressions
-     */
+  /*
+   *  Expressions
+   */
 
-    { "_expression", choice({
-        sym("object"),
-        sym("array"),
-        sym("function_expression"),
-        sym("function_call"),
-        sym("constructor_call"),
-        sym("member_access"),
-        sym("subscript_access"),
-        sym("assignment"),
-        sym("math_assignment"),
-        sym("ternary"),
-        sym("bool_op"),
-        sym("math_op"),
-        // sym("comma_op"),
+  { "_expression", choice({
+    sym("object"),
+    sym("array"),
+    sym("function_expression"),
+    sym("function_call"),
+    sym("constructor_call"),
+    sym("member_access"),
+    sym("subscript_access"),
+    sym("assignment"),
+    sym("math_assignment"),
+    sym("ternary"),
+    sym("bool_op"),
+    sym("math_op"),
+    // sym("comma_op"),
 
-        // sym("bitwise_op"),
+    // sym("bitwise_op"),
 
-        sym("rel_op"),
-        sym("type_op"),
-        sym("null"),
-        sym("number"),
-        sym("undefined"),
-        sym("regex"),
-        sym("string"),
-        sym("false"),
-        sym("identifier"),
-        sym("true"),
-        sym("_paren_expression") }) },
+    sym("rel_op"),
+    sym("type_op"),
+    sym("null"),
+    sym("number"),
+    sym("undefined"),
+    sym("regex"),
+    sym("string"),
+    sym("false"),
+    sym("identifier"),
+    sym("true"),
+    sym("_paren_expression") }) },
 
-    { "object", in_braces(comma_sep(err(sym("pair")))) },
+  { "object", in_braces(comma_sep(err(sym("pair")))) },
 
-    { "array", in_brackets(comma_sep(err(sym("_expression")))) },
+  { "array", in_brackets(comma_sep(err(sym("_expression")))) },
 
-    { "function_expression", seq({
-        str("function"),
-        optional(sym("identifier")),
-        str("("),
-        optional(sym("formal_parameters")),
-        str(")"),
-        sym("statement_block") }) },
+  { "function_expression", seq({
+    str("function"),
+    optional(sym("identifier")),
+    str("("),
+    optional(sym("formal_parameters")),
+    str(")"),
+    sym("statement_block") }) },
 
-    { "function_call", prec(PREC_CALL, seq({
-        sym("_expression"),
-        sym("arguments") })) },
+  { "function_call", prec(PREC_CALL, seq({
+    sym("_expression"),
+    sym("arguments") })) },
 
-    { "constructor_call", choice({
-        prec(PREC_SHORT_NEW, seq({
-          str("new"),
-          sym("_expression") }), AssociativityRight),
-        prec(PREC_MEMBER, seq({
-          str("new"),
-          sym("_expression"),
-          sym("arguments") }), AssociativityRight) }) },
+  { "constructor_call", choice({
+    prec(PREC_SHORT_NEW, seq({
+      str("new"),
+      sym("_expression") }), AssociativityRight),
+    prec(PREC_MEMBER, seq({
+      str("new"),
+      sym("_expression"),
+      sym("arguments") }), AssociativityRight) }) },
 
-    { "member_access", prec(PREC_MEMBER, seq({
-        sym("_expression"),
-        str("."),
-        sym("identifier") })) },
+  { "member_access", prec(PREC_MEMBER, seq({
+    sym("_expression"),
+    str("."),
+    sym("identifier") })) },
 
-    { "subscript_access", prec(PREC_MEMBER, seq({
-        sym("_expression"),
-        str("["),
-        err(sym("_expression")),
-        str("]") })) },
+  { "subscript_access", prec(PREC_MEMBER, seq({
+    sym("_expression"),
+    str("["),
+    err(sym("_expression")),
+    str("]") })) },
 
-    { "assignment", prec(PREC_ASSIGN, seq({
-        choice({
-            sym("identifier"),
-            sym("member_access"),
-            sym("subscript_access") }),
-        str("="),
-        sym("_expression") }), AssociativityRight) },
+  { "assignment", prec(PREC_ASSIGN, seq({
+    choice({
+      sym("identifier"),
+      sym("member_access"),
+      sym("subscript_access") }),
+    str("="),
+    sym("_expression") }), AssociativityRight) },
 
-    { "math_assignment", prec(PREC_ASSIGN, seq({
-        choice({
-            sym("identifier"),
-            sym("member_access"),
-            sym("subscript_access") }),
-        choice({ str("+="), str("-="), str("*="), str("/=") }),
-        sym("_expression") }), AssociativityRight) },
+  { "math_assignment", prec(PREC_ASSIGN, seq({
+    choice({
+      sym("identifier"),
+      sym("member_access"),
+      sym("subscript_access") }),
+    choice({ str("+="), str("-="), str("*="), str("/=") }),
+    sym("_expression") }), AssociativityRight) },
 
-    { "ternary", prec(PREC_TERNARY, seq({
-        sym("_expression"),
-        str("?"),
-        sym("_expression"),
-        str(":"),
-        sym("_expression") }), AssociativityRight) },
+  { "ternary", prec(PREC_TERNARY, seq({
+    sym("_expression"),
+    str("?"),
+    sym("_expression"),
+    str(":"),
+    sym("_expression") }), AssociativityRight) },
 
-    { "bool_op", choice({
-        infix_op("||", "_expression", PREC_OR),
-        infix_op("&&", "_expression", PREC_AND),
-        prefix_op("!", "_expression", PREC_NOT) }) },
+  { "bool_op", choice({
+    infix_op("||", "_expression", PREC_OR),
+    infix_op("&&", "_expression", PREC_AND),
+    prefix_op("!", "_expression", PREC_NOT) }) },
 
-    { "comma_op", infix_op(",", "_expression", PREC_COMMA) },
+  { "comma_op", infix_op(",", "_expression", PREC_COMMA) },
 
-    { "math_op", choice({
+  { "math_op", choice({
 
-        // prefix_op("+", "_expression", PREC_SIGN),
-        // prefix_op("-", "_expression", PREC_SIGN),
+    // prefix_op("+", "_expression", PREC_SIGN),
+    // prefix_op("-", "_expression", PREC_SIGN),
 
-        postfix_op("++", "_expression", PREC_INC),
-        postfix_op("--", "_expression", PREC_INC),
-        infix_op("*", "_expression", PREC_MULT),
-        infix_op("/", "_expression", PREC_MULT),
-        infix_op("+", "_expression", PREC_ADD),
-        infix_op("-", "_expression", PREC_ADD) }) },
+    postfix_op("++", "_expression", PREC_INC),
+    postfix_op("--", "_expression", PREC_INC),
+    infix_op("*", "_expression", PREC_MULT),
+    infix_op("/", "_expression", PREC_MULT),
+    infix_op("+", "_expression", PREC_ADD),
+    infix_op("-", "_expression", PREC_ADD) }) },
 
-    // { "bitwise_op", choice({
-        // infix_op("&", "_expression", PREC_MULT),
-        // infix_op("|", "_expression", PREC_MULT),
-        // infix_op("<<", "_expression", PREC_MULT),
-        // infix_op(">>", "_expression", PREC_MULT) }) },
+  // { "bitwise_op", choice({
+    // infix_op("&", "_expression", PREC_MULT),
+    // infix_op("|", "_expression", PREC_MULT),
+    // infix_op("<<", "_expression", PREC_MULT),
+    // infix_op(">>", "_expression", PREC_MULT) }) },
 
-    { "rel_op", choice({
+  { "rel_op", choice({
 
-        // infix_op("==", "_expression", PREC_REL),
-        // infix_op("!=", "_expression", PREC_REL),
-        // infix_op("<=", "_expression", PREC_REL),
-        // infix_op(">=", "_expression", PREC_REL),
+    // infix_op("==", "_expression", PREC_REL),
+    // infix_op("!=", "_expression", PREC_REL),
+    // infix_op("<=", "_expression", PREC_REL),
+    // infix_op(">=", "_expression", PREC_REL),
 
-        infix_op("===", "_expression", PREC_REL),
-        infix_op("!==", "_expression", PREC_REL),
-        infix_op("<", "_expression", PREC_REL),
-        infix_op(">", "_expression", PREC_REL) }) },
+    infix_op("===", "_expression", PREC_REL),
+    infix_op("!==", "_expression", PREC_REL),
+    infix_op("<", "_expression", PREC_REL),
+    infix_op(">", "_expression", PREC_REL) }) },
 
-    { "type_op", choice({
-        prec(PREC_REL, seq({
-          choice({ sym("_expression"), sym("identifier") }),
-          str("in"),
-          sym("_expression") })),
-        infix_op("instanceof", "_expression", PREC_REL),
-        prefix_op("typeof", "_expression", PREC_TYPE) }) },
+  { "type_op", choice({
+    prec(PREC_REL, seq({
+      choice({ sym("_expression"), sym("identifier") }),
+      str("in"),
+      sym("_expression") })),
+    infix_op("instanceof", "_expression", PREC_REL),
+    prefix_op("typeof", "_expression", PREC_TYPE) }) },
 
-    /*
-     *  Primitives
-     */
+  /*
+   *  Primitives
+   */
 
-    { "comment", token(choice({
-        seq({
-            str("/*"),
-            repeat(pattern("[^*]|(*[^/])")),
-            str("*/") }),
-        pattern("//[^\n]*") })) },
+  { "comment", token(choice({
+    seq({
+      str("/*"),
+      repeat(pattern("[^*]|(*[^/])")),
+      str("*/") }),
+    pattern("//[^\n]*") })) },
 
-    { "string", token(choice({
-        delimited("\""),
-        delimited("'") })) },
+  { "string", token(choice({
+    delimited("\""),
+    delimited("'") })) },
 
-    { "regex", token(seq({ delimited("/"), optional(str("g")) })) },
+  { "regex", token(seq({ delimited("/"), optional(str("g")) })) },
 
-    { "number", pattern("\\d+(\\.\\d+)?") },
+  { "number", pattern("\\d+(\\.\\d+)?") },
 
-    { "identifier", pattern("[\\a_$][\\w_$]*") },
+  { "identifier", pattern("[\\a_$][\\w_$]*") },
 
-    { "null", str("null") },
-    { "undefined", str("undefined") },
-    { "true", str("true") },
-    { "false", str("false") },
-    { "_line_break", str("\n") },
+  { "null", str("null") },
+  { "undefined", str("undefined") },
+  { "true", str("true") },
+  { "false", str("false") },
+  { "_line_break", str("\n") },
 
-    /*
-     *  Expression components
-     */
+  /*
+   *  Expression components
+   */
 
-    { "formal_parameters", comma_sep1(sym("identifier")) },
+  { "formal_parameters", comma_sep1(sym("identifier")) },
 
-    { "arguments", prec(PREC_ARGS, seq({
-        str("("),
-        comma_sep(err(sym("_expression"))),
-        str(")") })) },
+  { "arguments", prec(PREC_ARGS, seq({
+    str("("),
+    comma_sep(err(sym("_expression"))),
+    str(")") })) },
+
+  { "pair", seq({
+    choice({ sym("string"), sym("identifier") }),
+    str(":"),
+    sym("_expression") }) },
 
-    { "pair", seq({
-        choice({ sym("string"), sym("identifier") }),
-        str(":"),
-        sym("_expression") }) },
 }).ubiquitous_tokens({
-    sym("comment"),
-    sym("_line_break"),
-    pattern("[ \t\r]"),
+  sym("comment"),
+  sym("_line_break"),
+  pattern("[ \t\r]"),
 });
 
 }  // namespace tree_sitter_examples
diff --git a/spec/fixtures/grammars/json.cc b/spec/fixtures/grammars/json.cc
index 9737f094..0d31a12b 100644
--- a/spec/fixtures/grammars/json.cc
+++ b/spec/fixtures/grammars/json.cc
@@ -4,26 +4,26 @@
 namespace tree_sitter_examples {
 
 extern const Grammar json = Grammar({
-    { "_value", choice({
-        sym("object"),
-        sym("array"),
-        sym("string"),
-        sym("number"),
-        sym("true"),
-        sym("false"),
-        sym("null"), }) },
-    { "object", in_braces(comma_sep(err(seq({
-        sym("string"),
-        str(":"),
-        sym("_value") })))) },
-    { "array", in_brackets(comma_sep(err(sym("_value")))) },
-    { "string", pattern("\"([^\"]|\\\\\")*\"") },
-    { "number", pattern("\\d+(\\.\\d+)?") },
-    { "null", str("null") },
-    { "true", str("true") },
-    { "false", str("false") },
+  { "_value", choice({
+    sym("object"),
+    sym("array"),
+    sym("string"),
+    sym("number"),
+    sym("true"),
+    sym("false"),
+    sym("null"), }) },
+  { "object", in_braces(comma_sep(err(seq({
+    sym("string"),
+    str(":"),
+    sym("_value") })))) },
+  { "array", in_brackets(comma_sep(err(sym("_value")))) },
+  { "string", pattern("\"([^\"]|\\\\\")*\"") },
+  { "number", pattern("\\d+(\\.\\d+)?") },
+  { "null", str("null") },
+  { "true", str("true") },
+  { "false", str("false") },
 }).ubiquitous_tokens({
-    pattern("\\s"),
+  pattern("\\s"),
 });
 
 }  // namespace tree_sitter_examples