myco 0.1.3 → 0.1.4

data/lib/myco/{parser → code_tools/parser}/peg_parser.rb

@@ -549,20 +549,9 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # meme_expr = (return_arg_expr | arg_expr)
+  # meme_expr = arg_expr
   def _meme_expr
-
-    _save = self.pos
-    while true # choice
-      _tmp = apply(:_return_arg_expr)
-      break if _tmp
-      self.pos = _save
-      _tmp = apply(:_arg_expr)
-      break if _tmp
-      self.pos = _save
-      break
-    end # end choice
-
+    _tmp = apply(:_arg_expr)
     set_failed_rule :_meme_expr unless _tmp
     return _tmp
   end
@@ -1828,32 +1817,6 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # t_JUMP = < "->" > {token(:t_JUMP,          text)}
-  def _t_JUMP
-
-    _save = self.pos
-    while true # sequence
-      _text_start = self.pos
-      _tmp = match_string("->")
-      if _tmp
-        text = get_text(_text_start)
-      end
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin; token(:t_JUMP,          text); end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_t_JUMP unless _tmp
-    return _tmp
-  end
-
   # t_DOT = < "." > {token(:t_DOT,           text)}
   def _t_DOT
 
@@ -3157,30 +3120,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # expr_atom_evstr = expr_atom_not_string:n0 {node(:evstr, n0, n0)}
-  def _expr_atom_evstr
-
-    _save = self.pos
-    while true # sequence
-      _tmp = apply(:_expr_atom_not_string)
-      n0 = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin; node(:evstr, n0, n0); end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_expr_atom_evstr unless _tmp
-    return _tmp
-  end
-
-  # dyn_string_parts = (c_spc* expr_atom_evstr:n0 c_spc* lit_string:n1 {[n0,n1]})+:nlist { nlist.flatten }
+  # dyn_string_parts = (c_spc* expr_atom_not_string:n0 c_spc* lit_string:n1 {[n0,n1]})+:nlist { nlist.flatten }
   def _dyn_string_parts
 
     _save = self.pos
@@ -3199,7 +3139,7 @@ class CodeTools::PegParser
           self.pos = _save2
           break
         end
-        _tmp = apply(:_expr_atom_evstr)
+        _tmp = apply(:_expr_atom_not_string)
         n0 = @result
         unless _tmp
           self.pos = _save2
@@ -3243,7 +3183,7 @@ class CodeTools::PegParser
               self.pos = _save5
               break
             end
-            _tmp = apply(:_expr_atom_evstr)
+            _tmp = apply(:_expr_atom_not_string)
             n0 = @result
             unless _tmp
               self.pos = _save5
@@ -3297,7 +3237,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # dyn_string = lit_string:n0 dyn_string_parts:nrest {node(:dstr, n0, n0.value, nrest)}
+  # dyn_string = lit_string:n0 dyn_string_parts:nrest {node(:dstr, n0, [n0] + nrest)}
   def _dyn_string
 
     _save = self.pos
@@ -3314,7 +3254,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:dstr, n0, n0.value, nrest); end
+      @result = begin; node(:dstr, n0, [n0] + nrest); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -3326,7 +3266,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # dyn_symstr = lit_symstr:n0 dyn_string_parts:nrest {node(:dsym, n0, n0.value.to_s, nrest)}
+  # dyn_symstr = lit_symstr:n0 dyn_string_parts:nrest {node(:dsym, n0, [n0] + nrest)}
   def _dyn_symstr
 
     _save = self.pos
@@ -3343,7 +3283,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:dsym, n0, n0.value.to_s, nrest); end
+      @result = begin; node(:dsym, n0, [n0] + nrest); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -3355,88 +3295,92 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # constant = (constant:n0 t_SCOPE:ts t_CONSTANT:tc {node(:colon2, ts, n0, tc.sym)} | t_SCOPE:ts t_CONSTANT:tc {node(:colon3, ts, tc.sym)} | t_CONSTANT:tc {node(:const,  tc, tc.sym)})
-  def _constant
+  # colon_const = t_SCOPE t_CONSTANT:tc { tc }
+  def _colon_const
 
     _save = self.pos
-    while true # choice
-
-      _save1 = self.pos
-      while true # sequence
-        _tmp = apply(:_constant)
-        n0 = @result
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = apply(:_t_SCOPE)
-        ts = @result
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = apply(:_t_CONSTANT)
-        tc = @result
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        @result = begin; node(:colon2, ts, n0, tc.sym); end
-        _tmp = true
-        unless _tmp
-          self.pos = _save1
-        end
+    while true # sequence
+      _tmp = apply(:_t_SCOPE)
+      unless _tmp
+        self.pos = _save
         break
-      end # end sequence
+      end
+      _tmp = apply(:_t_CONSTANT)
+      tc = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  tc ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
 
-      break if _tmp
-      self.pos = _save
+    set_failed_rule :_colon_const unless _tmp
+    return _tmp
+  end
 
-      _save2 = self.pos
-      while true # sequence
-        _tmp = apply(:_t_SCOPE)
-        ts = @result
-        unless _tmp
-          self.pos = _save2
-          break
-        end
-        _tmp = apply(:_t_CONSTANT)
-        tc = @result
-        unless _tmp
-          self.pos = _save2
-          break
-        end
-        @result = begin; node(:colon3, ts, tc.sym); end
+  # constant = t_SCOPE?:ts t_CONSTANT:tc (t_SCOPE t_CONSTANT:tx)*:trest {node(:const, (ts||tc), !!ts, [tc.sym, *trest.map(&:sym)])}
+  def _constant
+
+    _save = self.pos
+    while true # sequence
+      _save1 = self.pos
+      _tmp = apply(:_t_SCOPE)
+      @result = nil unless _tmp
+      unless _tmp
         _tmp = true
-        unless _tmp
-          self.pos = _save2
-        end
+        self.pos = _save1
+      end
+      ts = @result
+      unless _tmp
+        self.pos = _save
         break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
+      end
+      _tmp = apply(:_t_CONSTANT)
+      tc = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _ary = []
+      while true
 
-      _save3 = self.pos
-      while true # sequence
-        _tmp = apply(:_t_CONSTANT)
-        tc = @result
-        unless _tmp
-          self.pos = _save3
+        _save3 = self.pos
+        while true # sequence
+          _tmp = apply(:_t_SCOPE)
+          unless _tmp
+            self.pos = _save3
+            break
+          end
+          _tmp = apply(:_t_CONSTANT)
+          tx = @result
+          unless _tmp
+            self.pos = _save3
+          end
           break
-        end
-        @result = begin; node(:const,  tc, tc.sym); end
-        _tmp = true
-        unless _tmp
-          self.pos = _save3
-        end
-        break
-      end # end sequence
+        end # end sequence
 
-      break if _tmp
-      self.pos = _save
+        _ary << @result if _tmp
+        break unless _tmp
+      end
+      _tmp = true
+      @result = _ary
+      trest = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; node(:const, (ts||tc), !!ts, [tc.sym, *trest.map(&:sym)]); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
       break
-    end # end choice
+    end # end sequence
 
     set_failed_rule :_constant unless _tmp
     return _tmp
@@ -3816,7 +3760,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # category = category_name:n0 category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}
+  # category = category_name:n0 category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0.value,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}
   def _category
 
     _save = self.pos
@@ -3871,7 +3815,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:category, n0, n0,
+      @result = begin; node(:category, n0, n0.value,
       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0))); end
       _tmp = true
       unless _tmp
@@ -4247,44 +4191,6 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # return_arg_expr = arg_expr:n0 c_spc* t_JUMP:to {node(:return, to, n0)}
-  def _return_arg_expr
-
-    _save = self.pos
-    while true # sequence
-      _tmp = apply(:_arg_expr)
-      n0 = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      while true
-        _tmp = apply(:_c_spc)
-        break unless _tmp
-      end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _tmp = apply(:_t_JUMP)
-      to = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin; node(:return, to, n0); end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_return_arg_expr unless _tmp
-    return _tmp
-  end
-
   # assignment = (local_assignment | invoke_assignment)
   def _assignment
 
@@ -5069,7 +4975,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # in_arg_block = t_OP_TOPROC:to expr_atom:n0 {node(:block_pass, to, nil, n0)}
+  # in_arg_block = t_OP_TOPROC:to expr_atom:n0 {node(:blkarg, to, n0)}
   def _in_arg_block
 
     _save = self.pos
@@ -5086,7 +4992,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:block_pass, to, nil, n0); end
+      @result = begin; node(:blkarg, to, n0); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -5778,7 +5684,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # param_list = (t_PARAMS_BEGIN:tb t_PARAMS_END { node(:args, tb, nil, nil, nil, nil, nil, nil, nil) } | t_PARAMS_BEGIN:tb param_sepds:plist t_PARAMS_END {       required, optional, rest, kwargs, kwrest, block = 6.times.map { [] }              required << plist.shift[1] while plist[0] && plist[0][0] == :required       optional << plist.shift[1] while plist[0] && plist[0][0] == :optional       rest     << plist.shift[1] while plist[0] && plist[0][0] == :rest       kwargs   << plist.shift[1] while plist[0] && plist[0][0] == :kwargs       kwrest   << plist.shift[1] while plist[0] && plist[0][0] == :kwrest       block    << plist.shift[1] while plist[0] && plist[0][0] == :block              required = required       optional = optional.empty? ? nil : node(:block, tb, optional)       rest     = rest.first       post     = nil       kwargs   = kwargs.empty?   ? nil : node(:block, tb, kwargs)       kwrest   = kwrest.first       block    = block.first              node(:args, tb, required, optional, rest, post, kwargs, kwrest, block)     })
+  # param_list = (t_PARAMS_BEGIN:tb t_PARAMS_END { node(:args, tb, [], [], nil, [], [], nil, nil) } | t_PARAMS_BEGIN:tb param_sepds:plist t_PARAMS_END {       required, optional, rest, post, kwargs, kwrest, block = 7.times.map { [] }              required << plist.shift[1] while plist[0] && plist[0][0] == :required       optional << plist.shift[1] while plist[0] && plist[0][0] == :optional       rest     << plist.shift[1] while plist[0] && plist[0][0] == :rest       post     << plist.shift[1] while plist[0] && plist[0][0] == :required       kwargs   << plist.shift[1] while plist[0] && plist[0][0] == :kwargs       kwrest   << plist.shift[1] while plist[0] && plist[0][0] == :kwrest       block    << plist.shift[1] while plist[0] && plist[0][0] == :block              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 && node(:blkprm, tb, block)              node(:args, tb, required, optional, rest, post, kwargs, kwrest, block)     })
   def _param_list
 
     _save = self.pos
@@ -5797,7 +5703,7 @@ class CodeTools::PegParser
           self.pos = _save1
           break
         end
-        @result = begin;  node(:args, tb, nil, nil, nil, nil, nil, nil, nil) ; end
+        @result = begin;  node(:args, tb, [], [], nil, [], [], nil, nil) ; end
         _tmp = true
         unless _tmp
           self.pos = _save1
@@ -5828,23 +5734,27 @@ class CodeTools::PegParser
           break
         end
         @result = begin; 
-      required, optional, rest, kwargs, kwrest, block = 6.times.map { [] }
+      required, optional, rest, post, kwargs, kwrest, block = 7.times.map { [] }
       
       required << plist.shift[1] while plist[0] && plist[0][0] == :required
       optional << plist.shift[1] while plist[0] && plist[0][0] == :optional
       rest     << plist.shift[1] while plist[0] && plist[0][0] == :rest
+      post     << plist.shift[1] while plist[0] && plist[0][0] == :required
       kwargs   << plist.shift[1] while plist[0] && plist[0][0] == :kwargs
       kwrest   << plist.shift[1] while plist[0] && plist[0][0] == :kwrest
       block    << plist.shift[1] while plist[0] && plist[0][0] == :block
       
       required = required
-      optional = optional.empty? ? nil : node(:block, tb, optional)
+      optional = optional
       rest     = rest.first
-      post     = nil
-      kwargs   = kwargs.empty?   ? nil : node(:block, tb, kwargs)
+      post     = post
+      kwargs   = kwargs
       kwrest   = kwrest.first
       block    = block.first
       
+      # TODO: move these conversions to their respective reductions
+      block = block && node(:blkprm, tb, block)
+      
       node(:args, tb, required, optional, rest, post, kwargs, kwrest, block)
     ; end
         _tmp = true
@@ -7112,7 +7022,7 @@ class CodeTools::PegParser
   Rules[:_decl] = rule_info("decl", "(declobj | declstr | copen)")
   Rules[:_declobj_expr] = rule_info("declobj_expr", "(category | declobj_expr_not_category)")
   Rules[:_declobj_expr_not_category] = rule_info("declobj_expr_not_category", "(decl | cdefn | cmeme | constant | meme)")
-  Rules[:_meme_expr] = rule_info("meme_expr", "(return_arg_expr | arg_expr)")
+  Rules[:_meme_expr] = rule_info("meme_expr", "arg_expr")
   Rules[:_arg_expr] = rule_info("arg_expr", "(assignment | left_chained_atoms | dyn_string | dyn_symstr | expr_atom)")
   Rules[:_expr_atom] = rule_info("expr_atom", "(decl | left_chained_invocations | lit_string | lit_symstr | unary_operation | paren_expr | constant | lit_simple | lit_array | invoke)")
   Rules[:_expr_atom_not_chained] = rule_info("expr_atom_not_chained", "(decl | lit_string | lit_symstr | unary_operation | paren_expr | constant | lit_simple | lit_array | invoke)")
@@ -7158,7 +7068,6 @@ class CodeTools::PegParser
   Rules[:_t_SELF] = rule_info("t_SELF", "< \"self\" > {token(:t_SELF,          text)}")
   Rules[:_t_FLOAT] = rule_info("t_FLOAT", "< \"-\"? c_num+ \".\" c_num+ > {token(:t_FLOAT,         text)}")
   Rules[:_t_INTEGER] = rule_info("t_INTEGER", "< \"-\"? c_num+ > {token(:t_INTEGER,       text)}")
-  Rules[:_t_JUMP] = rule_info("t_JUMP", "< \"->\" > {token(:t_JUMP,          text)}")
   Rules[:_t_DOT] = rule_info("t_DOT", "< \".\" > {token(:t_DOT,           text)}")
   Rules[:_t_QUEST] = rule_info("t_QUEST", "< \".\" c_spc_nl* \"?\" > {token(:t_QUEST,         text)}")
   Rules[:_t_SCOPE] = rule_info("t_SCOPE", "< \"::\" > {token(:t_SCOPE,         text)}")
@@ -7195,11 +7104,11 @@ class CodeTools::PegParser
   Rules[:_lit_string_as_symbol] = rule_info("lit_string_as_symbol", "(t_STRING_BEGIN t_STRING_BODY:tb t_STRING_END {node(:lit, tb, encode_escapes(tb.text).to_sym)} | t_SSTRING_BEGIN t_SSTRING_BODY:tb t_SSTRING_END {node(:lit, tb, encode_escapes(tb.text).to_sym)})")
   Rules[:_lit_symstr] = rule_info("lit_symstr", "t_SYMSTR_BEGIN t_STRING_BODY:tb t_STRING_END {node(:lit, tb, encode_escapes(tb.text).to_sym)}")
   Rules[:_category_name] = rule_info("category_name", "t_CATGRY_BEGIN t_CATGRY_BODY:tb t_CATGRY_END {node(:lit, tb, encode_escapes(tb.text).to_sym)}")
-  Rules[:_expr_atom_evstr] = rule_info("expr_atom_evstr", "expr_atom_not_string:n0 {node(:evstr, n0, n0)}")
-  Rules[:_dyn_string_parts] = rule_info("dyn_string_parts", "(c_spc* expr_atom_evstr:n0 c_spc* lit_string:n1 {[n0,n1]})+:nlist { nlist.flatten }")
-  Rules[:_dyn_string] = rule_info("dyn_string", "lit_string:n0 dyn_string_parts:nrest {node(:dstr, n0, n0.value, nrest)}")
-  Rules[:_dyn_symstr] = rule_info("dyn_symstr", "lit_symstr:n0 dyn_string_parts:nrest {node(:dsym, n0, n0.value.to_s, nrest)}")
-  Rules[:_constant] = rule_info("constant", "(constant:n0 t_SCOPE:ts t_CONSTANT:tc {node(:colon2, ts, n0, tc.sym)} | t_SCOPE:ts t_CONSTANT:tc {node(:colon3, ts, tc.sym)} | t_CONSTANT:tc {node(:const,  tc, tc.sym)})")
+  Rules[:_dyn_string_parts] = rule_info("dyn_string_parts", "(c_spc* expr_atom_not_string:n0 c_spc* lit_string:n1 {[n0,n1]})+:nlist { nlist.flatten }")
+  Rules[:_dyn_string] = rule_info("dyn_string", "lit_string:n0 dyn_string_parts:nrest {node(:dstr, n0, [n0] + nrest)}")
+  Rules[:_dyn_symstr] = rule_info("dyn_symstr", "lit_symstr:n0 dyn_string_parts:nrest {node(:dsym, n0, [n0] + nrest)}")
+  Rules[:_colon_const] = rule_info("colon_const", "t_SCOPE t_CONSTANT:tc { tc }")
+  Rules[:_constant] = rule_info("constant", "t_SCOPE?:ts t_CONSTANT:tc (t_SCOPE t_CONSTANT:tx)*:trest {node(:const, (ts||tc), !!ts, [tc.sym, *trest.map(&:sym)])}")
   Rules[:_const_sep] = rule_info("const_sep", "(c_spc_nl* t_CONST_SEP c_spc_nl*)+")
   Rules[:_constant_list] = rule_info("constant_list", "constant:n0 (const_sep constant:n)*:nrest {node(:arrass, n0, [n0, *nrest])}")
   Rules[:_id_as_symbol] = rule_info("id_as_symbol", "t_IDENTIFIER:t0 {node(:lit, t0, t0.sym)}")
@@ -7208,7 +7117,7 @@ class CodeTools::PegParser
   Rules[:_declobj] = rule_info("declobj", "constant_list:n0 c_spc_nl* t_DECLARE_BEGIN:t declobj_expr_body:n1 {node(:declobj, t, n0, n1)}")
   Rules[:_category_expr] = rule_info("category_expr", "declobj_expr_not_category")
   Rules[:_category_sepd_exprs] = rule_info("category_sepd_exprs", "arg_sep category_expr:n0 (arg_sep category_expr:n)*:nrest { [n0, *nrest] }")
-  Rules[:_category] = rule_info("category", "category_name:n0 category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}")
+  Rules[:_category] = rule_info("category", "category_name:n0 category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0.value,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}")
   Rules[:_copen] = rule_info("copen", "constant:n0 c_spc_nl* t_REOPEN:tb c_spc_nl* t_DECLARE_BEGIN declobj_expr_body:n1 {node(:copen, tb, n0, n1)}")
   Rules[:_cdefn] = rule_info("cdefn", "constant:n0 c_spc_nl* t_DEFINE:t c_spc_nl* declobj:n1 {node(:cdefn, t, n0, n1)}")
   Rules[:_t_DECLSTR_BEGIN] = rule_info("t_DECLSTR_BEGIN", "< /[^\\s{:,<][^\\s]+/ > {      \# Table of replacement characters to use when calculating   \# the ending delimiter from the starting delimiter.   \# Directional characters are replaced with their opposite.   @declstr_replace_tbl ||= %w{     < > ( ) { } [ ]   }      \# Calculate the ending delimiter to look for and store it   @declstr_destrlim = text \\     .split(/(?<=[^a-zA-Z])|(?=[^a-zA-Z])/)     .map { |str|       idx = @declstr_replace_tbl.find_index(str)       idx.nil? ? str :          (idx.odd? ? @declstr_replace_tbl[idx-1] : @declstr_replace_tbl[idx+1])     }     .reverse     .join ''      token(:t_DECLSTR_BEGIN, text) }")
@@ -7217,7 +7126,6 @@ class CodeTools::PegParser
   Rules[:_s_DECLSTR_BODY] = rule_info("s_DECLSTR_BODY", "s_DECLSTR_BODYLINE*:slist { slist[1..-1].join('') }")
   Rules[:_declstr_body] = rule_info("declstr_body", "t_DECLSTR_BEGIN:tb s_DECLSTR_BODY:st c_spc_nl* t_DECLSTR_END {node(:str, tb, st)}")
   Rules[:_declstr] = rule_info("declstr", "constant_list:nc c_spc+ declstr_body:nb {node(:declstr, nc, nc, nb)}")
-  Rules[:_return_arg_expr] = rule_info("return_arg_expr", "arg_expr:n0 c_spc* t_JUMP:to {node(:return, to, n0)}")
   Rules[:_assignment] = rule_info("assignment", "(local_assignment | invoke_assignment)")
   Rules[:_assign_rhs] = rule_info("assign_rhs", "arg_expr")
   Rules[:_local_assignment] = rule_info("local_assignment", "t_IDENTIFIER:ti c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs {node(:lasgn, to, ti.sym, rhs)}")
@@ -7236,14 +7144,14 @@ class CodeTools::PegParser
   Rules[:_in_arg_kwarg_mark] = rule_info("in_arg_kwarg_mark", "c_spc_nl* t_MEME_MARK:to")
   Rules[:_in_arg_kwarg] = rule_info("in_arg_kwarg", "id_as_symbol:n0 in_arg_kwarg_mark c_spc_nl* arg_expr:n1 { [n0, n1] }")
   Rules[:_in_arg_splat] = rule_info("in_arg_splat", "t_OP_MULT:to expr_atom:n0 {node(:splat, to, n0)}")
-  Rules[:_in_arg_block] = rule_info("in_arg_block", "t_OP_TOPROC:to expr_atom:n0 {node(:block_pass, to, nil, n0)}")
+  Rules[:_in_arg_block] = rule_info("in_arg_block", "t_OP_TOPROC:to expr_atom:n0 {node(:blkarg, to, n0)}")
   Rules[:_in_arg_list] = rule_info("in_arg_list", "(in_arg_normals:n0 arg_sep in_arg_kwargs:n1 arg_sep in_arg_block:n2 { [*n0,n1,n2] } | in_arg_normals:n0 arg_sep in_arg_kwargs:n1 { [*n0,n1] } | in_arg_normals:n0 arg_sep in_arg_block:n1 { [*n0,n1] } | in_arg_kwargs:n0 arg_sep in_arg_block:n1 { [n0, n1] } | in_arg_normals:n0 { [*n0] } | in_arg_kwargs:n0 { [n0] } | in_arg_block:n0 { [n0] })")
   Rules[:_arg_list] = rule_info("arg_list", "(t_ARGS_BEGIN:tb arg_sep_opt t_ARGS_END {node(:argass, tb, [])} | t_ARGS_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARGS_END {node(:argass, tb, nlist)})")
   Rules[:_lit_array] = rule_info("lit_array", "(t_ARRAY_BEGIN:tb arg_sep_opt t_ARRAY_END {node(:arrass, tb, [])} | t_ARRAY_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARRAY_END {node(:arrass, tb, nlist)})")
   Rules[:_param] = rule_info("param", "(t_IDENTIFIER:ti c_spc_nl* t_ASSIGN:to c_spc_nl* arg_expr:nv { [:optional, node(:lasgn, ti, ti.sym, nv)] } | t_IDENTIFIER:ti c_spc_nl* t_MEME_MARK:to c_spc_nl* arg_expr?:nv { [:kwargs, node(:lasgn, ti, ti.sym, (nv || node(:lit, to, :*)))] } | t_OP_EXP c_spc_nl* t_IDENTIFIER:ti { [:kwrest,   ti.sym] } | t_OP_MULT c_spc_nl* t_IDENTIFIER:ti { [:rest,     ti.sym] } | t_OP_TOPROC c_spc_nl* t_IDENTIFIER:ti { [:block,    ti.sym] } | t_IDENTIFIER:ti { [:required, ti.sym] })")
   Rules[:_param_sepd] = rule_info("param_sepd", "arg_sep param:n0 { n0 }")
   Rules[:_param_sepds] = rule_info("param_sepds", "param:n0 (arg_sep param:n)*:nrest arg_sep_opt { [n0, *nrest] }")
-  Rules[:_param_list] = rule_info("param_list", "(t_PARAMS_BEGIN:tb t_PARAMS_END { node(:args, tb, nil, nil, nil, nil, nil, nil, nil) } | t_PARAMS_BEGIN:tb param_sepds:plist t_PARAMS_END {       required, optional, rest, kwargs, kwrest, block = 6.times.map { [] }              required << plist.shift[1] while plist[0] && plist[0][0] == :required       optional << plist.shift[1] while plist[0] && plist[0][0] == :optional       rest     << plist.shift[1] while plist[0] && plist[0][0] == :rest       kwargs   << plist.shift[1] while plist[0] && plist[0][0] == :kwargs       kwrest   << plist.shift[1] while plist[0] && plist[0][0] == :kwrest       block    << plist.shift[1] while plist[0] && plist[0][0] == :block              required = required       optional = optional.empty? ? nil : node(:block, tb, optional)       rest     = rest.first       post     = nil       kwargs   = kwargs.empty?   ? nil : node(:block, tb, kwargs)       kwrest   = kwrest.first       block    = block.first              node(:args, tb, required, optional, rest, post, kwargs, kwrest, block)     })")
+  Rules[:_param_list] = rule_info("param_list", "(t_PARAMS_BEGIN:tb t_PARAMS_END { node(:args, tb, [], [], nil, [], [], nil, nil) } | t_PARAMS_BEGIN:tb param_sepds:plist t_PARAMS_END {       required, optional, rest, post, kwargs, kwrest, block = 7.times.map { [] }              required << plist.shift[1] while plist[0] && plist[0][0] == :required       optional << plist.shift[1] while plist[0] && plist[0][0] == :optional       rest     << plist.shift[1] while plist[0] && plist[0][0] == :rest       post     << plist.shift[1] while plist[0] && plist[0][0] == :required       kwargs   << plist.shift[1] while plist[0] && plist[0][0] == :kwargs       kwrest   << plist.shift[1] while plist[0] && plist[0][0] == :kwrest       block    << plist.shift[1] while plist[0] && plist[0][0] == :block              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 && node(:blkprm, tb, block)              node(:args, tb, required, optional, rest, post, kwargs, kwrest, block)     })")
   Rules[:_left_op_normal] = rule_info("left_op_normal", "(t_OP_EXP | t_OP_MULT | t_OP_DIV | t_OP_MOD | t_OP_PLUS | t_OP_MINUS | t_OP_COMPARE)")
   Rules[:_left_op_branch] = rule_info("left_op_branch", "(t_OP_AND | t_OP_OR | t_OP_AND_Q | t_OP_OR_Q | t_OP_VOID_Q)")
   Rules[:_left_op] = rule_info("left_op", "(left_op_normal | left_op_branch)")

data/lib/myco/{parser.rb → code_tools/parser.rb}

@@ -1,23 +1,6 @@
 
 require 'stringio'
 
-module CodeTools
-  class Parser < Melbourne
-  end
-  
-  class Compiler
-    module ParserPatch
-      def initialize *args
-        super
-        @processor = Myco::ToolSet::Parser
-      end
-    end
-    
-    Parser.prepend ParserPatch
-  end
-end
-
-require_relative 'parser/ast'
 require_relative 'parser/peg_parser'
 
 module CodeTools

data/lib/myco/code_tools.rb

@@ -0,0 +1,5 @@
+
+module ::CodeTools; end
+
+Myco.eval_file 'code_tools/AST.my'
+require_relative 'code_tools/parser'

data/lib/myco/core/BasicDecorators.my

@@ -59,4 +59,51 @@
       }
     }
   }
+  
+  # The 'pre' decorator defines a wrapper that pre-processes arguments
+  pre: Decorator {
+    apply: |meme| {
+      orig_meme = meme.target.memes[meme.name]
+      wrap_meme = meme.dup
+      meme.body = Proc.new |*a,&b| {
+        new_a = \
+        wrap_meme.result_for(self,*a)
+        orig_meme.result_for(self,*new_a,&b)
+      }
+    }
+  }
+  
+  # The 'post' decorator defines a wrapper that post-processes return value
+  post: Decorator {
+    apply: |meme| {
+      orig_meme = meme.target.memes[meme.name]
+      wrap_meme = meme.dup
+      meme.body = Proc.new |*a,&b| {
+        result = \
+        orig_meme.result_for(self,*a,&b)
+        wrap_meme.result_for(self,result)
+      }
+    }
+  }
+  
+  # The 'setter' decorator defines a setter that pre-processes the given value
+  setter: Decorator {
+    apply: |meme| {
+      wrap_meme = meme.dup
+      meme.setter = Proc.new |orig_value| {
+        wrap_meme.result_for(self,orig_value)
+      }
+    }
+  }
+  
+  # The 'getter' decorator defines a getter that post-processes the return value
+  getter: Decorator {
+    apply: |meme| {
+      wrap_meme = meme.dup
+      meme.getter = Proc.new |orig_value| {
+        wrap_meme.result_for(self,orig_value)
+      }
+    }
+  }
+  
 }

data/lib/myco/core/BasicDecorators.my.rb

@@ -64,5 +64,71 @@
       )}
     )
   )})}}.instance)}
+  declare_meme(:pre, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
+    orig_meme = meme.target.memes.__send__(
+      :[],
+      meme.name
+    )
+    wrap_meme = meme.dup
+    meme.__send__(
+      :body=,
+      ::Myco.find_constant(:Proc).new { |*a, &b| (
+        new_a = wrap_meme.result_for(
+          self,
+          *a
+        )
+        orig_meme.result_for(
+          self,
+          *new_a,
+          &b
+        )
+      )}
+    )
+  )})}}.instance)}
+  declare_meme(:post, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
+    orig_meme = meme.target.memes.__send__(
+      :[],
+      meme.name
+    )
+    wrap_meme = meme.dup
+    meme.__send__(
+      :body=,
+      ::Myco.find_constant(:Proc).new { |*a, &b| (
+        result = orig_meme.result_for(
+          self,
+          *a,
+          &b
+        )
+        wrap_meme.result_for(
+          self,
+          result
+        )
+      )}
+    )
+  )})}}.instance)}
+  declare_meme(:setter, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
+    wrap_meme = meme.dup
+    meme.__send__(
+      :setter=,
+      ::Myco.find_constant(:Proc).new { |orig_value| (wrap_meme.result_for(
+        self,
+        orig_value
+      ))}
+    )
+  )})}}.instance)}
+  declare_meme(:getter, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
+    wrap_meme = meme.dup
+    meme.__send__(
+      :getter=,
+      ::Myco.find_constant(:Proc).new { |orig_value| (wrap_meme.result_for(
+        self,
+        orig_value
+      ))}
+    )
+  )})}}.instance)}
 )})}}
 .tap { |__c__| __c__.__name__ = :BasicDecorators })}}.instance