myco 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ac82f91bb59e1b38407f56839dc6f9a8a747813
-  data.tar.gz: d81314ee8a56b8950c7a42d253c77476ecef51e3
+  metadata.gz: 5c9a3ec14044d47105eb0c1448e65c08cebedfd9
+  data.tar.gz: b24c8a056f1df9e441dccc851b1eca9bd4293ad1
 SHA512:
-  metadata.gz: d594ed1f2693c0445ab02729a0f435ed13ca18251d4e9fd72b2b1070594e0fee3c7d3aa606936f57852fa41c1591f4250163463db690c91463ddc35aab6115d6
-  data.tar.gz: 2377868fe82a9a3fba6e5fdff7df63859d06c3514152661c32b89225f3d996501d5f363fa648645a727219b60441cfaa5a7536b0ee916adf162d182f33e03f91
+  metadata.gz: 59af162beb7b9ce35677eceba813cd1fbf35f73ce4630bac4e0afd87636f09a0e5973c1a3e7f600d99bcf07cffea296c915aa87d73f37360f0ac0f98d1c770b3
+  data.tar.gz: 37ad5495fa33dd8fa6afb55eff7fa27a221a138f61dcc30d053984c67ad340d3121af3b9b535f152c78f31bea4f6f7d8f7e445fb0887aeee86d7f64259d6ef9d

data/lib/myco/bootstrap/component.rb

@@ -127,6 +127,8 @@ module Myco
     def include *others
       others.reverse_each do |other|
         Rubinius::Type.include_modules_from(other, self.origin)
+        # TODO: avoid touching singleton class that doesn't already exist?
+        Rubinius::Type.include_modules_from(other.singleton_class, self.singleton_class.origin)
         Rubinius::Type.infect(self, other)
         other.__send__ :included, self
       end

data/lib/myco/bootstrap/evaluator.rb

@@ -0,0 +1,58 @@
+
+module Myco
+  class Evaluator
+    
+    def self.evaluate(cscope, data)
+      type, *rest = representation
+      __send__(:"evaluate_#{type}", *rest)
+    end
+    
+    def self.evaluate_component(cscope, types, create, contents)
+      component = ::Myco::Component.new(
+        types.map { |data| resolve_constant(cscope, *data) },
+        cscope.for_method_definition,
+        cscope.active_path.to_s,
+        line
+      )
+      
+      inner_cscope = ::Rubinius::ConstantScope.new(component, cscope)
+      component.__last__ = evaluate_contents(inner_cscope, contents)
+      
+      create ? component.instance : component
+    end
+    
+    def self.evaluate_category(cscope, name, contents)
+      category = cscope.for_method_definition.__category__(name)
+      
+      inner_cscope = ::Rubinius::ConstantScope.new(category, cscope)
+      evaluate_contents(inner_cscope, contents)
+    end
+    
+    def self.evaluate_meme(cscope, name, decorations, body)
+      cscope.for_method_definition.declare_meme(name, decorations, &body)
+    end
+    
+    def self.resolve_constant(cscope, toplevel, names)
+      first_name, *names = names
+      const = if toplevel
+        case first_name
+        when :Myco;   ::Myco
+        when :Ruby;   ::Object
+        when :Rubinius; Rubinius
+        else;         ::Myco.const_get(first_name)
+        end
+      else
+        ::Myco.find_constant(first_name, cscope)
+      end
+      
+      names.reduce(const) { |const, var| const.const_get(name) }
+    end
+    
+    def self.evaluate_contents(cscope, contents)
+      last = nil
+      contents.each { |item| last = evaluate(inner_cscope, item) }
+      last
+    end
+    
+  end
+end

data/lib/myco/bootstrap/instance.rb

@@ -42,7 +42,7 @@ module Myco
     # prepend (::Module.new {
       def method_missing name, *args
         msg = "#{to_s} has no method called '#{name}'"
-        ::Kernel.raise ::NoMethodError.new(msg, name, args)
+        ::Ruby::Kernel.raise ::NoMethodError.new(msg, name, args)
       end
     # })
     

data/lib/myco/bootstrap/meme.rb

@@ -264,12 +264,14 @@ module Myco
         g.pop
         
         ##
-        # if @#{:"__#{@name}_defined__"}
+        # if instance_variable_defined?(#{name})
         #   @#{name} = meme.body.invoke meme.name, @target, obj, [], nil
         # end
         # return @#{name}
         #
-        g.push_ivar(:"__#{@name}_defined__")
+        g.push_self
+        g.push_literal(:"@#{@name}")
+        g.send(:instance_variable_defined?, 1)
         g.goto_if_true(get)
         
         g.push_local 1 # meme
@@ -282,9 +284,6 @@ module Myco
         g.send :invoke, 5
         g.set_ivar(:"@#{@name}")
         
-        g.push_true
-        g.set_ivar(:"__#{@name}_defined__")
-        g.pop
         g.goto(ret)
         
         get.set!
@@ -314,10 +313,6 @@ module Myco
         g.total_args = 1
         g.local_count = 1
         
-        g.push_true
-        g.set_ivar(:"__#{@name}_defined__")
-        g.pop
-        
         g.push_local 0 # value
         
         # If this meme has a setter defined, use it

data/lib/myco/bootstrap.my

@@ -1,6 +1,6 @@
 
 ::Myco::RubyEval < EmptyObject {
-  from_string: |string| ::Kernel.instance_method(:eval).bind(self).call(string)
+  from_string: |string| ::Ruby::Kernel.instance_method(:eval).bind(self).call(string)
 }
 
 RubyEval @@@

data/lib/myco/bootstrap.my.rb

@@ -2,7 +2,7 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   ::Myco::RubyEval = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:from_string, [], nil, ::Myco.cscope.dup) { |string| (::Kernel.instance_method(:eval).bind(self).call(string))})}}
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:from_string, [], nil, ::Myco.cscope.dup) { |string| (::Ruby::Kernel.instance_method(:eval).bind(self).call(string))})}}
   .tap { |__c__| __c__.__name__ = :RubyEval }
   ::Myco::Component.new([::Myco.find_constant(:RubyEval)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance.from_string("  Myco.eval_file(\"core/Category.my\",        [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/BasicDecorators.my\", [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/BasicObject.my\",     [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/Decorator.my\",       [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/Object.my\",          [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/FileToplevel.my\",    [Myco::CoreLoadPath])\n  \n  # Below are not necessary for bootstrapping; TODO: move out of RubyEval\n  Myco.eval_file(\"core/Switch.my\",          [Myco::CoreLoadPath])\n")

data/lib/myco/code_loader.rb

@@ -131,7 +131,12 @@ module Myco
         @string || make_string
         
         parser = new_parser
-        ast = parser.parse_string(@string)
+        begin
+          ast = parser.parse_string(@string)
+        rescue Exception => e
+          full_message = "Error while parsing #{filename}:\n" + e.message
+          raise e.class, full_message, e.backtrace
+        end
         
         ast = ast_root_for(ast)
         ast.file = filename.to_sym

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

@@ -2,9 +2,9 @@
 CodeTools::AST << {
   
   ArgumentAssembly < Node {
-    var body, var block
-    
-    Form: [:argass, :body]
+    node_type args
+    field body
+    var block # TODO: remove this unnecessary state
     
     setter body: |given_body| {
       given_body.last.is_a?(BlockArgument) && (self.block = given_body.pop)
@@ -20,15 +20,11 @@ CodeTools::AST << {
       self.body.drop_while |item| { !item.is_a?(SplatValue) }
     
     # Symbol of bytecode operation to use for send
-    send_op: {
-      self.body.detect |item| { item.is_a?(SplatValue) } &? (
-        :send_with_splat
-      ) ?? (self.block &? (  # TODO: better elsif construction
-        :send_with_block
-      ) ?? (
-        :send
-      ))
-    }
+    send_op: cond(
+      self.body.detect |item| { item.is_a?(SplatValue) }, :send_with_splat,
+      self.block,                                         :send_with_block,
+                                                          :send,
+    )
     
     # Number of arguments to use for send operation
     send_count:

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

@@ -2,12 +2,9 @@
 ::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::ArgumentAssembly = ::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}
+  declare_meme(:args, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :argass,
-    :body
-  ])
   declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given_body| (
     ::Myco.branch_op(:"&&", given_body.last.__send__(
       :is_a?,
@@ -26,10 +23,16 @@
     :is_a?,
     ::Myco.find_constant(:SplatValue)
   ).__send__(:!))})}
-  declare_meme(:send_op, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.body.detect { |item| (item.__send__(
-    :is_a?,
-    ::Myco.find_constant(:SplatValue)
-  ))}) {:send_with_splat}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block) {:send_with_block}) {:send}})}
+  declare_meme(:send_op, [], nil, ::Myco.cscope.dup) { |*| (self.cond(
+    self.body.detect { |item| (item.__send__(
+      :is_a?,
+      ::Myco.find_constant(:SplatValue)
+    ))},
+    :send_with_splat,
+    self.block,
+    :send_with_block,
+    :send
+  ))}
   declare_meme(:send_count, [], nil, ::Myco.cscope.dup) { |*| (self.pre_group.size)}
   declare_meme(:splat_bytecode, [], nil, ::Myco.cscope.dup) { |g| (::Myco.find_constant(:ArrayAssembly).new({
     :line => self.line,

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   ArrayAssembly < Node {
-    var body
-    
-    Form: [:arrass, :body]
+    node_type array
+    field body
     
     bytecode: |g| {
       pos(g)

data/lib/myco/code_tools/AST/ArrayAssembly.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::ArrayAssembly = ::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 = ([
-    :arrass,
-    :body
-  ])
+  declare_meme(:array, [[: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)
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.body.__send__(:empty?)) {g.make_array(0)}) {(

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

@@ -2,15 +2,15 @@
 CodeTools::AST << {
   
   Block < CodeTools::Compiler::LocalVariables, Node {
-    var parameters, var body
-    var parent # TODO: investigate removing
+    node_type block
+    field parameters, field body
     
-    Form: [:block, :parameters, :body]
+    var parent # TODO: investigate removing
     
     CompilerClass: CodeTools::Compiler # TODO: remove this
     
     setter parameters: |given| given || ParameterAssembly.new(line:self.line)
-    setter body:      |given| given || NullLiteral.new(line:self.line)
+    setter body:       |given| given || NullLiteral.new(line:self.line)
     
     locals: self.body.?locals.?body.map(&:value) ?? null
     

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

@@ -5,14 +5,10 @@
   ::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(:block, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:parameters, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:parent, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :block,
-    :parameters,
-    :body
-  ])
   ::Myco.cscope.for_method_definition::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})})}

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   BlockArgument < Node {
-    var body
-    
-    Form: [:blkarg, :body]
+    node_type blkarg
+    field body
     
     bytecode: |g| {
       self.body.bytecode(g)
@@ -14,9 +13,9 @@ CodeTools::AST << {
       g.is_nil
       g.goto_if_true(done_label)
       
-      g.push_cpath_top; g.find_const(:"Proc")
+      g.push_cpath_top; g.find_const(:Proc)
         g.swap
-      g.send(:"__from_block__", 1)
+      g.send(:__from_block__, 1)
       
       done_label.set!
     }

data/lib/myco/code_tools/AST/BlockArgument.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::BlockArgument = ::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 = ([
-    :blkarg,
-    :body
-  ])
+  declare_meme(:blkarg, [[: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.body.bytecode(g)
     done_label = g.new_label

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

@@ -2,14 +2,13 @@
 CodeTools::AST << {
   
   BlockLiteral < Node {
-    var block
-    
-    Form: [:blklit, :block]
+    node_type blklit
+    field block
     
     implementation_receiver: ConstantAccess.new(
       line:     self.line
       toplevel: true
-      names:    [:"Proc"]
+      names:    [:Ruby, :Proc]
     )
     
     implementation: Invoke.new(

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

@@ -2,15 +2,15 @@
 ::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::BlockLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :blklit,
-    :block
-  ])
+  declare_meme(:blklit, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:block, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:implementation_receiver, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ConstantAccess).new({
     :line => self.line,
     :toplevel => true,
-    :names => [:Proc]
+    :names => [
+      :Ruby,
+      :Proc
+    ]
   }))}
   declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Invoke).new({
     :line => self.line,

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

@@ -2,22 +2,15 @@
 CodeTools::AST << {
   
   BlockParameter < Node {
-    var name
-    var variable # TODO: remove
-    
-    Form: [:blkprm, :name]
+    node_type blkprm
+    field name
     
+    map_local: |scope| scope.new_local(self.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.state.scope.search_local(self.name).set_bytecode(g)
       g.pop
     }
   }

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

@@ -2,22 +2,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::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::Form = ([
-    :blkprm,
-    :name
-  ])
+  declare_meme(:blkprm, [[: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(self.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.state.scope.search_local(self.name).set_bytecode(g)
     g.pop
   )}
 )}}

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   BranchOperator < Node {
-    var type, var left, var right
-    
-    Form: [:branch_op, :type, :left, :right]
+    node_type branch_op
+    field type, field left, field right
     
     bytecode: |g| {
       pos(g)

data/lib/myco/code_tools/AST/BranchOperator.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::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::Form = ([
-    :branch_op,
-    :type,
-    :left,
-    :right
-  ])
+  declare_meme(:branch_op, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:type, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:left, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:right, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     done_label = g.new_label

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   ConstantAccess < Node {
-    var toplevel, var names
-    
-    Form: [:const, :toplevel, :names]
+    node_type const
+    field toplevel, field names
     
     bytecode: |g| {
       pos(g)
@@ -13,8 +12,13 @@ CodeTools::AST << {
       first_name = name_list.shift
       
       self.toplevel &? (
-        g.push_cpath_top
-        g.find_const(first_name)
+        # The conceptual toplevel in Myco is the Myco namespace
+        first_name case(
+          :Myco,     &{ g.push_myco },
+          :Ruby,     &{ g.push_cpath_top },
+          :Rubinius, &{ g.push_rubinius },
+                     &{ g.push_myco; g.find_const(first_name) }
+        )
       ) ?? (
         Myco.find_constant_bytecode(g, first_name)
       )
@@ -24,8 +28,7 @@ CodeTools::AST << {
     
     ::Myco::SingletonClass << {
       find_constant_bytecode: |g, name| {
-        g.push_cpath_top
-        g.find_const(:"Myco")
+        g.push_myco
           g.push_literal(name)
           g.push_scope
         g.send(:find_constant, 2)
@@ -61,7 +64,7 @@ CodeTools::AST << {
         
       #   fail_label.set!                         # stack: myco_levels, mod
       #   g.pop                                   # stack: myco_levels
-      #   g.push_cpath_top; g.find_const(:"Myco") # stack: myco_levels, ::Myco
+      #   g.push_myco                             # stack: myco_levels, Myco
       #     g.push_literal(name)
       #   g.send(:const_get, 1)                   # stack: myco_levels, result
         

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

@@ -2,20 +2,25 @@
 ::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::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::Form = ([
-    :const,
-    :toplevel,
-    :names
-  ])
+  declare_meme(:const, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:toplevel, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:names, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   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)
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
+      first_name,
+      :Myco,
+      ::Proc.new { || (g.push_myco)},
+      :Ruby,
+      ::Proc.new { || (g.push_cpath_top)},
+      :Rubinius,
+      ::Proc.new { || (g.push_rubinius)},
+      ::Proc.new { || (
+        g.push_myco
+        g.find_const(first_name)
+      )}
     )}) {::Myco.find_constant(:Myco).find_constant_bytecode(
       g,
       first_name
@@ -23,8 +28,7 @@
     name_list.each { |name| (g.find_const(name))}
   )}
   ::Myco::SingletonClass.component_eval {(declare_meme(:find_constant_bytecode, [], nil, ::Myco.cscope.dup) { |g, name| (
-    g.push_cpath_top
-    g.find_const(:Myco)
+    g.push_myco
     g.push_literal(name)
     g.push_scope
     g.send(

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   ConstantAssignment < Node {
-    var constant, var value
-    
-    Form: [:cdecl, :constant, :value]
+    node_type cdecl
+    field constant, field value
     
     bytecode: |g| {
       pos(g)
@@ -14,8 +13,17 @@ CodeTools::AST << {
       first_name = name_list.any? && name_list.shift
       
       self.constant.toplevel &? (
-        g.push_cpath_top
-        first_name && g.find_const(first_name)
+        first_name &? (
+          # The conceptual toplevel in Myco is the Myco namespace
+          first_name case(
+            :Myco,     &{ g.push_myco },
+            :Ruby,     &{ g.push_cpath_top },
+            :Rubinius, &{ g.push_rubinius },
+                       &{ g.push_myco; g.find_const(first_name) }
+          )
+        ) ?? (
+          g.push_myco
+        )
       ) ?? (
         first_name &? (
           Myco.find_constant_bytecode(g, first_name)

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

@@ -2,22 +2,27 @@
 ::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::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::Form = ([
-    :cdecl,
-    :constant,
-    :value
-  ])
+  declare_meme(:cdecl, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:constant, [[:field, []]], 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)
     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) {::Myco.find_constant(:Myco).find_constant_bytecode(
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
+      first_name,
+      :Myco,
+      ::Proc.new { || (g.push_myco)},
+      :Ruby,
+      ::Proc.new { || (g.push_cpath_top)},
+      :Rubinius,
+      ::Proc.new { || (g.push_rubinius)},
+      ::Proc.new { || (
+        g.push_myco
+        g.find_const(first_name)
+      )}
+    )}) {g.push_myco}}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {::Myco.find_constant(:Myco).find_constant_bytecode(
       g,
       first_name
     )}) {(

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   ConstantDefine < Node {
-    var constant, var object
-    
-    Form: [:cdefn, :constant, :object]
+    node_type cdefn
+    field constant, field object
     
     implementation: ConstantAssignment.new(
       line:     self.line