myco 0.1.6 → 0.1.7

data/lib/myco/code_tools/AST/{MycoModuleScope.my.rb → DeclaredScope.my.rb}

@@ -1,27 +1,17 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::MycoModuleScope = ::Myco::Component.new([
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::DeclaredScope = ::Myco::Component.new([
   ::Myco.find_constant(:CodeTools)::Compiler::LocalVariables,
   ::Myco.find_constant(:Node)
 ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:scope_method, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     g.state.scope.nest_scope(self)
-    self.attach_and_call(
-      g,
-      :__myco_module_init__,
-      true
-    )
-  )}
-  declare_meme(:attach_and_call, [], nil, ::Myco.cscope.dup) { |g, arg_name, scoped=false, pass_block=false| (
-    self.__send__(
-      :name=,
-      :MycoModuleScope
-    )
-    name = ::Myco.branch_op(:"||", self.name) {arg_name}
+    name = :__declaration__
     meth = self.new_generator(
       g,
       name
@@ -31,12 +21,18 @@
       :for_module_body=,
       true
     )
-    ::Myco.branch_op(:"&&", scoped) {(
-      meth.push_self
-      meth.add_scope
-    )}
+    meth.push_self
+    meth.add_scope
     meth.state.push_name(name.to_sym)
-    self.body_bytecode(meth)
+    ::Myco.branch_op(:"&&", self.scope_method) {(
+      meth.push_scope
+      meth.send(
+        self.scope_method,
+        0
+      )
+      meth.pop
+    )}
+    self.body.bytecode(meth)
     meth.state.pop_name
     meth.ret
     meth.close
@@ -59,7 +55,6 @@
     )
     meth
   )}
-  declare_meme(:body_bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.body.bytecode(g))}
   declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
     :parent=,
     self
@@ -79,4 +74,4 @@
     )}
   )}
 )}}
-.tap { |__c__| __c__.__name__ = :MycoModuleScope })})}}.instance
+.tap { |__c__| __c__.__name__ = :DeclaredScope })})}}.instance

data/lib/myco/code_tools/AST/Invoke.my

@@ -2,22 +2,22 @@
 CodeTools::AST << {
   
   Invoke < Node {
-    var receiver, var name, var arguments, var block
-    
-    Form: [:invoke, :receiver, :name, :arguments, :block]
+    node_type invoke
+    field receiver, field name, field arguments, field block
     
     bytecode: |g| pos(g); implementation.bytecode(g)
     
     implementation: {
+      use_args = self.arguments
+      
       # TODO: error if passing both block argument and block literal
       # Currently, this fails silently and ignores the block argument
-      # TODO: don't change AST state from here
       self.block && (
-        self.arguments = self.arguments || ArgumentAssembly.new(line:self.line, body:[])
-        self.arguments.block = self.block
+        use_args = (use_args && use_args.dup) || ArgumentAssembly.new(line:self.line, body:[])
+        use_args.block = self.block
       )
       
-      self.receiver.nil? && self.arguments.nil? &? (
+      self.receiver.nil? && use_args.nil? &? (
         LocalVariableAccessAmbiguous.new(
           line: self.line
           name: self.name
@@ -27,7 +27,7 @@ CodeTools::AST << {
           line:      self.line
           receiver:  self.receiver || Self.new(line:self.line)
           name:      self.name
-          arguments: self.arguments || ArgumentAssembly.new(line:self.line, body:[])
+          arguments: use_args || ArgumentAssembly.new(line:self.line, body:[])
         )
       )
     }

data/lib/myco/code_tools/AST/Invoke.my.rb

@@ -2,43 +2,35 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::Invoke = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:receiver, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:arguments, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :invoke,
-    :receiver,
-    :name,
-    :arguments,
-    :block
-  ])
+  declare_meme(:invoke, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:receiver, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:arguments, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:block, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     self.implementation.bytecode(g)
   )}
   declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (
+    use_args = self.arguments
     ::Myco.branch_op(:"&&", self.block) {(
-      self.__send__(
-        :arguments=,
-        ::Myco.branch_op(:"||", self.arguments) {::Myco.find_constant(:ArgumentAssembly).new({
-          :line => self.line,
-          :body => []
-        })}
-      )
-      self.arguments.__send__(
+      use_args = ::Myco.branch_op(:"||", ::Myco.branch_op(:"&&", use_args) {use_args.dup}) {::Myco.find_constant(:ArgumentAssembly).new({
+        :line => self.line,
+        :body => []
+      })}
+      use_args.__send__(
         :block=,
         self.block
       )
     )}
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", self.receiver.__send__(:nil?)) {self.arguments.__send__(:nil?)}) {::Myco.find_constant(:LocalVariableAccessAmbiguous).new({
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", self.receiver.__send__(:nil?)) {use_args.__send__(:nil?)}) {::Myco.find_constant(:LocalVariableAccessAmbiguous).new({
       :line => self.line,
       :name => self.name
     })}) {::Myco.find_constant(:InvokeMethod).new({
       :line => self.line,
       :receiver => ::Myco.branch_op(:"||", self.receiver) {::Myco.find_constant(:Self).new({:line => self.line})},
       :name => self.name,
-      :arguments => ::Myco.branch_op(:"||", self.arguments) {::Myco.find_constant(:ArgumentAssembly).new({
+      :arguments => ::Myco.branch_op(:"||", use_args) {::Myco.find_constant(:ArgumentAssembly).new({
         :line => self.line,
         :body => []
       })}

data/lib/myco/code_tools/AST/InvokeMethod.my

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   InvokeMethod < Node {
-    var receiver, var name, var arguments
-    
-    Form: [:call, :receiver, :name, :arguments]
+    node_type call
+    field receiver, field name, field arguments
     
     bytecode: |g| {
       self.receiver.bytecode(g)

data/lib/myco/code_tools/AST/InvokeMethod.my.rb

@@ -2,15 +2,10 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::InvokeMethod = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:receiver, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:arguments, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :call,
-    :receiver,
-    :name,
-    :arguments
-  ])
+  declare_meme(:call, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:receiver, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:arguments, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.receiver.bytecode(g)
     self.arguments.bytecode(g)

data/lib/myco/code_tools/AST/KeywordAssembly.my

@@ -2,15 +2,14 @@
 CodeTools::AST << {
   
   KeywordAssembly < Node {
-    var body
-    
-    Form: [:hash, :body]
+    node_type hash
+    field body
     
     bytecode: |g| {
       pos(g)
       
       g.push_cpath_top
-      g.find_const(:"Hash")
+      g.find_const(:Hash)
       g.push(self.body.size / 2)
       g.send(:new_from_literal, 1)
       

data/lib/myco/code_tools/AST/KeywordAssembly.my.rb

@@ -2,11 +2,8 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::KeywordAssembly = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :hash,
-    :body
-  ])
+  declare_meme(:hash, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     g.push_cpath_top

data/lib/myco/code_tools/AST/KeywordOptionalParameter.my

@@ -0,0 +1,16 @@
+
+CodeTools::AST << {
+  
+  KeywordOptionalParameter < Node {
+    node_type kwoptprm
+    field name, field value
+    
+    map_local: |scope| {
+      scope.new_local(:__myco_keywords_value__)
+      scope.new_local(self.name)
+    }
+    
+    bytecode: |g| { } # TODO: move ParameterAssembly logic to this method
+  }
+   
+}

data/lib/myco/code_tools/AST/KeywordOptionalParameter.my.rb

@@ -0,0 +1,14 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::KeywordOptionalParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:kwoptprm, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:map_local, [], nil, ::Myco.cscope.dup) { |scope| (
+    scope.new_local(:__myco_keywords_value__)
+    scope.new_local(self.name)
+  )}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| nil}
+)}}
+.tap { |__c__| __c__.__name__ = :KeywordOptionalParameter })})}}.instance

data/lib/myco/code_tools/AST/KeywordRequiredParameter.my

@@ -0,0 +1,16 @@
+
+CodeTools::AST << {
+  
+  KeywordRequiredParameter < Node {
+    node_type kwreqprm
+    field name
+    
+    map_local: |scope| {
+      scope.new_local(:__myco_keywords_value__)
+      scope.new_local(self.name)
+    }
+    
+    bytecode: |g| { } # TODO: move ParameterAssembly logic to this method
+  }
+   
+}

data/lib/myco/code_tools/AST/KeywordRequiredParameter.my.rb

@@ -0,0 +1,13 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::KeywordRequiredParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:kwreqprm, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:map_local, [], nil, ::Myco.cscope.dup) { |scope| (
+    scope.new_local(:__myco_keywords_value__)
+    scope.new_local(self.name)
+  )}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| nil}
+)}}
+.tap { |__c__| __c__.__name__ = :KeywordRequiredParameter })})}}.instance

data/lib/myco/code_tools/AST/KeywordRestParameter.my

@@ -0,0 +1,16 @@
+
+CodeTools::AST << {
+  
+  KeywordRestParameter < Node {
+    node_type kwrestprm
+    field name
+    
+    map_local: |scope| {
+      scope.new_local(:__myco_keywords_value__)
+      scope.new_local(self.name)
+    }
+    
+    bytecode: |g| { } # TODO: move ParameterAssembly logic to this method
+  }
+   
+}

data/lib/myco/code_tools/AST/KeywordRestParameter.my.rb

@@ -0,0 +1,13 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::KeywordRestParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:kwrestprm, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:map_local, [], nil, ::Myco.cscope.dup) { |scope| (
+    scope.new_local(:__myco_keywords_value__)
+    scope.new_local(self.name)
+  )}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| nil}
+)}}
+.tap { |__c__| __c__.__name__ = :KeywordRestParameter })})}}.instance

data/lib/myco/code_tools/AST/LocalVariableAccessAmbiguous.my

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   LocalVariableAccessAmbiguous < Node {
-    var name
-    
-    Form: [:lambig, :name]
+    node_type lambig
+    field name
     
     bytecode: |g| {
       pos(g)

data/lib/myco/code_tools/AST/LocalVariableAccessAmbiguous.my.rb

@@ -2,11 +2,8 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::LocalVariableAccessAmbiguous = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :lambig,
-    :name
-  ])
+  declare_meme(:lambig, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     local = g.state.scope.search_local(self.name)

data/lib/myco/code_tools/AST/LocalVariableAssignment.my

@@ -2,10 +2,10 @@
 CodeTools::AST << {
   
   LocalVariableAssignment < Node {
-    var name, var value
-    var variable # TODO: remove
+    node_type lasgn
+    field name, field value
     
-    Form: [:lasgn, :name, :value]
+    var variable # TODO: remove
     
     bytecode: |g| {
       var = g.state.scope.assign_local_reference(self)

data/lib/myco/code_tools/AST/LocalVariableAssignment.my.rb

@@ -2,14 +2,10 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::LocalVariableAssignment = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:lasgn, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:variable, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :lasgn,
-    :name,
-    :value
-  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     var = g.state.scope.assign_local_reference(self)
     ::Myco.branch_op(:"&&", self.value) {self.value.bytecode(g)}

data/lib/myco/code_tools/AST/Node.my

@@ -8,7 +8,7 @@ CodeTools::AST << {
     
     new_block_generator: |g, parameters| {
       blk = g.class.new
-      blk.name = g.state.name || :"__block__"
+      blk.name = g.state.name || :__block__
       blk.file = g.file
       blk.for_block = true
       
@@ -26,6 +26,36 @@ CodeTools::AST << {
       
       meth
     }
+    
+    static var node_type: null
+    static var fields:    [] # TODO: should be "static const"
+    
+    node_type: self.class.node_type
+    fields:    self.class.fields
+    representation: [
+      self.node_type, self.line, *self.fields.map |name| {
+        value = __send__(name)
+        value.?map |value| { value.?representation ?? value }
+          ?? value.?representation
+            ?? value
+      }
+    ]
+    
+    [decorators]
+    
+    # TODO: should be "const", not "var"
+    var node_type: Decorator {
+      apply: |meme| meme.target.node_type = meme.name
+      [transforms]
+      expose: false
+    }
+    
+    # TODO: should be "const", not "var"
+    var field: Decorator {
+      apply: |meme| meme.target.fields.push(meme.name)
+      [transforms]
+      var: true
+    }
   }
   
   # TODO: move this out of Node.my ?
@@ -33,7 +63,7 @@ CodeTools::AST << {
     var scope
     
     # TODO: decouple rubinius-compiler from rubinius-ast and remove this hack
-    sclass new: |scope| {
+    static new: |scope| {
       obj = allocate
       obj.scope = scope
       obj

data/lib/myco/code_tools/AST/Node.my.rb

@@ -35,12 +35,45 @@
       ::Myco.branch_op(:"&&", parameters) {parameters.generator_setup(meth)}
       meth
     )}
+    declare_meme(:node_type, [
+      [:var, []],
+      [:static, []]
+    ], nil, ::Myco.cscope.dup) { |*| (nil)}
+    declare_meme(:fields, [
+      [:var, []],
+      [:static, []]
+    ], nil, ::Myco.cscope.dup) { |*| ([])}
+    declare_meme(:node_type, [], nil, ::Myco.cscope.dup) { |*| (self.__send__(:class).node_type)}
+    declare_meme(:fields, [], nil, ::Myco.cscope.dup) { |*| (self.__send__(:class).fields)}
+    declare_meme(:representation, [], nil, ::Myco.cscope.dup) { |*| ([
+      self.node_type,
+      self.line,
+      *self.fields.map { |name| (
+        value = self.__send__(name)
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"??", (value.respond_to?(:map).false? ? ::Myco::Void : value.map { |value| (::Myco.branch_op(:"??", (value.respond_to?(:representation).false? ? ::Myco::Void : value.representation)) {value})})) {(value.respond_to?(:representation).false? ? ::Myco::Void : value.representation)}) {value}
+      )}
+    ])}
+    __category__(:decorators).component_eval {(
+      declare_meme(:node_type, [[:var, []]], 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| (meme.target.__send__(
+          :node_type=,
+          meme.name
+        ))}
+        __category__(:transforms).component_eval {(declare_meme(:expose, [], nil, ::Myco.cscope.dup) { |*| (false)})}
+      )}}.instance)}
+      declare_meme(:field, [[:var, []]], 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| (meme.target.fields.push(meme.name))}
+        __category__(:transforms).component_eval {(declare_meme(:var, [], nil, ::Myco.cscope.dup) { |*| (true)})}
+      )}}.instance)}
+    )}
   )}}
   .tap { |__c__| __c__.__name__ = :Node }
   ::Myco.cscope.for_method_definition::State = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
     declare_meme(:scope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:new, [[:sclass, []]], nil, ::Myco.cscope.dup) { |scope| (
+    declare_meme(:new, [[:static, []]], nil, ::Myco.cscope.dup) { |scope| (
       obj = self.allocate
       obj.__send__(
         :scope=,

data/lib/myco/code_tools/AST/NumericLiteral.my

@@ -0,0 +1,15 @@
+
+CodeTools::AST << {
+  
+  NumericLiteral < Node {
+    node_type numeric
+    field value
+    
+    bytecode: |g| {
+      pos(g)
+      
+      g.push_literal(self.value)
+    }
+  }
+  
+}

data/lib/myco/code_tools/AST/NumericLiteral.my.rb

@@ -0,0 +1,12 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::NumericLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:numeric, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    g.push_literal(self.value)
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :NumericLiteral })})}}.instance

data/lib/myco/code_tools/AST/OptionalParameter.my

@@ -0,0 +1,24 @@
+
+CodeTools::AST << {
+  
+  OptionalParameter < Node {
+    node_type optprm
+    field name, field value
+    
+    map_local: |scope| scope.new_local(self.name)
+    
+    bytecode: |g| {
+      done_label = g.new_label
+      
+      g.state.scope.search_local(self.name).get_bytecode(g)
+      g.goto_if_not_undefined(done_label)
+      
+      self.value.bytecode(g)
+      g.state.scope.search_local(self.name).set_bytecode(g)
+      g.pop
+      
+      done_label.set!
+    }
+  }
+   
+}

data/lib/myco/code_tools/AST/OptionalParameter.my.rb

@@ -0,0 +1,19 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::OptionalParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:optprm, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:map_local, [], nil, ::Myco.cscope.dup) { |scope| (scope.new_local(self.name))}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    done_label = g.new_label
+    g.state.scope.search_local(self.name).get_bytecode(g)
+    g.goto_if_not_undefined(done_label)
+    self.value.bytecode(g)
+    g.state.scope.search_local(self.name).set_bytecode(g)
+    g.pop
+    done_label.__send__(:set!)
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :OptionalParameter })})}}.instance