Parse '.' in regexes

examples/grammars/golang.cc

@@ -119,6 +119,6 @@ namespace tree_sitter_examples {
         { "var_name", sym("_identifier") },
         { "type_name", sym("_identifier") },
         { "_identifier", pattern("\\a[\\w_]*") },
-        { "number", pattern("\\d+(.\\d+)?") },
+        { "number", pattern("\\d+(\\.\\d+)?") },
     });
 }

examples/grammars/javascript.cc

@@ -179,6 +179,6 @@ namespace tree_sitter_examples {
         { "_terminator", pattern("[;\n]") },
         { "string", pattern("\"([^\"]|\\\\\")+\"") },
         { "identifier", pattern("\\a[\\w_$]*") },
-        { "number", pattern("\\d+(.\\d+)?") },
+        { "number", pattern("\\d+(\\.\\d+)?") },
     });
 }

examples/grammars/json.cc

@@ -32,7 +32,7 @@ namespace tree_sitter_examples {
             comma_sep(err(sym("value"))),
             str("]"), }) },
         { "string", pattern("\"([^\"]|\\\\\")+\"") },
-        { "number", pattern("\\d+(.\\d+)?") },
+        { "number", pattern("\\d+(\\.\\d+)?") },
         { "null", str("null") },
         { "true", str("true") },
         { "false", str("false") },

spec/compiler/rules/pattern_spec.cc

@@ -6,7 +6,7 @@ using namespace rules;
 
 START_TEST
 
-describe("parsing pattern rules", []() {
+describe("parsing regex pattern rules", []() {
     it("parses simple strings", [&]() {
         Pattern rule("abc");
         AssertThat(
@@ -17,6 +17,13 @@ describe("parsing pattern rules", []() {
                 character({ 'c' })
             })));
     });
+    
+    it("parses wildcard '.' characters", [&]() {
+        Pattern rule(".");
+        AssertThat(
+            rule.to_rule_tree(),
+            EqualsPointer(CharacterSet({'\n'}).complement().copy()));
+    });
 
     it("parses character classes", []() {
         Pattern rule("\\w-\\d");
@@ -114,6 +121,15 @@ describe("parsing pattern rules", []() {
                 character({ '(' }),
                 character({ 'b' })
             })));
+        
+        Pattern rule2("a\\.");
+        AssertThat(
+            rule2.to_rule_tree(),
+            EqualsPointer(seq({
+                character({ 'a' }),
+                character({ '.' }),
+            })));
+
     });
 
     it("parses repeating rules", []() {

src/compiler/rules/pattern.cc

@@ -87,6 +87,10 @@ namespace tree_sitter {
                     case ')':
                         error = "mismatched parens";
                         break;
+                    case '.':
+                        result = CharacterSet({ '\n' }).complement().copy();
+                        next();
+                        break;
                     default:
                         result = single_char().copy();
                 }
@@ -130,10 +134,6 @@ namespace tree_sitter {
 
             CharacterSet escaped_char(char value) {
                 switch (value) {
-                    case '\\':
-                    case '(':
-                    case ')':
-                        return CharacterSet({ value });
                     case 'a':
                         return CharacterSet({ {'a', 'z'}, {'A', 'Z'} });
                     case 'w':
@@ -141,8 +141,7 @@ namespace tree_sitter {
                     case 'd':
                         return CharacterSet({ {'0', '9'} });
                     default:
-                        error = "unrecognized escape sequence";
-                        return CharacterSet();
+                        return CharacterSet({ value });
                 }
             }