Add ternary expressions to javascript grammar

examples/grammars/javascript.cc

@@ -19,12 +19,13 @@ namespace tree_sitter_examples {
     static rule_ptr comma_sep(rule_ptr element) {
         return choice({
             seq({ element, repeat(seq({ str(","), element })) }),
-            blank(),
-        });
+            blank() });
     }
 
     extern const Grammar javascript({
         { "program", repeat(sym("statement")) },
+
+        // Statements
         { "statement", choice({
             sym("statement_block"),
             sym("if_statement"),
@@ -33,8 +34,6 @@ namespace tree_sitter_examples {
             sym("break_statement"),
             sym("var_declaration"),
             sym("expression_statement") }) },
-
-        // Statements
         { "statement_block", in_braces(err(repeat(sym("statement")))) },
         { "for_statement", seq({
             sym("_for"),
@@ -53,9 +52,9 @@ namespace tree_sitter_examples {
             err(sym("expression")),
             str(")"),
             sym("statement"),
-            optional(seq({
+            optional(prec(1, seq({
                 sym("_else"),
-                sym("statement") })) }) },
+                sym("statement") }))) }) },
         { "switch_statement", seq({
             sym("_switch"),
             str("("),
@@ -84,22 +83,28 @@ namespace tree_sitter_examples {
         { "expression_statement", seq({
             err(sym("expression")),
             sym("_terminator") }) },
+
+        // Expressions
         { "expression", choice({
             sym("function_expression"),
             sym("function_call"),
             sym("property_access"),
             sym("assignment"),
+            sym("ternary"),
             sym("literal"),
             sym("identifier") }) },
-
-        // Expressions
-        { "assignment", seq({
+        { "ternary", seq({
+            sym("expression"),
+            str("?"),
+            sym("expression"),
+            str(":"),
+            sym("expression") }) },
+        { "assignment", prec(-1, seq({
             choice({
                 sym("identifier"),
-                sym("property_access"),
-            }),
+                sym("property_access") }),
             str("="),
-            sym("expression") })},
+            sym("expression") })) },
         { "function_expression", seq({
             sym("_function"),
             optional(sym("identifier")),

spec/runtime/languages/javascript/operators.txt

@@ -0,0 +1,9 @@
+==========================================
+parses ternary expressions
+==========================================
+print(isDone() ? stuff : otherStuff);
+---
+(program (expression_statement
+    (function_call
+        (identifier)
+        (ternary (function_call (identifier)) (identifier) (identifier)))))

src/compiler/build_tables/rule_transitions.cc

@@ -1,5 +1,4 @@
 #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"
@@ -15,12 +14,10 @@
 
 namespace tree_sitter {
     using std::map;
-    using std::set;
     using std::make_shared;
     using rules::rule_ptr;
     using rules::ISymbol;
     using rules::CharacterSet;
-    using rules::Metadata;
 
     namespace build_tables {
         template<typename T>
@@ -29,14 +26,14 @@ namespace tree_sitter {
         template<>
         void merge_transitions(map<CharacterSet, rule_ptr> &left, const map<CharacterSet, rule_ptr> &right) {
             merge_char_transitions<rule_ptr>(left, right, [](rule_ptr left, rule_ptr right) {
-                return make_shared<rules::Choice>(left, right);
+                return rules::Choice::Build({ left, right });
             });
         }
 
         template<>
         void merge_transitions(map<ISymbol, rule_ptr> &left, const map<ISymbol, rule_ptr> &right) {
             merge_sym_transitions<rule_ptr>(left, right, [](rule_ptr left, rule_ptr right) {
-                return make_shared<rules::Choice>(left, right);
+                return rules::Choice::Build({ left, right });
             });
         }
 
@@ -92,7 +89,7 @@ namespace tree_sitter {
             map<T, rule_ptr> apply_to(const rules::Metadata *rule) {
                 auto result = this->apply(rule->rule);
                 transform_transitions(result, [&](const rule_ptr &to_rule) {
-                    return make_shared<Metadata>(to_rule, rule->value);
+                    return make_shared<rules::Metadata>(to_rule, rule->value);
                 });
                 return result;
             }
@@ -102,7 +99,7 @@ namespace tree_sitter {
                 for (char val : rule->value)
                     result = rules::Seq::Build({
                         result,
-                        make_shared<CharacterSet>(set<rules::CharacterRange>({ val }))
+                        CharacterSet({ val }).copy()
                     });
                 return this->apply(result);
             }