myco 0.1.7 → 0.1.8

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

@@ -1,46 +1,52 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco::BasicObject = ::Myco::Component.new([
-    ::Myco::EmptyObject,
-    ::Myco::BasicDecorators
-  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:if, [], nil, ::Myco.cscope.dup) { |cond, &blk| (::Myco.branch_op(:"&&", cond) {blk.call})}
-    declare_meme(:unless, [], nil, ::Myco.cscope.dup) { |cond, &blk| (::Myco.branch_op(:"||", cond) {blk.call})}
-    declare_meme(:case, [], nil, ::Myco.cscope.dup) { |input, *rest| (
-      use_strategy = ::Myco.branch_op(:"&&", rest.size.__send__(:odd?)) {rest.pop}
-      rest.each_slice(2).detect { |test_value, strategy| (::Myco.branch_op(:"&&", test_value.__send__(
-        :==,
-        input
-      )) {(
-        use_strategy = strategy
-        true
-      )})}
-      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", use_strategy) {::Myco.branch_op(:"??", (use_strategy.respond_to?(:call).false? ? ::Myco::Void : use_strategy.call(input))) {use_strategy}}) {self.raise("No match for case(#{input})")}
-    )}
-    declare_meme(:cond, [], nil, ::Myco.cscope.dup) { |*rest| (
-      use_strategy = ::Myco.branch_op(:"&&", rest.size.__send__(:odd?)) {rest.pop}
-      rest.each_slice(2).detect { |test_value, strategy| (::Myco.branch_op(:"&&", ::Myco.branch_op(:"??", (test_value.respond_to?(:call).false? ? ::Myco::Void : test_value.call)) {test_value}) {(
-        use_strategy = strategy
-        true
-      )})}
-      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", use_strategy) {::Myco.branch_op(:"??", (use_strategy.respond_to?(:call).false? ? ::Myco::Void : use_strategy.call)) {use_strategy}}) {self.raise("No match for cond")}
-    )}
-    declare_meme(:switch, [], nil, ::Myco.cscope.dup) { |input, comparator=:==| (::Myco.find_constant(:Switch).new({
-      :input => input,
-      :comparator => comparator
-    }))}
-    declare_meme(:raise, [], nil, ::Myco.cscope.dup) { |*args| (::Ruby::Kernel.instance_method(:raise).bind(self).call(*args))}
-    declare_meme(:loop, [], nil, ::Myco.cscope.dup) { |&block| (::Ruby::Kernel.instance_method(:loop).bind(self).call(&block))}
-    declare_meme(:break, [], nil, ::Myco.cscope.dup) { |*| (self.raise(::Ruby::StopIteration))}
-    declare_meme(:puts, [], nil, ::Myco.cscope.dup) { |*args| (::Myco.find_constant(:STDOUT).puts(*args))}
-    declare_meme(:p, [], nil, ::Myco.cscope.dup) { |*args| (::Myco.find_constant(:STDOUT).puts(args.map { |a| (a.inspect)}.join(", ")))}
-    declare_meme(:ruby_require, [], nil, ::Myco.cscope.dup) { |arg| (::Ruby.send(
-      :require,
-      arg
-    ))}
-  )}}
-  .tap { |__c__| __c__.__name__ = :BasicObject }
-  ::Myco::Instance::BasicObject = (::Myco::BasicObject)
-)}}.instance
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::BasicObject.component_eval {(
+  declare_meme(:if, [], nil, ::Myco.cscope.dup) { |cond, &blk| (::Myco.branch_op(:"&&", cond) {blk.call})}
+  declare_meme(:unless, [], nil, ::Myco.cscope.dup) { |cond, &blk| (::Myco.branch_op(:"||", cond) {blk.call})}
+  declare_meme(:case, [], nil, ::Myco.cscope.dup) { |input, *rest| (
+    use_strategy = ::Myco.branch_op(:"&&", rest.size.__send__(:odd?)) {rest.pop}
+    rest.each_slice(2).detect { |test_value, strategy| (::Myco.branch_op(:"&&", test_value.__send__(
+      :==,
+      input
+    )) {(
+      use_strategy = strategy
+      true
+    )})}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", use_strategy) {::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(use_strategy, :call).false? ? ::Myco::Void : use_strategy.call(input))) {use_strategy}}) {self.raise("No match for case(#{input})")}
+  )}
+  declare_meme(:cond, [], nil, ::Myco.cscope.dup) { |*rest| (
+    use_strategy = ::Myco.branch_op(:"&&", rest.size.__send__(:odd?)) {rest.pop}
+    rest.each_slice(2).detect { |test_value, strategy| (::Myco.branch_op(:"&&", ::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(test_value, :call).false? ? ::Myco::Void : test_value.call)) {test_value}) {(
+      use_strategy = strategy
+      true
+    )})}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", use_strategy) {::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(use_strategy, :call).false? ? ::Myco::Void : use_strategy.call)) {use_strategy}}) {self.raise("No match for cond")}
+  )}
+  declare_meme(:switch, [], nil, ::Myco.cscope.dup) { |input, comparator=:==| (::Myco.find_constant(:Switch).new({
+    :input => input,
+    :comparator => comparator
+  }))}
+  declare_meme(:raise, [], nil, ::Myco.cscope.dup) { |*args| (::Object.__send__(
+    :raise,
+    *args
+  ))}
+  declare_meme(:loop, [], nil, ::Myco.cscope.dup) { |&block| (::Object.__send__(
+    :loop,
+    &block
+  ))}
+  declare_meme(:break, [], nil, ::Myco.cscope.dup) { |*| (self.raise(::Object::StopIteration))}
+  declare_meme(:send, [], nil, ::Myco.cscope.dup) { |*args, &block| (self.__send__(
+    *args,
+    &block
+  ))}
+  declare_meme(:kind_of?, [], nil, ::Myco.cscope.dup) { |mod| (self.__kind_of__(mod))}
+  declare_meme(:is_a?, [], nil, ::Myco.cscope.dup) { |mod| (self.__kind_of__(mod))}
+  declare_meme(:class, [], nil, ::Myco.cscope.dup) { |*| (self.__class__)}
+  declare_meme(:dup, [], nil, ::Myco.cscope.dup) { |*| (self.__dup__)}
+  declare_meme(:puts, [], nil, ::Myco.cscope.dup) { |*args| (::Myco.find_constant(:STDOUT).puts(*args))}
+  declare_meme(:p, [], nil, ::Myco.cscope.dup) { |*args| (::Myco.find_constant(:STDOUT).puts(args.map { |a| (a.inspect)}.join(", ")))}
+  declare_meme(:ruby_require, [], nil, ::Myco.cscope.dup) { |arg| (::Object.send(
+    :require,
+    arg
+  ))}
+)})}}.instance

data/lib/myco/core/Category.my

@@ -1,5 +1,15 @@
 
-::Myco::Category < ::Myco::EmptyObject {
+::Myco::Category << {
   # Forward unknown methods to parent
-  method_missing: |sym, *a, &b| parent.send(sym, *a, &b)
+  method_missing: |sym, *a, &b| parent.__send__(sym, *a, &b)
+  
+  # TODO: make DRY with respect to BasicObject.my (or remove these methods entirely...)
+  send: |*args, &block| __send__(*args, &block)
+  
+  kind_of?: |mod| __kind_of__(mod)
+  is_a?:    |mod| __kind_of__(mod)
+  
+  class: __class__ # TODO: consider removing
+  
+  dup: __dup__ # TODO: remove
 }

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

@@ -1,9 +1,17 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Category = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |sym, *a, &b| (self.parent.send(
-  sym,
-  *a,
-  &b
-))})}}
-.tap { |__c__| __c__.__name__ = :Category })}}.instance
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Category.component_eval {(
+  declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |sym, *a, &b| (self.parent.__send__(
+    sym,
+    *a,
+    &b
+  ))}
+  declare_meme(:send, [], nil, ::Myco.cscope.dup) { |*args, &block| (self.__send__(
+    *args,
+    &block
+  ))}
+  declare_meme(:kind_of?, [], nil, ::Myco.cscope.dup) { |mod| (self.__kind_of__(mod))}
+  declare_meme(:is_a?, [], nil, ::Myco.cscope.dup) { |mod| (self.__kind_of__(mod))}
+  declare_meme(:class, [], nil, ::Myco.cscope.dup) { |*| (self.__class__)}
+  declare_meme(:dup, [], nil, ::Myco.cscope.dup) { |*| (self.__dup__)}
+)})}}.instance

data/lib/myco/core/Decorator.my

@@ -1,5 +1,5 @@
 
-::Myco::Decorator < ::Myco::BasicObject {
+::Myco::Decorator << {
   # Implement the apply meme to mutate the incoming meme in more custom ways.
   # This is run after transforms.apply has already mutated the meme.
   apply: |meme, *args| { }

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

@@ -1,33 +1,31 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Decorator = ::Myco::Component.new([::Myco::BasicObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Decorator.component_eval {(
   declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme, *args| nil}
   __category__(:transforms).component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme, *args| (
-    (self.respond_to?(:target).false? ? ::Myco::Void : self.target(meme)).tap { |x| (meme.__send__(
+    (Rubinius::Type.object_respond_to?(self, :target).false? ? ::Myco::Void : self.target(meme)).tap { |x| (meme.__send__(
       :target=,
       x
     ))}
-    (self.respond_to?(:name).false? ? ::Myco::Void : self.name(meme)).tap { |x| (meme.__send__(
+    (Rubinius::Type.object_respond_to?(self, :name).false? ? ::Myco::Void : self.name(meme)).tap { |x| (meme.__send__(
       :name=,
       x
     ))}
-    (self.respond_to?(:body).false? ? ::Myco::Void : self.body(meme)).tap { |x| (meme.__send__(
+    (Rubinius::Type.object_respond_to?(self, :body).false? ? ::Myco::Void : self.body(meme)).tap { |x| (meme.__send__(
       :body=,
       x
     ))}
-    (self.respond_to?(:cache).false? ? ::Myco::Void : self.cache(meme)).tap { |x| (meme.__send__(
+    (Rubinius::Type.object_respond_to?(self, :cache).false? ? ::Myco::Void : self.cache(meme)).tap { |x| (meme.__send__(
       :cache=,
       x
     ))}
-    (self.respond_to?(:var).false? ? ::Myco::Void : self.var(meme)).tap { |x| (meme.__send__(
+    (Rubinius::Type.object_respond_to?(self, :var).false? ? ::Myco::Void : self.var(meme)).tap { |x| (meme.__send__(
       :var=,
       x
     ))}
-    (self.respond_to?(:expose).false? ? ::Myco::Void : self.expose(meme)).tap { |x| (meme.__send__(
+    (Rubinius::Type.object_respond_to?(self, :expose).false? ? ::Myco::Void : self.expose(meme)).tap { |x| (meme.__send__(
       :expose=,
       x
     ))}
   )})}
-)}}
-.tap { |__c__| __c__.__name__ = :Decorator })}}.instance
+)})}}.instance

data/lib/myco/core/FileToplevel.my

@@ -1,5 +1,5 @@
 
-::Myco::FileToplevel < ::Myco::Object {
+::Myco::FileToplevel << {
   # TODO: don't use instance_variable_get
   dirname:  component.instance_variable_get("@dirname")
   basename: component.instance_variable_get("@basename")
@@ -9,7 +9,7 @@
   
   # Run the code in the given file, ignoring the return value but
   # importing the constants defined therein into the current namespace.
-  var import: Decorator {
+  const import: Decorator {
     apply: |meme| {
       load_paths = [meme.target.instance.dirname]
       scope = meme.target.constant_scope
@@ -25,7 +25,7 @@
   }
   # Force an import to assign to a constant in the current namespace
   # instead of being included into the current namespace.
-  var as: Decorator {
+  const as: Decorator {
     apply: |meme, given| meme.metadata[:as] = given
   }
 }

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

@@ -1,12 +1,11 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::FileToplevel = ::Myco::Component.new([::Myco::Object], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::FileToplevel.component_eval {(
   declare_meme(:dirname, [], nil, ::Myco.cscope.dup) { |*| (self.component.instance_variable_get("@dirname"))}
   declare_meme(:basename, [], nil, ::Myco.cscope.dup) { |*| (self.component.instance_variable_get("@basename"))}
   declare_meme(:filename, [], nil, ::Myco.cscope.dup) { |*| (self.component.instance_variable_get("@filename"))}
   __category__(:decorators).component_eval {(
-    declare_meme(:import, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    declare_meme(:import, [[:const, []]], 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| (
       load_paths = [meme.target.instance.dirname]
       scope = meme.target.constant_scope
@@ -25,12 +24,11 @@
         component
       )}) {meme.target.include(component)}
     )})}}.instance)}
-    declare_meme(:as, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    declare_meme(:as, [[:const, []]], 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, given| (meme.metadata.__send__(
       :[]=,
       :as,
       given
     ))})}}.instance)}
   )}
-)}}
-.tap { |__c__| __c__.__name__ = :FileToplevel })}}.instance
+)})}}.instance

data/lib/myco/core/Object.my

@@ -3,22 +3,19 @@
   # Send the named signal to all handlers for this object
   __signal__: |name, *args, &block| {
     component.ancestors.reverse.each |other| {
-      other.is_a?(Component) && (
-        inst = (component == other) &? self ?? other.instance
-        inst.?decorators.?on.?signal_handlers(name).each |meme| {
-          meme.result_for(self, *args, &block)
-        }
-      )
+      other.?__signal_handlers__(name).each |meme| {
+        meme.result_for(self, *args, &block)
+      }
     }
   }
   
+  static storage __signal_handlers__: []
+  
   [decorators]
   
   # Register a named signal handler
-  var on: Decorator {
-    storage signal_handlers: Array.new
-    
-    apply: |meme| signal_handlers(meme.name).push(meme)
+  const on: Decorator {
+    apply: |meme| meme.target.__signal_handlers__(meme.name).push(meme)
     
     [transforms]
     expose: false

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

@@ -2,24 +2,18 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Object = ::Myco::Component.new([::Myco::BasicObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:__signal__, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (self.component.ancestors.reverse.each { |other| (::Myco.branch_op(:"&&", other.__send__(
-    :is_a?,
-    ::Myco.find_constant(:Component)
-  )) {(
-    inst = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.component.__send__(
-      :==,
-      other
-    )) {self}) {other.instance}
-    (((inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).respond_to?(:on).false? ? ::Myco::Void : (inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).on).respond_to?(:signal_handlers).false? ? ::Myco::Void : ((inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).respond_to?(:on).false? ? ::Myco::Void : (inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).on).signal_handlers(name)).each { |meme| (meme.result_for(
-      self,
-      *args,
-      &block
-    ))}
-  )})})}
-  __category__(:decorators).component_eval {(declare_meme(:on, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:__signal__, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (self.component.ancestors.reverse.each { |other| ((Rubinius::Type.object_respond_to?(other, :__signal_handlers__).false? ? ::Myco::Void : other.__signal_handlers__(name)).each { |meme| (meme.result_for(
+    self,
+    *args,
+    &block
+  ))})})}
+  declare_meme(:__signal_handlers__, [
+    [:storage, []],
+    [:static, []]
+  ], nil, ::Myco.cscope.dup) { |*| ([])}
+  __category__(:decorators).component_eval {(declare_meme(:on, [[:const, []]], 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(:signal_handlers, [[:storage, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Array).new)}
-    declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (self.signal_handlers(meme.name).push(meme))}
+    declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (meme.target.__signal_handlers__(meme.name).push(meme))}
     __category__(:transforms).component_eval {(declare_meme(:expose, [], nil, ::Myco.cscope.dup) { |*| (false)})}
   )}}.instance)})}
 )}}

data/lib/myco/core/Ruby.my

@@ -0,0 +1,6 @@
+
+::Myco::Ruby < ::Ruby::Object, ::Myco::BasicObject {
+  static eval: |*a,&b| Kernel.eval(*a, &b)
+  
+  Eval < ::Myco::EmptyObject { from_string: |string| Ruby.eval(string) }
+}

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

@@ -0,0 +1,16 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Ruby = ::Myco::Component.new([
+  ::Object::Object,
+  ::Myco::BasicObject
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:eval, [[:static, []]], nil, ::Myco.cscope.dup) { |*a, &b| (::Myco.find_constant(:Kernel).eval(
+    *a,
+    &b
+  ))}
+  ::Myco.cscope.for_method_definition::Eval = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:from_string, [], nil, ::Myco.cscope.dup) { |string| (::Myco.find_constant(:Ruby).eval(string))})}}
+  .tap { |__c__| __c__.__name__ = :Eval }
+)}}
+.tap { |__c__| __c__.__name__ = :Ruby })}}.instance

data/lib/myco/core/Switch.my

@@ -6,7 +6,7 @@
   var comparator: :"=="
   
   when: |expected, &blk| {
-    matched || (input.send(comparator, expected) &&
+    matched || (input.__send__(comparator, expected) &&
       ((matched() = true) && (output() = blk.call(input))))
     self
   }

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

@@ -7,7 +7,7 @@
   declare_meme(:matched, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (false)}
   declare_meme(:comparator, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (:==)}
   declare_meme(:when, [], nil, ::Myco.cscope.dup) { |expected, &blk| (
-    ::Myco.branch_op(:"||", self.matched) {::Myco.branch_op(:"&&", self.input.send(
+    ::Myco.branch_op(:"||", self.matched) {::Myco.branch_op(:"&&", self.input.__send__(
       self.comparator,
       expected
     )) {::Myco.branch_op(:"&&", self.__send__(

data/lib/myco/core.my

@@ -0,0 +1,4 @@
+
+import "core/Object.my"
+import "core/Switch.my"
+import "core/Ruby.my"

data/lib/myco/core.my.rb

@@ -0,0 +1,7 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:"core/Object.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"core/Switch.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"core/Ruby.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+)}}.instance

data/lib/myco/dev/call_sites.rb

@@ -0,0 +1,39 @@
+
+module Myco
+  module DEV
+    class CallSites
+      class << self
+        
+        def report(*modules)
+          list = []
+          if modules.empty?
+            ObjectSpace.each_object(Module) { |mod| analyze_module(mod, list) }
+          else
+            modules.each { |mod| analyze_module(mod, list) }
+          end
+          list.uniq.sort
+        end
+        
+        def report!(*args, count: 2000)
+          list = report(*args)
+          list = list[-count..-1] if list.size > count
+          list.each { |item| p item }
+        end
+        
+        def analyze_module(mod, list)
+          mod.method_table.each_entry do |name, executable, _|
+            if executable.respond_to?(:call_sites)
+              executable.call_sites.each do |cache|
+                called = "#{cache.stored_module}##{cache.method.name}" rescue "#{cache.name}"
+                caller = "#{mod}##{name}"
+                location = "#{executable.active_path}:#{executable.line_from_ip(0)}"
+                
+                list.push [cache.hits, "#{called} in #{caller} near #{location}"]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/myco/dev/counter.rb

@@ -0,0 +1,26 @@
+
+module Myco
+  module DEV
+    class Counter
+      class << self
+        def coll
+          @coll ||= begin
+            at_exit { print! }
+            Hash.new(0)
+          end
+        end
+        
+        def count(*items)
+          coll[items] += 1
+        end
+        
+        def print!
+          STDOUT.puts "#{self} report:"
+          coll.to_a.sort_by { |x| x.last }.each do |key,val|
+            STDOUT.puts "  #{val} : #{key.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/myco/dev.rb

@@ -0,0 +1,3 @@
+
+require_relative 'dev/counter'
+require_relative 'dev/call_sites'

data/lib/myco/eval.rb

@@ -10,7 +10,7 @@ module Myco
   end
   
   # TODO: deprecate with proper import set of functions
-  def self.eval_file path, load_paths=nil, get_last=true, scope=nil
+  def self.eval_file path, load_paths=nil, get_last=true, scope=Rubinius::ConstantScope.new(::Myco, nil)
     load_paths ||= [File.dirname(Rubinius::VM.backtrace(1).first.file)]
     file_toplevel = CodeLoader.load(path, load_paths, cscope:scope, call_depth:1)
     get_last ? file_toplevel.component.__last__ : file_toplevel.component

data/lib/myco/tools/BasicCommand.my.rb

@@ -42,7 +42,7 @@
       )
       args = [
         name,
-        ::Myco.branch_op(:"??", (self.respond_to?(:argument).false? ? ::Myco::Void : self.argument)) {nil},
+        ::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self, :argument).false? ? ::Myco::Void : self.argument)) {nil},
         self.long_form,
         self.description
       ]

data/lib/myco/version.rb

@@ -1,6 +1,6 @@
 
 module Myco
-  MYCO_VERSION = '0.1.7'
+  MYCO_VERSION = '0.1.8'
   
   MYCO_REQUIRED_GEMS = [
     ['rubinius-toolset',   '~> 2.3'],

data/lib/myco.rb

@@ -3,6 +3,7 @@ require_relative 'myco/version'
 Myco.activate_required_gems
 
 Myco::SingletonClass = Myco.singleton_class
+require_relative 'myco/dev'
 
 require_relative 'myco/code_loader'
 require_relative 'myco/eval'
@@ -11,9 +12,6 @@ require_relative 'myco/backtrace'
 require_relative 'myco/bootstrap'
 
 
-# TODO: remove this hack after 0.1.7 gem release
-::Ruby = ::Object
-
 # Detect whether a second pass is necessary (when no bytecode is available)
 # TODO: recursively check mtime for all rbc files as well,
 #   to be sure that core implementation files don't need to be recompiled.
@@ -33,6 +31,7 @@ stages.each do |toolset_name|
       # TODO: be more clever here communicating the load path for bootstrapping
       Myco::CoreLoadPath = File.expand_path('myco', File.dirname(__FILE__))
       Myco.eval_file 'myco/bootstrap.my'
+      Myco.eval_file 'myco/core.my'
     end
     
     require "rubinius/compiler"