Issue 37 more (#43)

Work in progress on #37

.vscode/launch.json

@@ -17,6 +17,19 @@
       "environment": [],
       "console": "internalConsole",
     },
+    {
+      "name": "Debug Parser Perf (Windows)",
+      "type": "cppvsdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/build/debug/parser-perf.exe",
+      "args": [
+        "${workspaceFolder}/eohippus-vscode/test_folder/main.pony"
+      ],
+      "stopAtEntry": false,
+      "cwd": "${workspaceFolder}",
+      "environment": [],
+      "console": "internalConsole",
+    },
     {
       "name": "Debug CLI (Windows)",
       "type": "cppvsdbg",

corral.json

@@ -4,12 +4,12 @@
   ],
   "deps": [
     {
-      "locator": "github.com/ponylang/appdirs.git",
-      "version": "0.1.5"
+      "locator": "github.com/chalcolith/kiuatan.git",
+      "version": "1.5.5"
     },
     {
-      "locator": "github.com/chalcolith/kiuatan.git",
-      "version": "1.5.2"
+      "locator": "github.com/ponylang/appdirs.git",
+      "version": "0.1.5"
     },
     {
       "locator": "github.com/ponylang/logger.git",

eohippus/ast/exp_match.pony

@@ -73,64 +73,98 @@ primitive ParseExpMatch
       end
     ExpMatch(expression, cases, else_block)
 
-class val MatchCase is NodeData
-  """A case in a `match` expression."""
+class val MatchPattern is NodeData
   let pattern: NodeWith[Expression]
   let condition: (NodeWith[Expression] | None)
-  let body: NodeWith[Expression]
 
   new val create(
     pattern': NodeWith[Expression],
-    condition': (NodeWith[Expression] | None),
-    body': NodeWith[Expression])
+    condition': (NodeWith[Expression] | None))
   =>
     pattern = pattern'
     condition = condition'
-    body = body'
 
-  fun name(): String => "MatchCase"
+  fun name(): String => "MatchPattern"
 
   fun val clone(updates: ChildUpdateMap): NodeData =>
-    MatchCase(
+    MatchPattern(
       _map_with[Expression](pattern, updates),
-      _map_or_none[Expression](condition, updates),
-      _map_with[Expression](body, updates))
+      _map_or_none[Expression](condition, updates))
 
   fun add_json_props(node: Node box, props: Array[(String, json.Item)]) =>
     props.push(("pattern", node.child_ref(pattern)))
     match condition
     | let condition': NodeWith[Expression] =>
       props.push(("condition", node.child_ref(condition')))
     end
-    props.push(("body", node.child_ref(body)))
 
-primitive ParseMatchCase
-  fun apply(obj: json.Object, children: NodeSeq): (MatchCase | String) =>
+primitive ParseMatchPattern
+  fun apply(obj: json.Object, children: NodeSeq): (MatchPattern | String) =>
     let pattern =
       match ParseNode._get_child_with[Expression](
         obj,
         children,
         "pattern",
-        "MatchCase.pattern must be an Expression")
+        "MatchPattern.pattern must be an Expression")
       | let node: NodeWith[Expression] =>
         node
       | let err: String =>
         return err
       else
-        return "MatchCase.pattern must be an Expression"
+        return "MatchPattern.pattern must be an Expression"
       end
     let condition =
       match ParseNode._get_child_with[Expression](
         obj,
         children,
         "condition",
-        "MatchCase.condition must be an Expression",
-        false)
+        "MatchPattern.condition must be an Expression")
       | let node: NodeWith[Expression] =>
         node
       | let err: String =>
         return err
       end
+    MatchPattern(pattern, condition)
+
+class val MatchCase is NodeData
+  """A case in a `match` expression."""
+  let patterns: NodeSeqWith[MatchPattern]
+  let body: NodeWith[Expression]
+
+  new val create(
+    patterns': NodeSeqWith[MatchPattern],
+    body': NodeWith[Expression])
+  =>
+    patterns = patterns'
+    body = body'
+
+  fun name(): String => "MatchCase"
+
+  fun val clone(updates: ChildUpdateMap): NodeData =>
+    MatchCase(
+      _map[MatchPattern](patterns, updates),
+      _map_with[Expression](body, updates))
+
+  fun add_json_props(node: Node box, props: Array[(String, json.Item)]) =>
+    if patterns.size() > 0 then
+      props.push(("patterns", node.child_refs(patterns)))
+    end
+    props.push(("body", node.child_ref(body)))
+
+primitive ParseMatchCase
+  fun apply(obj: json.Object, children: NodeSeq): (MatchCase | String) =>
+    let patterns =
+      match ParseNode._get_seq_with[MatchPattern](
+        obj,
+        children,
+        "patterns",
+        "MatchCase.patterns must refer to MatchCasePatterns",
+        false)
+      | let seq: NodeSeqWith[MatchPattern] =>
+        seq
+      | let err: String =>
+        return err
+      end
     let body =
       match ParseNode._get_child_with[Expression](
         obj,
@@ -144,4 +178,4 @@ primitive ParseMatchCase
       else
         return "MatchCase.body must be an Expression"
       end
-    MatchCase(pattern, condition, body)
+    MatchCase(patterns, body)

eohippus/ast/parse_node.pony

@@ -164,6 +164,8 @@ primitive ParseNode
         ParseNode~_ctor[Expression](ParseExpLambda~apply(obj, children))
       | "ExpMatch" =>
         ParseNode~_ctor[Expression](ParseExpMatch~apply(obj, children))
+      | "MatchPattern" =>
+        ParseNode~_ctor[MatchPattern](ParseMatchPattern~apply(obj, children))
       | "MatchCase" =>
         ParseNode~_ctor[MatchCase](ParseMatchCase~apply(obj, children))
       | "ExpObject" =>

eohippus/parser/_exp_actions.pony

@@ -343,10 +343,9 @@ primitive _ExpActions
       _Build.info(d, r), c, ast.ExpMatch(exp', cases', else_block'))
     (value, b)
 
-  fun tag _match_case(
+  fun tag _match_pattern(
     pattern: Variable,
     condition: Variable,
-    body: Variable,
     d: Data,
     r: Success,
     c: ast.NodeSeq,
@@ -357,9 +356,24 @@ primitive _ExpActions
       try
         _Build.value_with[ast.Expression](b, pattern, r)?
       else
-        return _Build.bind_error(d, r, c, b, "Expression/MatchCase/Pattern")
+        return _Build.bind_error(d, r, c, b, "Expression/MatchPattern/Pattern")
       end
     let condition' = _Build.value_with_or_none[ast.Expression](b, condition, r)
+
+    let value = ast.NodeWith[ast.MatchPattern](
+      _Build.info(d, r), c, ast.MatchPattern(pattern', condition'))
+    (value, b)
+
+  fun tag _match_case(
+    patterns: Variable,
+    body: Variable,
+    d: Data,
+    r: Success,
+    c: ast.NodeSeq,
+    b: Bindings)
+    : ((ast.Node | None), Bindings)
+  =>
+    let patterns' = _Build.values_with[ast.MatchPattern](b, patterns, r)
     let body' =
       try
         _Build.value_with[ast.Expression](b, body, r)?
@@ -368,7 +382,7 @@ primitive _ExpActions
       end
 
     let value = ast.NodeWith[ast.MatchCase](
-      _Build.info(d, r), c, ast.MatchCase(pattern', condition', body'))
+      _Build.info(d, r), c, ast.MatchCase(patterns', body'))
     (value, b)
 
   fun tag _while(