Add more expressions, statements to golang grammar

examples/grammars/golang.cc

@@ -43,7 +43,7 @@ namespace tree_sitter_examples {
             sym("var_name"),
             sym("_func_signature"),
             sym("statement_block") })) },
-        { "statement_block", in_braces(blank()) },
+        { "statement_block", in_braces(err(repeat(sym("statement")))) },
         { "type_expression", choice({
             sym("pointer_type"),
             sym("slice_type"),
@@ -58,13 +58,10 @@ namespace tree_sitter_examples {
             sym("type_expression") }) },
         { "map_type", seq({
             keyword("map"),
-            str("["),
-            sym("type_expression"),
-            str("]"),
+            in_brackets(sym("type_expression")),
             sym("type_expression") }) },
         { "slice_type", seq({
-            str("["),
-            str("]"),
+            in_brackets(blank()),
             sym("type_expression") }) },
         { "struct_type", seq({
             keyword("struct"),
@@ -77,13 +74,31 @@ namespace tree_sitter_examples {
                 sym("var_name"),
                 sym("_func_signature") }))) }) },
 
+        // Statements
+        { "statement", choice({
+            sym("expression_statement"),
+            sym("return_statement") }) },
+        { "return_statement", seq({
+            keyword("return"),
+            comma_sep(sym("expression")) }) },
+        { "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),

spec/runtime/languages/golang/flow_control.txt

@@ -0,0 +1,52 @@
+==========================================
+parses function calls
+==========================================
+package main
+
+func main() {
+    println("1", 2)
+    println()
+}
+---
+(program
+    (package_directive (package_name))
+    (func_declaration (var_name) (statement_block
+        (expression_statement (call_expression (var_name) (string) (number)))
+        (expression_statement (call_expression (var_name))))))
+
+============================================
+parses selector expressions
+============================================
+package main
+
+func main() {
+    x.SomeMethod(x.SomeField, x.OtherField.NestedField);
+}
+---
+(program
+    (package_directive (package_name))
+    (func_declaration (var_name) (statement_block
+        (expression_statement (call_expression
+            (selector_expression (var_name) (var_name))
+            (selector_expression (var_name) (var_name))
+            (selector_expression (selector_expression (var_name) (var_name)) (var_name)))))))
+
+============================================
+parses return statements
+============================================
+package main
+
+func main() {
+    return
+}
+
+func helper() {
+    return 1, two, "three"
+}
+---
+(program
+    (package_directive (package_name))
+    (func_declaration (var_name) (statement_block
+        (return_statement)))
+    (func_declaration (var_name) (statement_block
+        (return_statement (number) (var_name) (string)))))

src/compiler/prepared_grammar.cc

@@ -37,7 +37,7 @@ namespace tree_sitter {
 
     bool PreparedGrammar::operator==(const PreparedGrammar &other) const {
         if (other.rules_.size() != rules_.size()) return false;
-        
+
         for (size_t i = 0; i < rules_.size(); i++) {
             auto &pair = rules_[i];
             auto &other_pair = other.rules_[i];
@@ -56,7 +56,7 @@ namespace tree_sitter {
 
         return true;
     }
-    
+
     const vector<pair<string, rule_ptr>> & PreparedGrammar::rules() const {
         return rules_;
     }
@@ -64,16 +64,16 @@ namespace tree_sitter {
     const vector<pair<string, rule_ptr>> & PreparedGrammar::aux_rules() const {
         return aux_rules_;
     }
-    
+
     const vector<Symbol> & PreparedGrammar::ubiquitous_tokens() const {
         return ubiquitous_tokens_;
     }
-    
+
     const PreparedGrammar & PreparedGrammar::ubiquitous_tokens(const vector<Symbol> &ubiquitous_tokens) {
         ubiquitous_tokens_ = ubiquitous_tokens;
         return *this;
     }
-    
+
     ostream& operator<<(ostream &stream, const PreparedGrammar &grammar) {
         stream << string("#<grammar");