Convert some of the fixture grammars from JSON to JS

These tests are easier to write and maintain if the grammars are just JS,
like grammars normally are. It doesn't slow the tests down significantly
to shell out to `node` for each of these grammars.

Author: maxbrunsfeld

cli/src/generate/mod.rs

@@ -157,7 +157,7 @@ fn generate_parser_for_grammar_with_opts(
     })
 }
 
-fn load_grammar_file(grammar_path: &Path) -> Result<String> {
+pub fn load_grammar_file(grammar_path: &Path) -> Result<String> {
     match grammar_path.extension().and_then(|e| e.to_str()) {
         Some("js") => Ok(load_js_grammar_file(grammar_path)?),
         Some("json") => Ok(fs::read_to_string(grammar_path)?),

cli/src/tests/corpus_test.rs

@@ -269,9 +269,12 @@ fn test_feature_corpus_files() {
         }
 
         let test_path = entry.path();
-        let grammar_path = test_path.join("grammar.json");
+        let mut grammar_path = test_path.join("grammar.js");
+        if !grammar_path.exists() {
+            grammar_path = test_path.join("grammar.json");
+        }
         let error_message_path = test_path.join("expected_error.txt");
-        let grammar_json = fs::read_to_string(grammar_path).unwrap();
+        let grammar_json = generate::load_grammar_file(&grammar_path).unwrap();
         let generate_result = generate::generate_parser_for_grammar(&grammar_json);
 
         if error_message_path.exists() {

test/fixtures/test_grammars/aliased_inlined_rules/corpus.txt

@@ -2,12 +2,13 @@
 OK
 =========================
 
-a.b.c
+a.b.c;
 
 ---
 
-(expression (member_expression
-  (expression (member_expression
-    (expression (variable_name))
+(statement
+  (member_expression
+    (member_expression
+      (variable_name)
+      (property_name))
     (property_name)))
-  (property_name)))

test/fixtures/test_grammars/aliased_inlined_rules/grammar.js

@@ -0,0 +1,28 @@
+// This grammar shows that `ALIAS` rules can *contain* a rule that is marked as `inline`. It also
+// shows that you can alias a rule that would otherwise be anonymous, and it will then appear as a
+// named node.
+
+module.exports = grammar({
+    name: 'aliased_inlined_rules',
+
+    extras: $ => [/\s/],
+
+    inline: $ => [$.identifier],
+
+    rules: {
+        statement: $ => seq($._expression, ';'),
+
+        _expression: $ => choice(
+            $.member_expression,
+            alias($.identifier, $.variable_name),
+        ),
+
+        member_expression: $ => prec.left(1, seq(
+            $._expression,
+            '.',
+            alias($.identifier, $.property_name)
+        )),
+
+        identifier: $ => choice('a', 'b', 'c')
+    }
+});

test/fixtures/test_grammars/aliased_inlined_rules/grammar.json

@@ -0,0 +1,30 @@
+module.exports = grammar({
+    name: 'aliased_rules',
+
+    extras: $ => [/\s/],
+
+    rules: {
+        statement: $ => seq($._expression, ';'),
+
+        _expression: $ => choice(
+            $.call_expression,
+            $.member_expression,
+            alias($.identifier, $.variable_name),
+        ),
+
+        call_expression: $ => prec.left(seq(
+            $._expression,
+            '(',
+            $._expression,
+            ')'
+        )),
+
+        member_expression: $ => prec.left(1, seq(
+            $._expression,
+            '.',
+            alias($.identifier, $.property_name)
+        )),
+
+        identifier: $ => /[a-z]+/
+    }
+});

test/fixtures/test_grammars/aliased_inlined_rules/readme.md

@@ -0,0 +1,16 @@
+// This grammar shows that `ALIAS` rules can be applied directly to `TOKEN` and `IMMEDIATE_TOKEN`
+// rules.
+
+module.exports = grammar({
+    name: 'aliased_token_rules',
+
+    extras: $ => [/\s/],
+
+    rules: {
+        expression: $ => seq(
+            'a',
+            alias(token(seq('b', 'c')), $.X),
+            alias(token.immediate(seq('d', 'e')), $.Y),
+        ),
+    }
+});