myco 0.1.9 → 0.1.10

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

@@ -2,23 +2,43 @@
 ::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::DeclareCategory = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:category, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:scope_implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:DeclaredScope).new({
-    :line => self.line,
-    :body => self.body,
-    :scope_method => :set_myco_category
-  }))}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    g.push_self
-    g.push_literal(self.name)
-    g.send(
-      :__category__,
-      1
-    )
-    self.scope_implementation.bytecode(g)
-  )}
+  declare_meme(
+    :category,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :name,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :scope_implementation,
+    [],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:DeclaredScope).new({
+      :line => self.line,
+      :body => self.body,
+      :scope_method => :set_myco_category
+    }))}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      g.push_self
+      g.push_literal(self.name)
+      g.send(
+        :__category__,
+        1
+      )
+      self.scope_implementation.bytecode(g)
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :DeclareCategory })})}}.instance

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

@@ -2,18 +2,34 @@
 ::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::DeclareExtension = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:copen, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:constant, [[:field, []]], 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)
-    scope = ::Myco.find_constant(:DeclaredScope).new({
-      :line => self.line,
-      :body => self.body,
-      :scope_method => :set_myco_component
-    })
-    self.constant.bytecode(g)
-    scope.bytecode(g)
-  )}
+  declare_meme(
+    :copen,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :constant,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      scope = ::Myco.find_constant(:DeclaredScope).new({
+        :line => self.line,
+        :body => self.body,
+        :scope_method => :set_myco_component
+      })
+      self.constant.bytecode(g)
+      scope.bytecode(g)
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :DeclareExtension })})}}.instance

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

@@ -2,36 +2,56 @@
 ::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::DeclareFile = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:declfile, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:inspect, [], nil, ::Myco.cscope.dup) { |*| (self.to_s)}
-  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (
-    type = ::Myco.find_constant(:ConstantAccess).new({
-      :line => self.line,
-      :toplevel => true,
-      :names => [
-        :Myco,
-        :FileToplevel
-      ]
-    })
-    types = ::Myco.find_constant(:ArrayAssembly).new({
-      :line => self.line,
-      :body => [type]
-    })
-    decl = ::Myco.find_constant(:DeclareObject).new({
-      :line => self.line,
-      :types => types,
-      :body => self.body
-    })
-    decl.scope_implementation.__send__(
-      :scope_method=,
-      :set_myco_file
-    )
-    decl
-  )}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    self.implementation.bytecode(g)
-  )}
+  declare_meme(
+    :declfile,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :inspect,
+    [],
+    ::Object::Proc.new { |*| (self.to_s)}
+  )
+  declare_meme(
+    :implementation,
+    [],
+    ::Object::Proc.new { |*| (
+      type = ::Myco.find_constant(:ConstantAccess).new({
+        :line => self.line,
+        :toplevel => true,
+        :names => [
+          :Myco,
+          :FileToplevel
+        ]
+      })
+      types = ::Myco.find_constant(:ArrayAssembly).new({
+        :line => self.line,
+        :body => [type]
+      })
+      decl = ::Myco.find_constant(:DeclareObject).new({
+        :line => self.line,
+        :types => types,
+        :body => self.body
+      })
+      decl.scope_implementation.__send__(
+        :scope_method=,
+        :set_myco_file
+      )
+      decl
+    )}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      self.implementation.bytecode(g)
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :DeclareFile })})}}.instance

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

@@ -2,76 +2,104 @@
 ::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::DeclareMeme = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:meme, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:decorations, [[:field, []]], 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)
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.effective_name.node_type.__send__(
-      :==,
-      :symbol
-    )) {(
-      g.push_scope
-      g.send(
-        :for_method_definition,
-        0
-      )
-      self.effective_name.bytecode(g)
-      self.effective_decorations.bytecode(g)
-      self.effective_body.bytecode(g)
-      g.send(
-        :declare_meme,
-        3
-      )
-    )}) {::Myco.find_constant(:ConstantAssignment).new({
-      :line => self.line,
-      :constant => self.effective_name,
-      :value => self.effective_body.block.body
-    }).bytecode(g)}
-  )}
-  declare_meme(:effective_name, [], nil, ::Myco.cscope.dup) { |*| (self.decorations.last)}
-  declare_meme(:effective_decorations, [], nil, ::Myco.cscope.dup) { |*| (
-    decorations = self.decorations.__send__(
-      :[],
-      ::Myco.find_constant(:Ruby)::Range.new(
-        0,
-        -1,
-        true
-      )
-    )
-    ::Myco.find_constant(:ArrayAssembly).new({
-      :line => self.line,
-      :body => decorations.reverse.map { |d| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", d.node_type.__send__(
+  declare_meme(
+    :meme,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :decorations,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.effective_name.node_type.__send__(
         :==,
-        :invoke
-      )) {::Myco.find_constant(:ArrayAssembly).new({
-        :line => d.line,
-        :body => [
-          ::Myco.find_constant(:SymbolLiteral).new({
-            :line => d.line,
-            :value => d.name
-          }),
-          ::Myco.find_constant(:ArrayAssembly).new({
-            :line => d.line,
-            :body => d.arguments.body
-          })
-        ]
-      })}) {d})}
-    })
-  )}
-  declare_meme(:effective_body, [], nil, ::Myco.cscope.dup) { |*| (
-    body = ::Myco.branch_op(:"||", self.body) {::Myco.find_constant(:BlockLiteral).new({
-      :line => self.line,
-      :block => ::Myco.find_constant(:Block).new({
+        :symbol
+      )) {(
+        g.push_scope
+        g.send(
+          :for_method_definition,
+          0
+        )
+        self.effective_name.bytecode(g)
+        self.effective_decorations.bytecode(g)
+        self.effective_body.bytecode(g)
+        g.send(
+          :declare_meme,
+          3
+        )
+      )}) {::Myco.find_constant(:ConstantAssignment).new({
         :line => self.line,
-        :body => ::Myco.find_constant(:NullLiteral).new({:line => self.line})
+        :constant => self.effective_name,
+        :value => self.effective_body.block.body
+      }).bytecode(g)}
+    )}
+  )
+  declare_meme(
+    :effective_name,
+    [],
+    ::Object::Proc.new { |*| (self.decorations.last)}
+  )
+  declare_meme(
+    :effective_decorations,
+    [],
+    ::Object::Proc.new { |*| (
+      decorations = self.decorations.__send__(
+        :[],
+        ::Myco.find_constant(:Ruby)::Range.new(
+          0,
+          -1,
+          true
+        )
+      )
+      ::Myco.find_constant(:ArrayAssembly).new({
+        :line => self.line,
+        :body => decorations.reverse.map { |d| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", d.node_type.__send__(
+          :==,
+          :invoke
+        )) {::Myco.find_constant(:ArrayAssembly).new({
+          :line => d.line,
+          :body => [
+            ::Myco.find_constant(:SymbolLiteral).new({
+              :line => d.line,
+              :value => d.name
+            }),
+            ::Myco.find_constant(:ArrayAssembly).new({
+              :line => d.line,
+              :body => d.arguments.body
+            })
+          ]
+        })}) {d})}
       })
-    })}
-    body.block.__send__(
-      :new_cscope=,
-      true
-    )
-    body
-  )}
+    )}
+  )
+  declare_meme(
+    :effective_body,
+    [],
+    ::Object::Proc.new { |*| (
+      body = ::Myco.branch_op(:"||", self.body) {::Myco.find_constant(:BlockLiteral).new({
+        :line => self.line,
+        :block => ::Myco.find_constant(:Block).new({
+          :line => self.line,
+          :body => ::Myco.find_constant(:NullLiteral).new({:line => self.line})
+        })
+      })}
+      body.block.__send__(
+        :new_cscope=,
+        true
+      )
+      body
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :DeclareMeme })})}}.instance

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

@@ -2,48 +2,72 @@
 ::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::DeclareObject = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:declobj, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:types, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:create, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (true)}
-  declare_meme(:scope_implementation, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:DeclaredScope).new({
-    :line => self.line,
-    :body => self.body,
-    :scope_method => :set_myco_component
-  }))}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    g.push_myco
-    g.find_const(:Component)
-    self.types.bytecode(g)
-    g.push_scope
-    g.send(
-      :for_method_definition,
-      0
-    )
-    g.push_scope
-    g.send(
-      :active_path,
-      0
-    )
-    g.meta_to_s
-    g.push_int(self.line)
-    g.send(
-      :new,
-      4
-    )
-    g.dup_top
-    g.dup_top
-    self.scope_implementation.bytecode(g)
-    g.send(
-      :__last__=,
-      1
-    )
-    g.pop
-    ::Myco.branch_op(:"&&", self.create) {g.send(
-      :instance,
-      0
+  declare_meme(
+    :declobj,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :types,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :create,
+    [:var],
+    ::Object::Proc.new { |*| (true)}
+  )
+  declare_meme(
+    :scope_implementation,
+    [:var],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:DeclaredScope).new({
+      :line => self.line,
+      :body => self.body,
+      :scope_method => :set_myco_component
+    }))}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      g.push_myco
+      g.find_const(:Component)
+      self.types.bytecode(g)
+      g.push_scope
+      g.send(
+        :for_method_definition,
+        0
+      )
+      g.push_scope
+      g.send(
+        :active_path,
+        0
+      )
+      g.meta_to_s
+      g.push_int(self.line)
+      g.send(
+        :new,
+        4
+      )
+      g.dup_top
+      g.dup_top
+      self.scope_implementation.bytecode(g)
+      g.send(
+        :__last__=,
+        1
+      )
+      g.pop
+      ::Myco.branch_op(:"&&", self.create) {g.send(
+        :instance,
+        0
+      )}
     )}
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :DeclareObject })})}}.instance