myco 0.1.3 → 0.1.4

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

@@ -0,0 +1,126 @@
+
+::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.const_set(:BlockLiteral, ::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(:parameters, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:parent, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :blklit,
+    :parameters,
+    :body
+  ]))
+  ::Myco.cscope.for_method_definition.const_set(:CompilerClass, (::Myco.find_constant(:CodeTools)::Compiler))
+  declare_meme(:parameters, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:ParameterAssembly).new({:line => self.line})})}
+  declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:NullLiteral).new({:line => self.line})})}
+  declare_meme(:locals, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ((self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).respond_to?(:body).false? ? ::Myco::Void : (self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
+  declare_meme(:block_local?, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", (self.locals.respond_to?(:include?).false? ? ::Myco::Void : self.locals.__send__(
+    :include?,
+    name
+  ))) {false})}
+  declare_meme(:module?, [], nil, ::Myco.cscope.dup) { |*| (false)}
+  declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
+    :parent=,
+    self
+  ))}
+  declare_meme(:search_local, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", variable = self.variables.__send__(
+    :[],
+    name
+  )) {variable.nested_reference}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.__send__(
+    :block_local?,
+    name
+  )) {self.new_local(name)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", reference = self.parent.search_local(name)) {(
+    reference.__send__(
+      :depth=,
+      reference.depth.__send__(
+        :+,
+        1
+      )
+    )
+    reference
+  )}) {nil}}})}
+  declare_meme(:assign_local_reference, [], nil, ::Myco.cscope.dup) { |var| (var.__send__(
+    :variable=,
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", variable = self.variables.__send__(
+      :[],
+      var.name
+    )) {variable.reference}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.__send__(
+      :block_local?,
+      var.name
+    )) {(
+      variable = self.new_local(var.name)
+      variable.reference
+    )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", reference = self.parent.search_local(var.name)) {(
+      reference.__send__(
+        :depth=,
+        reference.depth.__send__(
+          :+,
+          1
+        )
+      )
+      reference
+    )}) {(
+      variable = self.new_local(var.name)
+      variable.reference
+    )}}}
+  ))}
+  declare_meme(:new_local, [], nil, ::Myco.cscope.dup) { |name| (self.variables.__send__(
+    :[]=,
+    name,
+    ::Myco.branch_op(:"||", self.variables.__send__(
+      :[],
+      name
+    )) {::Myco.find_constant(:CompilerClass)::LocalVariable.new(self.allocate_slot)}
+  ))}
+  declare_meme(:new_nested_local, [], nil, ::Myco.cscope.dup) { |name| (self.new_local(name).nested_reference)}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    state = g.state
+    state.scope.nest_scope(self)
+    blk = self.new_block_generator(
+      g,
+      self.parameters
+    )
+    blk.push_state(self)
+    blk.definition_line(self.line)
+    blk.state.push_super(state.super)
+    blk.state.push_eval(state.eval)
+    blk.state.push_name(blk.name)
+    self.pos(blk)
+    self.parameters.bytecode(blk)
+    blk.state.push_block
+    blk.push_modifiers
+    blk.__send__(
+      :break=,
+      nil
+    )
+    blk.__send__(
+      :next=,
+      nil
+    )
+    blk.__send__(
+      :redo=,
+      blk.new_label
+    )
+    blk.redo.__send__(:set!)
+    self.body.bytecode(blk)
+    blk.pop_modifiers
+    blk.state.pop_block
+    blk.ret
+    blk.close
+    blk.pop_state
+    blk.__send__(
+      :local_count=,
+      self.local_count
+    )
+    blk.__send__(
+      :local_names=,
+      self.local_names
+    )
+    g.create_block(blk)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :BlockLiteral })})}}.instance

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

@@ -0,0 +1,25 @@
+
+CodeTools::AST << {
+  
+  BlockParameter < Node {
+    var name
+    var variable # TODO: remove
+    
+    Form: [:blkprm, :name]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      g.push_proc
+      
+      (self.variable.?depth > 0) &? (
+        g.set_local_depth(self.variable.depth, self.variable.slot)
+      ) ?? (
+        g.set_local(self.variable.slot)
+      )
+      
+      g.pop
+    }
+  }
+   
+}

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

@@ -0,0 +1,24 @@
+
+::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.const_set(:BlockParameter, ::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(:variable, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :blkprm,
+    :name
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    g.push_proc
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", (self.variable.respond_to?(:depth).false? ? ::Myco::Void : self.variable.depth).__send__(
+      :>,
+      0
+    )) {g.set_local_depth(
+      self.variable.depth,
+      self.variable.slot
+    )}) {g.set_local(self.variable.slot)}
+    g.pop
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :BlockParameter })})}}.instance

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

@@ -0,0 +1,18 @@
+
+CodeTools::AST << {
+  
+  Body < Node {
+    var array
+    
+    Form: [:block, :array]
+    
+    bytecode: |g| {
+      ary = self.array.dup
+      last = ary.pop
+      
+      ary.each |item| { item.bytecode(g); g.pop }
+      last.bytecode(g)
+    }
+  }
+  
+}

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

@@ -0,0 +1,20 @@
+
+::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.const_set(:Body, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:array, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :block,
+    :array
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    ary = self.array.dup
+    last = ary.pop
+    ary.each { |item| (
+      item.bytecode(g)
+      g.pop
+    )}
+    last.bytecode(g)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :Body })})}}.instance

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

@@ -0,0 +1,59 @@
+
+CodeTools::AST << {
+  
+  BranchOperator < Node {
+    var type, var left, var right
+    
+    Form: [:branch_op, :type, :left, :right]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      done_label = g.new_label
+      right_label = g.new_label
+      otherwise_push_void = false
+      
+      self.left.bytecode(g)
+      
+      type == :"&&" && (
+        g.dup_top
+        g.send(:"false?", 0)
+        g.goto_if_true(done_label)
+        g.pop
+      )
+      type == :"||" && (
+        g.dup_top
+        g.send(:"false?", 0)
+        g.goto_if_false(done_label)
+        g.pop
+      )
+      type == :"??" && (
+        g.dup_top
+        g.send(:"void?", 0)
+        g.goto_if_false(done_label)
+        g.pop
+      )
+      type == :"&?" && (
+        g.send(:"false?", 0)
+        g.goto_if_false(right_label)
+        otherwise_push_void = true
+      )
+      type == :"|?" && (
+        g.send(:"false?", 0)
+        g.goto_if_true(right_label)
+        otherwise_push_void = true
+      )
+      
+      otherwise_push_void && (
+        g.push_void
+        g.goto(done_label)
+        
+        right_label.set!
+      )
+      
+      self.right.bytecode(g)
+      done_label.set!
+    }
+  }
+  
+}

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

@@ -0,0 +1,87 @@
+
+::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.const_set(:BranchOperator, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:type, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:left, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:right, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :branch_op,
+    :type,
+    :left,
+    :right
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    done_label = g.new_label
+    right_label = g.new_label
+    otherwise_push_void = false
+    self.left.bytecode(g)
+    ::Myco.branch_op(:"&&", self.type.__send__(
+      :==,
+      :"&&"
+    )) {(
+      g.dup_top
+      g.send(
+        :false?,
+        0
+      )
+      g.goto_if_true(done_label)
+      g.pop
+    )}
+    ::Myco.branch_op(:"&&", self.type.__send__(
+      :==,
+      :"||"
+    )) {(
+      g.dup_top
+      g.send(
+        :false?,
+        0
+      )
+      g.goto_if_false(done_label)
+      g.pop
+    )}
+    ::Myco.branch_op(:"&&", self.type.__send__(
+      :==,
+      :"??"
+    )) {(
+      g.dup_top
+      g.send(
+        :void?,
+        0
+      )
+      g.goto_if_false(done_label)
+      g.pop
+    )}
+    ::Myco.branch_op(:"&&", self.type.__send__(
+      :==,
+      :"&?"
+    )) {(
+      g.send(
+        :false?,
+        0
+      )
+      g.goto_if_false(right_label)
+      otherwise_push_void = true
+    )}
+    ::Myco.branch_op(:"&&", self.type.__send__(
+      :==,
+      :"|?"
+    )) {(
+      g.send(
+        :false?,
+        0
+      )
+      g.goto_if_true(right_label)
+      otherwise_push_void = true
+    )}
+    ::Myco.branch_op(:"&&", otherwise_push_void) {(
+      g.push_void
+      g.goto(done_label)
+      right_label.__send__(:set!)
+    )}
+    self.right.bytecode(g)
+    done_label.__send__(:set!)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :BranchOperator })})}}.instance

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

@@ -0,0 +1,30 @@
+
+CodeTools::AST << {
+  
+  ConstantAccess < Node {
+    var toplevel, var names
+    
+    Form: [:const, :toplevel, :names]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      name_list = self.names.map(&:to_sym)
+      first_name = name_list.shift
+      
+      self.toplevel &? (
+        g.push_cpath_top
+        g.find_const(first_name)
+      ) ?? (
+        g.push_cpath_top
+        g.find_const(:"Myco")
+          g.push_literal(first_name)
+          g.push_scope
+        g.send(:find_constant, 2)
+      )
+      
+      name_list.each |name| { g.find_const(name) }
+    }
+  }
+  
+}

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

@@ -0,0 +1,32 @@
+
+::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.const_set(:ConstantAccess, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:toplevel, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:names, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :const,
+    :toplevel,
+    :names
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    name_list = self.names.map(&:to_sym)
+    first_name = name_list.shift
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {(
+      g.push_cpath_top
+      g.find_const(first_name)
+    )}) {(
+      g.push_cpath_top
+      g.find_const(:Myco)
+      g.push_literal(first_name)
+      g.push_scope
+      g.send(
+        :find_constant,
+        2
+      )
+    )}
+    name_list.each { |name| (g.find_const(name))}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :ConstantAccess })})}}.instance

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

@@ -0,0 +1,40 @@
+
+CodeTools::AST << {
+  
+  ConstantAssignment < Node {
+    var constant, var value
+    
+    Form: [:cdecl, :constant, :value]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      name_list = self.constant.names.map(&:to_sym)
+      last_name = name_list.pop
+      first_name = name_list.any? && name_list.shift
+      
+      self.constant.toplevel &? (
+        g.push_cpath_top
+        first_name && g.find_const(first_name)
+      ) ?? (
+        first_name &? (
+          g.push_cpath_top
+          g.find_const(:"Myco")
+            g.push_literal(first_name)
+            g.push_scope
+          g.send(:find_constant, 2)
+        ) ?? (
+          g.push_scope
+          g.send(:for_method_definition, 0)
+        )
+      )
+      
+      name_list.each |name| { g.find_const(name) }
+      
+      g.push_literal(last_name)
+      self.value.bytecode(g)
+      g.send(:const_set, 2)
+    }
+  }
+  
+}

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

@@ -0,0 +1,45 @@
+
+::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.const_set(:ConstantAssignment, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:constant, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :cdecl,
+    :constant,
+    :value
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    name_list = self.constant.names.map(&:to_sym)
+    last_name = name_list.pop
+    first_name = ::Myco.branch_op(:"&&", name_list.__send__(:any?)) {name_list.shift}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {(
+      g.push_cpath_top
+      ::Myco.branch_op(:"&&", first_name) {g.find_const(first_name)}
+    )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {(
+      g.push_cpath_top
+      g.find_const(:Myco)
+      g.push_literal(first_name)
+      g.push_scope
+      g.send(
+        :find_constant,
+        2
+      )
+    )}) {(
+      g.push_scope
+      g.send(
+        :for_method_definition,
+        0
+      )
+    )}}
+    name_list.each { |name| (g.find_const(name))}
+    g.push_literal(last_name)
+    self.value.bytecode(g)
+    g.send(
+      :const_set,
+      2
+    )
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :ConstantAssignment })})}}.instance

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

@@ -0,0 +1,30 @@
+
+CodeTools::AST << {
+  
+  ConstantDefine < Node {
+    var constant, var object
+    
+    Form: [:cdefn, :constant, :object]
+    
+    implementation: ConstantAssignment.new(
+      line:     self.line
+      constant: self.constant
+      value:    self.object
+    )
+    
+    # TODO: don't set AST state from here
+    setter object: |given| given.create = false; given
+    
+    bytecode: |g| {
+      pos(g)
+      
+      implementation.bytecode(g)
+      
+      g.dup_top
+        g.push_literal(self.constant.names.last)
+      g.send(:"__name__=", 1)
+      g.pop
+    }
+  }
+  
+}

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

@@ -0,0 +1,36 @@
+
+::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.const_set(:ConstantDefine, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:constant, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:object, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :cdefn,
+    :constant,
+    :object
+  ]))
+  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ConstantAssignment).new({
+    :line => self.line,
+    :constant => self.constant,
+    :value => self.object
+  }))}
+  declare_meme(:object, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (
+    given.__send__(
+      :create=,
+      false
+    )
+    given
+  )}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    self.implementation.bytecode(g)
+    g.dup_top
+    g.push_literal(self.constant.names.last)
+    g.send(
+      :__name__=,
+      1
+    )
+    g.pop
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :ConstantDefine })})}}.instance

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

@@ -0,0 +1,29 @@
+
+CodeTools::AST << {
+  
+  ConstantReopenScope < MycoModuleScope {
+    body_bytecode: |g| {
+      g.push_scope
+      g.send(:set_myco_component, 0)
+      g.pop
+      
+      self.body.bytecode(g)
+    }
+  }
+  
+  ConstantReopen < Node {
+    var constant, var body
+    
+    Form: [:copen, :constant, :body]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      scope = ConstantReopenScope.new(line:self.line, body:self.body)
+      
+      self.constant.bytecode(g)
+      scope.bytecode(g)
+    }
+  }
+  
+}

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

@@ -0,0 +1,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.const_set(:ConstantReopenScope, ::Myco::Component.new([::Myco.find_constant(:MycoModuleScope)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:body_bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    g.push_scope
+    g.send(
+      :set_myco_component,
+      0
+    )
+    g.pop
+    self.body.bytecode(g)
+  )})}})
+  .tap { |__c__| __c__.__name__ = :ConstantReopenScope }
+  ::Myco.cscope.for_method_definition.const_set(:ConstantReopen, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:constant, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    ::Myco.cscope.for_method_definition.const_set(:Form, ([
+      :copen,
+      :constant,
+      :body
+    ]))
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      scope = ::Myco.find_constant(:ConstantReopenScope).new({
+        :line => self.line,
+        :body => self.body
+      })
+      self.constant.bytecode(g)
+      scope.bytecode(g)
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :ConstantReopen }
+)})}}.instance

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

@@ -0,0 +1,35 @@
+
+CodeTools::AST << {
+  
+  DeclareCategoryScope < MycoModuleScope {
+    body_bytecode: |g| {
+      g.push_scope
+      g.send(:set_myco_category, 0)
+      g.pop
+      
+      self.body.bytecode(g)
+    }
+  }
+  
+  DeclareCategory < Node {
+    var name, var body
+    
+    Form: [:category, :name, :body]
+    
+    scope_implementation: DeclareCategoryScope.new(
+      line: self.line
+      body: self.body
+    )
+    
+    bytecode: |g| {
+      pos(g)
+      
+      g.push_self
+        g.push_literal(self.name)
+      g.send(:__category__, 1)
+      
+      scope_implementation.bytecode(g)
+    }
+  }
+  
+}