myco 0.1.6 → 0.1.7

data/lib/myco/code_tools/parser/MycoGrammar.my

@@ -42,8 +42,8 @@ rule meme_expr:
 rule arg_expr:
   assignment
 / left_chained_operations
-/ dyn_string
-/ dyn_symstr
+/ string_compose
+/ symbol_compose
 / left_chained_piping
 / expr_atom
 
@@ -96,9 +96,9 @@ rule lit_simple:
 / r(T.true[:t0])     { ast.true(t0) }
 / r(T.false[:t0])    { ast.false(t0) }
 / r(T.self[:t0])     { ast.self(t0) }
-/ r(T.float[:t0])    { ast.lit(t0, t0.float) }
-/ r(T.integer[:t0])  { ast.lit(t0, t0.integer) }
-/ r(T.symbol[:t0])   { ast.lit(t0, t0.text.slice(::Range.new(1,-1)).to_sym) } # TODO: more succinct here
+/ r(T.float[:t0])    { ast.numeric(t0, t0.float) }
+/ r(T.integer[:t0])  { ast.numeric(t0, t0.integer) }
+/ r(T.symbol[:t0])   { ast.symbol(t0, t0.text.slice(Range.new(1,-1)).to_sym) } # TODO: more succinct here
 
 ##
 # Other literals
@@ -120,39 +120,39 @@ rule block_body:
 rule lit_string:
   r((T.string_begin  + T.string_body[:tb]  + T.string_end) /
     (T.sstring_begin + T.sstring_body[:tb] + T.sstring_end))
-    { ast.lit(tb, encode_escapes(tb.text)) }
+    { ast.symbol(tb, encode_escapes(tb.text)) }
 
 rule lit_string_as_symbol:
   r((T.string_begin  + T.string_body[:tb]  + T.string_end) /
     (T.sstring_begin + T.sstring_body[:tb] + T.sstring_end))
-    { ast.lit(tb, encode_escapes(tb.text).to_sym) }
+    { ast.symbol(tb, encode_escapes(tb.text).to_sym) }
 
 rule lit_symstr:
   r(T.symstr_begin + T.string_body[:tb] + T.string_end)
-    { ast.lit(tb, encode_escapes(tb.text).to_sym) }
+    { ast.symbol(tb, encode_escapes(tb.text).to_sym) }
 
 rule category_name:
   r(T.catgry_begin + T.catgry_body[:tb] + T.catgry_end)
-    { ast.lit(tb, encode_escapes(tb.text).to_sym) }
+    { ast.symbol(tb, encode_escapes(tb.text).to_sym) }
 
 ##
 # String interpolations / juxtapositions
 
-rule dyn_string_part:
+rule string_compose_part:
   r(C.spc.* + expr_atom_not_string[:n0] + C.spc.* + lit_string[:n1])
     { [n0,n1] }
 
-rule dyn_string_parts:
-  r(dyn_string_part.+[:nlist])
+rule string_compose_parts:
+  r(string_compose_part.+[:nlist])
     { nlist.flatten }
 
-rule dyn_string:
-  r(lit_string[:n0] + dyn_string_parts[:nrest])
-    { ast.dstr(n0, [n0] + nrest) }
+rule string_compose:
+  r(lit_string[:n0] + string_compose_parts[:nrest])
+    { ast.string_compose(n0, [n0] + nrest) }
 
-rule dyn_symstr:
-  r(lit_symstr[:n0] + dyn_string_parts[:nrest])
-    { ast.dsym(n0, [n0] + nrest) }
+rule symbol_compose:
+  r(lit_symstr[:n0] + string_compose_parts[:nrest])
+    { ast.symbol_compose(n0, [n0] + nrest) }
 
 ##
 # Constants
@@ -173,14 +173,14 @@ rule sepd_constant:
 
 rule constant_list:
   r(constant[:n0] + sepd_constant.*[:nrest])
-    { ast.arrass(n0, [n0, *nrest]) }
+    { ast.array(n0, [n0, *nrest]) }
 
 ##
 # Bare identifiers
 
 # Used in contexts where a bare identifier is a symbol
 rule id_as_symbol:
-  r(T.identifier[:t0]) { ast.lit(t0, t0.sym) }
+  r(T.identifier[:t0]) { ast.symbol(t0, t0.sym) }
 
 ##
 # Object declarations
@@ -262,7 +262,7 @@ rule invoke_assignment:
     lhs.name = (""lhs.name"=").to_sym
     orig_arguments = lhs.arguments &? lhs.arguments.body ?? []
     arg_order = lhs.name==:"[]=" &? [*orig_arguments, rhs] ?? [rhs, *orig_arguments]
-    lhs.arguments = ast.argass(rhs, arg_order)
+    lhs.arguments = ast.args(rhs, arg_order)
     lhs
   }
 
@@ -283,7 +283,7 @@ rule op_invoke: # Allow some binary operators to be invoked with a dot
 
 rule elem_invoke:
   r(lit_array[:na] + opt_block_body[:nb])
-    { ast.invoke(na, null, :"[]", ast.argass(na, na.body), nb) }
+    { ast.invoke(na, null, :"[]", ast.args(na, na.body), nb) }
 
 rule op_invoke_id:
   left_op_normal
@@ -337,68 +337,61 @@ rule in_arg_list:
 
 rule arg_list:
   r(T.args_begin[:tb] + arg_sep_opt + in_arg_list.-[:nlist] + arg_sep_opt + T.args_end)
-    { ast.argass(tb, (nlist || [])) }
+    { ast.args(tb, (nlist || [])) }
 
 rule lit_array:
   r(T.array_begin[:tb] + arg_sep_opt + in_arg_list.-[:nlist] + arg_sep_opt + T.array_end)
-    { ast.arrass(tb, (nlist || [])) }
+    { ast.array(tb, (nlist || [])) }
 
 ##
 # Parameter lists
 
-rule param:
+param_sep:     (C.spc.* + T.arg_sep + C.spc.*).+ / (C.spc.* + !!T.params_end)
+param_sep_opt: (C.spc / T.arg_sep).*
+param_sepd: |x| r(x[:n0] + param_sep) { n0 }
+
+rule req_param:
+  r(T.identifier[:ti] + !!param_sep)
+    { ast.reqprm(ti, ti.sym) }
+rule opt_param:
   r(T.identifier[:ti] + C.spc_nl.* + T.assign[:to] + C.spc_nl.* + arg_expr[:nv])
-    { [:optional, ast.lasgn(ti, ti.sym, nv)] }
-/ r(T.identifier[:ti] + C.spc_nl.* + T.meme_mark[:to] + C.spc_nl.* + arg_expr.-[:nv])
-    { [:kwargs, ast.lasgn(ti, ti.sym, nv || ast.lit(to, :"*"))] }
-/ r(T.op_exp + C.spc_nl.* + T.identifier[:ti])
-    { [:kwrest,   ti.sym] }
-/ r(T.op_mult + C.spc_nl.* + T.identifier[:ti])
-    { [:rest,     ti.sym] }
-/ r(T.op_toproc + C.spc_nl.* + T.identifier[:ti])
-    { [:block,    ti.sym] }
-/ r(T.identifier[:ti])
-    { [:required, ti.sym] }
-
-rule param_sepd:
-  r(arg_sep + param[:n0]) { n0 }
-
-rule param_sepds:
-  r(param[:n0] + param_sepd.*[:nrest] + arg_sep_opt) { [n0, *nrest] }
+    { ast.optprm(ti, ti.sym, nv) }
+rule rest_param:
+  r(T.op_mult + C.spc_nl.* + T.identifier[:ti])
+    { ast.restprm(ti, ti.sym) }
+rule kwopt_param:
+  r(T.identifier[:ti] + C.spc_nl.* + T.meme_mark[:to] + C.spc_nl.* + arg_expr[:nv])
+    { ast.kwoptprm(ti, ti.sym, nv) }
+rule kwreq_param:
+  r(T.identifier[:ti] + C.spc_nl.* + T.meme_mark[:to] + !!param_sep)
+    { ast.kwreqprm(ti, ti.sym) }
+rule kwrest_param:
+  r(T.op_exp + C.spc_nl.* + T.identifier[:ti])
+    { ast.kwrestprm(ti, ti.sym) }
+rule block_param:
+  r(T.op_toproc + C.spc_nl.* + T.identifier[:ti])
+    { ast.blkprm(ti, ti.sym) }
 
 rule param_list:
-  r(T.params_begin[:tb] + T.params_end)
-    { ast.args(tb, [], [], null, [], [], null, null) } # TODO: investigate removing
-/ r(T.params_begin[:tb] + param_sepds[:plist] + T.params_end)
-    {
-  required = []
-  optional = []
-  rest     = []
-  post     = []
-  kwargs   = []
-  kwrest   = []
-  block    = []
-  
-  loop { plist[0] && plist[0][0] == :required || break; required.push(plist.shift[1]) }
-  loop { plist[0] && plist[0][0] == :optional || break; optional.push(plist.shift[1]) }
-  loop { plist[0] && plist[0][0] == :rest     || break; rest    .push(plist.shift[1]) }
-  loop { plist[0] && plist[0][0] == :required || break; post    .push(plist.shift[1]) }
-  loop { plist[0] && plist[0][0] == :kwargs   || break; kwargs  .push(plist.shift[1]) }
-  loop { plist[0] && plist[0][0] == :kwrest   || break; kwrest  .push(plist.shift[1]) }
-  loop { plist[0] && plist[0][0] == :block    || break; block   .push(plist.shift[1]) }
-  
-  required = required
-  optional = optional
-  rest     = rest.first
-  post     = post
-  kwargs   = kwargs
-  kwrest   = kwrest.first
-  block    = block.first
-  
-  # TODO: move these conversions to their respective reductions
-  block = block && ast.blkprm(tb, block)
+  r(T.params_begin[:tb]
+    + param_sep_opt
+    + param_sepd(req_param).*[:required]
+    + param_sepd(opt_param).*[:optional]
+    + param_sepd(rest_param).-[:rest]
+    + param_sepd(req_param).*[:post]
+    + param_sepd(kwreq_param / kwopt_param).*[:kw]
+    + param_sepd(kwrest_param).-[:kwrest]
+    + param_sepd(block_param).-[:block]
+    + T.params_end) {
+  kwrequired = kw.select |x| { x.node_type == :kwreqprm }
+  kwoptional = kw.select |x| { x.node_type == :kwoptprm }
   
-  ast.args(tb, required, optional, rest, post, kwargs, kwrest, block)
+  # TODO: the ternary clauses should not be necessary
+  ast.params(tb
+    required, optional, (rest.is_a?(Array) &? rest.first ?? rest), post
+    kwrequired, kwoptional, (kwrest.is_a?(Array) &? kwrest.first ?? kwrest)
+    (block.is_a?(Array) &? block.first ?? block)
+  )
 }
 
 ##
@@ -594,7 +587,7 @@ rule sepd_decorator:
 
 rule decorators_and_meme_name:
   r(decorator[:n0] + sepd_decorator.*[:nrest])
-    { ast.arrass(n0, [n0, *nrest].reverse) }
+    { ast.array(n0, [n0, *nrest].reverse) }
 
 rule meme:
   r(decorators_and_meme_name[:nd]