tree-sitter 0.0.1 → 0.1.0

data/ext/tree-sitter/tree-sitter/{spec → test}/fixtures/error_corpus/json_errors.txt

@@ -25,10 +25,11 @@ errors inside arrays
 [1, , 2]
 
 ---
-(array
+
+(value (array
   (number)
   (ERROR)
-  (number))
+  (number)))
 
 ==========================================
 errors inside objects
@@ -38,19 +39,21 @@ errors inside objects
 
 ---
 
-(object (pair (string) (number)) (ERROR (UNEXPECTED 'o')))
+(value (object
+  (pair (string) (number))
+  (ERROR (UNEXPECTED 'o'))))
 
 ==========================================
 errors inside nested objects
 ==========================================
 
-{ "key1": { "key2": 1, 2 }, [, "key3": 3 }
+{ "key1": { "key2": 1, 2 }, "key3": 3 [ }
 
 ---
 
-(object
+(value (object
   (pair (string) (object
     (pair (string) (number))
     (ERROR (number))))
-  (ERROR)
-  (pair (string) (number)))
+  (pair (string) (number))
+  (ERROR)))

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_inlined_rules/corpus.txt

@@ -0,0 +1,13 @@
+=========================
+OK
+=========================
+
+a.b.c
+
+---
+
+(expression (member_expression
+  (expression (member_expression
+    (expression (variable_name))
+    (property_name)))
+  (property_name)))

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_inlined_rules/grammar.json

@@ -0,0 +1,59 @@
+{
+  "name": "aliased_inlined_rules",
+
+  "extras": [
+    {"type": "PATTERN", "value": "\\s"}
+  ],
+
+  "inline": [
+    "identifier"
+  ],
+
+  "rules": {
+    "expression": {
+      "type": "CHOICE",
+      "members": [
+        {"type": "SYMBOL", "name": "member_expression"},
+        {
+          "type": "ALIAS",
+          "value": "variable_name",
+          "named": true,
+          "content": {
+            "type": "SYMBOL",
+            "name": "identifier"
+          }
+        }
+      ]
+    },
+
+    "member_expression": {
+      "type": "PREC_LEFT",
+      "value": 1,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {"type": "SYMBOL", "name": "expression"},
+          {"type": "STRING", "value": "."},
+          {
+            "type": "ALIAS",
+            "value": "property_name",
+            "named": true,
+            "content": {
+              "type": "SYMBOL",
+              "name": "identifier"
+            }
+          }
+        ]
+      }
+    },
+
+    "identifier": {
+      "type": "CHOICE",
+      "members": [
+        {"type": "STRING", "value": "a"},
+        {"type": "STRING", "value": "b"},
+        {"type": "STRING", "value": "c"}
+      ]
+    }
+  }
+}

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_inlined_rules/readme.md

@@ -0,0 +1 @@
+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.

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_rules/corpus.txt

@@ -0,0 +1,18 @@
+======================================
+Method calls
+======================================
+
+a.b(c(d.e));
+
+---
+
+(statement
+  (call_expression
+    (member_expression
+      (variable_name)
+      (property_name))
+    (call_expression
+      (variable_name)
+      (member_expression
+        (variable_name)
+        (property_name)))))

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_rules/grammar.json

@@ -0,0 +1,71 @@
+{
+  "name": "aliased_rules",
+
+  "extras": [
+    {"type": "PATTERN", "value": "\\s"}
+  ],
+
+  "rules": {
+    "statement": {
+      "type": "SEQ",
+      "members": [
+        {"type": "SYMBOL", "name": "_expression"},
+        {"type": "STRING", "value": ";"}
+      ]
+    },
+
+    "_expression": {
+      "type": "CHOICE",
+      "members": [
+        {"type": "SYMBOL", "name": "call_expression"},
+        {"type": "SYMBOL", "name": "member_expression"},
+        {
+          "type": "ALIAS",
+          "named": true,
+          "value": "variable_name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "identifier"
+          }
+        }
+      ]
+    },
+
+    "call_expression": {
+      "type": "PREC_LEFT",
+      "value": 0,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {"type": "SYMBOL", "name": "_expression"},
+          {"type": "STRING", "value": "("},
+          {"type": "SYMBOL", "name": "_expression"},
+          {"type": "STRING", "value": ")"},
+        ]
+      }
+    },
+
+    "member_expression": {
+      "type": "PREC_LEFT",
+      "value": 1,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {"type": "SYMBOL", "name": "_expression"},
+          {"type": "STRING", "value": "."},
+          {
+            "type": "ALIAS",
+            "named": true,
+            "value": "property_name",
+            "content": {
+              "type": "SYMBOL",
+              "name": "identifier"
+            }
+          }
+        ]
+      }
+    },
+
+    "identifier": {"type": "PATTERN", "value": "[a-z]+"}
+  }
+}

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_unit_reductions/corpus.txt

@@ -0,0 +1,12 @@
+==========================================
+Aliases on rules that are unit reductions
+==========================================
+
+one two three;
+
+---
+
+(statement
+  (identifier)
+  (b_prime (identifier))
+  (c_prime (identifier)))

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_unit_reductions/grammar.json

@@ -0,0 +1,70 @@
+{
+  "name": "aliased_unit_reductions",
+
+  "extras": [
+    {"type": "PATTERN", "value": "\\s"}
+  ],
+
+  "rules": {
+    "statement": {
+      "type": "SEQ",
+      "members": [
+        {"type": "SYMBOL", "name": "_a"},
+        {
+          "type": "ALIAS",
+          "named": true,
+          "value": "b_prime",
+          "content": {
+            "type": "SYMBOL",
+            "name": "_b"
+          }
+        },
+        {
+          "type": "ALIAS",
+          "named": true,
+          "value": "c_prime",
+          "content": {
+            "type": "SYMBOL",
+            "name": "_c"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": ";"
+        }
+      ]
+    },
+
+    "_a": {
+      "type": "SYMBOL",
+      "name": "_A"
+    },
+
+    "_A": {
+      "type": "SYMBOL",
+      "name": "identifier"
+    },
+
+    "_b": {
+      "type": "SYMBOL",
+      "name": "_B"
+    },
+
+    "_B": {
+      "type": "SYMBOL",
+      "name": "identifier"
+    },
+
+    "_c": {
+      "type": "SYMBOL",
+      "name": "_B"
+    },
+
+    "_C": {
+      "type": "SYMBOL",
+      "name": "identifier"
+    },
+
+    "identifier": {"type": "PATTERN", "value": "[a-z]+"}
+  }
+}

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/aliased_unit_reductions/readme.md

@@ -0,0 +1,5 @@
+Normally, when there are invisible rules (rules whose names start with an `_`) that simply
+wrap another rule, there is an optimization at parser-generation time called *Unit Reduction Elimination* that avoids creating nodes for those rules at runtime. One case where this
+optimization must *not* be applied is when those invisible rules are going to be aliased
+within their parent rule. In that situation, eliminating the invisible node could cause
+the alias to be incorrectly applied to its child.

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/anonymous_tokens_with_escaped_chars/corpus.txt

@@ -0,0 +1,32 @@
+================================================
+anonymous tokens defined with character classes
+================================================
+1234
+---
+
+(first_rule)
+
+=================================================
+anonymous tokens defined with LF escape sequence
+=================================================
+
+
+---
+
+(first_rule)
+
+=================================================
+anonymous tokens defined with CR escape sequence
+=================================================
+
+---
+
+(first_rule)
+
+================================================
+anonymous tokens with quotes
+================================================
+'hello'
+---
+
+(first_rule)

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/anonymous_tokens_with_escaped_chars/grammar.json

@@ -0,0 +1,14 @@
+{
+  "name": "anonymous_tokens_with_escaped_chars",
+  "rules": {
+    "first_rule": {
+      "type": "CHOICE",
+      "members": [
+        {"type": "STRING", "value": "\n"},
+        {"type": "STRING", "value": "\r"},
+        {"type": "STRING", "value": "'hello'"},
+        {"type": "PATTERN", "value": "\\d+"}
+      ]
+    }
+  }
+}

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/anonymous_tokens_with_escaped_chars/readme.md

@@ -0,0 +1 @@
+Every token in a grammar is given a name in the generated parser. Anonymous tokens (tokens specified directly in the body of some larger rule) are named according their content. So when tokens contains characters that aren't valid in a C string literal, we need to escape those characters. This grammar tests that this escaping works. The test is basically that the generated parser compiles succesfully.

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/associativity_left/corpus.txt

@@ -0,0 +1,8 @@
+===================
+chained operations
+===================
+x+y+z
+---
+(expression (math_operation
+  (expression (math_operation (expression (identifier)) (expression (identifier))))
+  (expression (identifier))))

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/associativity_left/grammar.json

@@ -0,0 +1,31 @@
+{
+  "name": "associativity_left",
+
+  "rules": {
+    "expression": {
+      "type": "CHOICE",
+      "members": [
+        {"type": "SYMBOL", "name": "math_operation"},
+        {"type": "SYMBOL", "name": "identifier"}
+      ]
+    },
+
+    "math_operation": {
+      "type": "PREC_LEFT",
+      "value": 0,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {"type": "SYMBOL", "name": "expression"},
+          {"type": "STRING", "value": "+"},
+          {"type": "SYMBOL", "name": "expression"}
+        ]
+      }
+    },
+
+    "identifier": {
+      "type": "PATTERN",
+      "value": "[a-zA-Z]+"
+    }
+  }
+}

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/associativity_missing/expected_error.txt

@@ -0,0 +1,13 @@
+Unresolved conflict for symbol sequence:
+
+  expression  '+'  expression  •  '+'  …
+
+Possible interpretations:
+
+  1:  expression  '+'  (math_operation  expression  •  '+'  expression)
+  2:  (math_operation  expression  '+'  expression)  •  '+'  …
+
+Possible resolutions:
+
+  1:  Specify a left or right associativity in `math_operation`
+  2:  Add a conflict for these rules: `math_operation`

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/associativity_missing/grammar.json

@@ -0,0 +1,27 @@
+{
+  "name": "associativity_missing",
+
+  "rules": {
+    "expression": {
+      "type": "CHOICE",
+      "members": [
+        {"type": "SYMBOL", "name": "math_operation"},
+        {"type": "SYMBOL", "name": "identifier"}
+      ]
+    },
+
+    "math_operation": {
+      "type": "SEQ",
+      "members": [
+        {"type": "SYMBOL", "name": "expression"},
+        {"type": "STRING", "value": "+"},
+        {"type": "SYMBOL", "name": "expression"}
+      ]
+    },
+
+    "identifier": {
+      "type": "PATTERN",
+      "value": "[a-zA-Z]+"
+    }
+  }
+}

data/ext/tree-sitter/tree-sitter/test/fixtures/test_grammars/associativity_right/corpus.txt

@@ -0,0 +1,8 @@
+===================
+chained operations
+===================
+x+y+z
+---
+(expression (math_operation
+  (expression (identifier))
+  (expression (math_operation (expression (identifier)) (expression (identifier))))))