opal 0.9.0.beta2 → 0.9.0.rc1

data/opal/corelib/helpers.rb

@@ -112,5 +112,5 @@ module Opal
     end
 
     name
-  end  
+  end
 end

data/opal/corelib/io.rb

@@ -18,7 +18,11 @@ class IO
     string.size
   end
 
-  attr_accessor :sync
+  attr_accessor :sync, :tty
+
+  def flush
+    # noop
+  end
 
   module Writable
     def <<(string)
@@ -65,9 +69,8 @@ STDERR = $stderr = IO.new
 STDIN  = $stdin  = IO.new
 STDOUT = $stdout = IO.new
 
+STDOUT.write_proc = `typeof(process) === 'object' ? function(s){process.stdout.write(s)} : function(s){console.log(s)}`
+STDERR.write_proc = `typeof(process) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)}`
 
-$stdout.write_proc = `typeof(process) === 'object' ? function(s){process.stdout.write(s)} : function(s){console.log(s)}`
-$stderr.write_proc = `typeof(process) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)}`
-
-$stdout.extend(IO::Writable)
-$stderr.extend(IO::Writable)
+STDOUT.extend(IO::Writable)
+STDERR.extend(IO::Writable)

data/opal/corelib/kernel.rb

@@ -105,7 +105,7 @@ module Kernel
   def copy_instance_variables(other)
     %x{
       for (var name in other) {
-        if (name.charAt(0) !== '$') {
+        if (other.hasOwnProperty(name) && name.charAt(0) !== '$') {
           self[name] = other[name];
         }
       }
@@ -177,7 +177,12 @@ module Kernel
   end
 
   def exit(status = true)
-    $__at_exit__.reverse.each(&:call) if $__at_exit__
+    $__at_exit__ ||= []
+    loop do
+      block = $__at_exit__.pop
+      block ? block.call : break
+    end
+
     status = 0 if `status === true` # it's in JS because it can be null/undef
     `Opal.exit(status);`
     nil
@@ -190,6 +195,10 @@ module Kernel
       for (var i = mods.length - 1; i >= 0; i--) {
         var mod = mods[i];
 
+        if (!mod.$$is_module) {
+          #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
+        }
+
         #{`mod`.append_features `singleton`};
         #{`mod`.extended self};
       }
@@ -740,7 +749,7 @@ module Kernel
   end
 
   def hash
-    "#{self.class}:#{self.class.__id__}:#{__id__}"
+    __id__
   end
 
   def initialize_copy(other)
@@ -770,7 +779,7 @@ module Kernel
     name = Opal.instance_variable_name!(name)
 
     %x{
-      var ivar = self[name.substr(1)];
+      var ivar = self[Opal.ivar(name.substr(1))];
 
       return ivar == null ? nil : ivar;
     }
@@ -779,18 +788,37 @@ module Kernel
   def instance_variable_set(name, value)
     name = Opal.instance_variable_name!(name)
 
-    `self[name.substr(1)] = value`
+    `self[Opal.ivar(name.substr(1))] = value`
+  end
+
+  def remove_instance_variable(name)
+    name = Opal.instance_variable_name!(name)
+
+    %x{
+      var key = Opal.ivar(name.substr(1)),
+          val;
+      if (self.hasOwnProperty(key)) {
+        val = self[key];
+        delete self[key];
+        return val;
+      }
+    }
+
+    raise NameError, "instance variable #{name} not defined"
   end
 
   def instance_variables
     %x{
-      var result = [];
+      var result = [], ivar;
 
       for (var name in self) {
-        if (name.charAt(0) !== '$') {
-          if (name !== '$$class' && name !== '$$id') {
-            result.push('@' + name);
+        if (self.hasOwnProperty(name) && name.charAt(0) !== '$') {
+          if (name.substr(-1) === '$') {
+            ivar = name.slice(0, name.length - 1);
+          } else {
+            ivar = name;
           }
+          result.push('@' + ivar);
         }
       }
 

data/opal/corelib/module.rb

@@ -1,8 +1,7 @@
 class Module
   def self.new(&block)
     %x{
-      function AnonModule(){}
-      var klass         = Opal.boot(Opal.Module, AnonModule);
+      var klass         = Opal.boot_module_object();
       klass.$$name      = nil;
       klass.$$class     = Opal.Module;
       klass.$$dep       = []
@@ -67,21 +66,7 @@ class Module
   end
 
   def ancestors
-    %x{
-      var parent = self,
-          result = [];
-
-      while (parent) {
-        result.push(parent);
-        for (var i=0; i < parent.$$inc.length; i++) {
-          result = result.concat(parent.$$inc[i].$ancestors());
-        }
-
-        parent = parent.$$is_class ? parent.$$super : null;
-      }
-
-      return result;
-    }
+    `Opal.ancestors(self)`
   end
 
   def append_features(klass)
@@ -347,6 +332,10 @@ class Module
           continue;
         }
 
+        if (!mod.$$is_module) {
+          #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
+        }
+
         #{`mod`.append_features self};
         #{`mod`.included self};
       }

data/opal/corelib/nil.rb

@@ -71,6 +71,10 @@ class NilClass
   def to_r
     Rational(0, 1)
   end
+
+  def instance_variables
+    []
+  end
 end
 
 NIL = nil

data/opal/corelib/number.rb

@@ -392,10 +392,6 @@ class Number < Numeric
     [gcd, lcm]
   end
 
-  def hash
-    `'Numeric:'+self.toString()`
-  end
-
   def integer?
     `self % 1 === 0`
   end

data/opal/corelib/runtime.js

@@ -4,6 +4,36 @@
     return this.Opal;
   }
 
+  var nil;
+
+  // The actual class for BasicObject
+  var BasicObject;
+
+  // The actual Object class.
+  // The leading underscore is to avoid confusion with window.Object()
+  var _Object;
+
+  // The actual Module class
+  var Module;
+
+  // The actual Class class
+  var Class;
+
+  // Constructor for instances of BasicObject
+  function BasicObject_alloc(){}
+
+  // Constructor for instances of Object
+  function Object_alloc(){}
+
+  // Constructor for instances of Class
+  function Class_alloc(){}
+
+  // Constructor for instances of Module
+  function Module_alloc(){}
+
+  // Constructor for instances of NilClass (nil)
+  function NilClass_alloc(){}
+
   // The Opal object that is exposed globally
   var Opal = this.Opal = {};
 
@@ -51,26 +81,25 @@
   // Exit function, this should be replaced by platform specific implementation
   // (See nodejs and phantom for examples)
   Opal.exit = function(status) { if (Opal.gvars.DEBUG) console.log('Exited with status '+status); };
-	
+
   // keeps track of exceptions for $!
   Opal.exceptions = [];
 
-  /**
-    Get a constant on the given scope. Every class and module in Opal has a
-    scope used to store, and inherit, constants. For example, the top level
-    `Object` in ruby has a scope accessible as `Opal.Object.$$scope`.
-
-    To get the `Array` class using this scope, you could use:
-
-        Opal.Object.$$scope.get("Array")
-
-    If a constant with the given name cannot be found, then a dispatch to the
-    class/module's `#const_method` is called, which by default will raise an
-    error.
-
-    @param [String] name the name of the constant to lookup
-    @returns [RubyObject]
-  */
+  // Get a constant on the given scope. Every class and module in Opal has a
+  // scope used to store, and inherit, constants. For example, the top level
+  // `Object` in ruby has a scope accessible as `Opal.Object.$$scope`.
+  //
+  // To get the `Array` class using this scope, you could use:
+  //
+  //     Opal.Object.$$scope.get("Array")
+  //
+  // If a constant with the given name cannot be found, then a dispatch to the
+  // class/module's `#const_method` is called, which by default will raise an
+  // error.
+  //
+  // @param [String] name the name of the constant to lookup
+  // @return [RubyObject]
+  //
   Opal.get = function(name) {
     var constant = this[name];
 
@@ -81,12 +110,11 @@
     return constant;
   };
 
-  /*
-   * Create a new constants scope for the given class with the given
-   * base. Constants are looked up through their parents, so the base
-   * scope will be the outer scope of the new klass.
-   */
-  function create_scope(base, klass, id) {
+  // Create a new constants scope for the given class with the given
+  // base. Constants are looked up through their parents, so the base
+  // scope will be the outer scope of the new klass.
+  //
+  Opal.create_scope = function(base, klass, id) {
     var const_alloc = function() {};
     var const_scope = const_alloc.prototype = new base.constructor();
 
@@ -98,45 +126,51 @@
     const_scope.constants   = [];
 
     if (id) {
-      Opal.cdecl(base, id, klass)
+      Opal.cdecl(base, id, klass);
+      const_alloc.displayName = id+"_alloc";
     }
   }
 
-  Opal.create_scope = create_scope;
-
-  /*
-   * A `class Foo; end` expression in ruby is compiled to call this runtime
-   * method which either returns an existing class of the given name, or creates
-   * a new class in the given `base` scope.
-   *
-   * If a constant with the given name exists, then we check to make sure that
-   * it is a class and also that the superclasses match. If either of these
-   * fail, then we raise a `TypeError`. Note, superklass may be null if one was
-   * not specified in the ruby code.
-   *
-   * We pass a constructor to this method of the form `function ClassName() {}`
-   * simply so that classes show up with nicely formatted names inside debuggers
-   * in the web browser (or node/sprockets).
-   *
-   * The `base` is the current `self` value where the class is being created
-   * from. We use this to get the scope for where the class should be created.
-   * If `base` is an object (not a class/module), we simple get its class and
-   * use that as the base instead.
-   *
-   * @param [Object] base where the class is being created
-   * @param [Class] superklass superclass of the new class (may be null)
-   * @param [String] id the name of the class to be created
-   * @param [Function] constructor function to use as constructor
-   * @return [Class] new or existing ruby class
-   */
+  // A `class Foo; end` expression in ruby is compiled to call this runtime
+  // method which either returns an existing class of the given name, or creates
+  // a new class in the given `base` scope.
+  //
+  // If a constant with the given name exists, then we check to make sure that
+  // it is a class and also that the superclasses match. If either of these
+  // fail, then we raise a `TypeError`. Note, superklass may be null if one was
+  // not specified in the ruby code.
+  //
+  // We pass a constructor to this method of the form `function ClassName() {}`
+  // simply so that classes show up with nicely formatted names inside debuggers
+  // in the web browser (or node/sprockets).
+  //
+  // The `base` is the current `self` value where the class is being created
+  // from. We use this to get the scope for where the class should be created.
+  // If `base` is an object (not a class/module), we simple get its class and
+  // use that as the base instead.
+  //
+  // @param [Object] base where the class is being created
+  // @param [Class] superklass superclass of the new class (may be null)
+  // @param [String] id the name of the class to be created
+  // @param [Function] constructor function to use as constructor
+  // @return [Class] new or existing ruby class
+  //
   Opal.klass = function(base, superklass, id, constructor) {
+    var klass, bridged, alloc;
+
     // If base is an object, use its class
     if (!base.$$is_class && !base.$$is_module) {
       base = base.$$class;
     }
 
-    var klass   = base.$$scope[id],
-        bridged = typeof(superklass) === 'function';
+    // If the superclass is a function then we're bridging a native JS class
+    if (typeof(superklass) === 'function') {
+      bridged = superklass;
+      superklass = _Object;
+    }
+
+    // Try to find the class in the current scope
+    klass = base.$$scope[id];
 
     // If the class exists in the scope, then we must use that
     if (klass && klass.$$orig_scope === base.$$scope) {
@@ -153,38 +187,42 @@
       return klass;
     }
 
+    // Class doesnt exist, create a new one with given superclass...
+
     // Not specifying a superclass means we can assume it to be Object
-    if (superklass === null) {
-      superklass = ObjectClass;
+    if (superklass == null) {
+      superklass = _Object;
     }
 
-    // if class doesnt exist, create a new one with given superclass
-    klass = bridged ?
-      boot_class_object(ObjectClass, superklass) :
-      boot_class(superklass, constructor);
+    // If bridged the JS class will also be the alloc function
+    alloc = bridged || boot_class_alloc(id, constructor, superklass);
 
-    // name class using base (e.g. Foo or Foo::Baz)
+    // Create the class object (instance of Class)
+    klass = boot_class_object(id, superklass, alloc);
+
+    // Name the class
     klass.$$name = id;
+    klass.displayName = id;
 
-    // mark the object as a class
+    // Mark the object as a class
     klass.$$is_class = true;
 
-    // every class gets its own constant scope, inherited from current scope
-    create_scope(base.$$scope, klass, id);
+    // Every class gets its own constant scope, inherited from current scope
+    Opal.create_scope(base.$$scope, klass, id);
 
     // Name new class directly onto current scope (Opal.Foo.Baz = klass)
     base[id] = base.$$scope[id] = klass;
 
     if (bridged) {
-      Opal.bridge(klass, superklass);
+      Opal.bridge(klass, alloc);
     }
     else {
       // Copy all parent constants to child, unless parent is Object
-      if (superklass !== ObjectClass && superklass !== BasicObjectClass) {
+      if (superklass !== _Object && superklass !== BasicObject) {
         donate_constants(superklass, klass);
       }
 
-      // call .inherited() hook with new class on the superclass
+      // Call .inherited() hook with new class on the superclass
       if (superklass.$inherited) {
         superklass.$inherited(klass);
       }
@@ -194,33 +232,34 @@
   };
 
   // Create generic class with given superclass.
-  function boot_class(superklass, constructor) {
+  Opal.boot_class = function(superklass, constructor) {
     var alloc = boot_class_alloc(null, constructor, superklass)
 
-    return boot_class_object(superklass, alloc);
+    return boot_class_object(null, superklass, alloc);
   }
 
-  // Make `boot_class` available to the JS-API
-  Opal.boot = boot_class;
-
-  /*
-   * The class object itself (as in `Class.new`)
-   *
-   * @param [(Opal) Class] superklass Another class object (as in `Class.new`)
-   * @param [constructor]  alloc      The constructor that holds the prototype
-   *                                  that will be used for instances of the
-   *                                  newly constructed class.
-   */
-  function boot_class_object(superklass, alloc) {
-    var singleton_class = function() {};
-    singleton_class.prototype = superklass.constructor.prototype;
+  // The class object itself (as in `Class.new`)
+  //
+  // @param superklass [(Opal) Class] Another class object (as in `Class.new`)
+  // @param alloc      [constructor]  The constructor that holds the prototype
+  //                                  that will be used for instances of the
+  //                                  newly constructed class.
+  function boot_class_object(id, superklass, alloc) {
+    // Grab the superclass prototype and use it to build an intermediary object
+    // in the prototype chain.
+    function Superclass_alloc_proxy() {};
+    Superclass_alloc_proxy.prototype = superklass.constructor.prototype;
+    function SingletonClass_alloc() {}
+    SingletonClass_alloc.prototype = new Superclass_alloc_proxy();
 
-    function OpalClass() {}
-    OpalClass.prototype = new singleton_class();
+    if (id) {
+      SingletonClass_alloc.displayName = "SingletonClass_alloc("+id+")";
+    }
 
-    var klass = new OpalClass();
+    // The built class is the only instance of its singleton_class
+    var klass = new SingletonClass_alloc();
 
-    setup_module_or_class_object(klass, OpalClass, superklass, alloc.prototype);
+    setup_module_or_class_object(klass, SingletonClass_alloc, superklass, alloc.prototype);
 
     // @property $$alloc This is the constructor of instances of the current
     //                   class. Its prototype will be used for method lookup
@@ -233,22 +272,21 @@
     return klass;
   }
 
-  /*
-   * Adds common/required properties to a module or class object
-   * (as in `Module.new` / `Class.new`)
-   *
-   * @param module      The module or class that needs to be prepared
-   *
-   * @param constructor The constructor of the module or class itself,
-   *                    usually it's already assigned by using `new`. Some
-   *                    ipothesis on why it's needed can be found below.
-   *
-   * @param superklass  The superclass of the class/module object, for modules
-   *                    is `Module` (of `ModuleClass` in JS context)
-   *
-   * @param prototype   The prototype on which the class/module methods will
-   *                    be stored.
-   */
+  // Adds common/required properties to a module or class object
+  // (as in `Module.new` / `Class.new`)
+  //
+  // @param module      The module or class that needs to be prepared
+  //
+  // @param constructor The constructor of the module or class itself,
+  //                    usually it's already assigned by using `new`. Some
+  //                    ipothesis on why it's needed can be found below.
+  //
+  // @param superklass  The superclass of the class/module object, for modules
+  //                    is `Module` (of `Module` in JS context)
+  //
+  // @param prototype   The prototype on which the class/module methods will
+  //                    be stored.
+  //
   function setup_module_or_class_object(module, constructor, superklass, prototype) {
     // @property $$id Each class is assigned a unique `id` that helps
     //                comparation and implementation of `#object_id`
@@ -265,15 +303,15 @@
     //                       Maybe there are some browsers not abiding (IE6?)
     module.constructor = constructor;
 
-    if (superklass === ModuleClass) {
+    if (superklass === Module) {
       // @property $$is_module Clearly mark this as a module
       module.$$is_module = true;
-      module.$$class     = ModuleClass;
+      module.$$class     = Module;
     }
     else {
       // @property $$is_class Clearly mark this as a class
       module.$$is_class = true;
-      module.$$class    = ClassClass;
+      module.$$class    = Class;
     }
 
     // @property $$super the superclass, doesn't get changed by module inclusions
@@ -288,26 +326,25 @@
     module.$$inc = [];
   }
 
-  /**
-    Define new module (or return existing module). The given `base` is basically
-    the current `self` value the `module` statement was defined in. If this is
-    a ruby module or class, then it is used, otherwise if the base is a ruby
-    object then that objects real ruby class is used (e.g. if the base is the
-    main object, then the top level `Object` class is used as the base).
-
-    If a module of the given name is already defined in the base, then that
-    instance is just returned.
-
-    If there is a class of the given name in the base, then an error is
-    generated instead (cannot have a class and module of same name in same base).
-
-    Otherwise, a new module is created in the base with the given name, and that
-    new instance is returned back (to be referenced at runtime).
-
-    @param [RubyModule or Class] base class or module this definition is inside
-    @param [String] id the name of the new (or existing) module
-    @returns [RubyModule]
-  */
+  // Define new module (or return existing module). The given `base` is basically
+  // the current `self` value the `module` statement was defined in. If this is
+  // a ruby module or class, then it is used, otherwise if the base is a ruby
+  // object then that objects real ruby class is used (e.g. if the base is the
+  // main object, then the top level `Object` class is used as the base).
+  //
+  // If a module of the given name is already defined in the base, then that
+  // instance is just returned.
+  //
+  // If there is a class of the given name in the base, then an error is
+  // generated instead (cannot have a class and module of same name in same base).
+  //
+  // Otherwise, a new module is created in the base with the given name, and that
+  // new instance is returned back (to be referenced at runtime).
+  //
+  // @param [RubyModule or Class] base class or module this definition is inside
+  // @param [String] id the name of the new (or existing) module
+  // @return [RubyModule]
+  //
   Opal.module = function(base, id) {
     var module;
 
@@ -318,7 +355,7 @@
     if ($hasOwn.call(base.$$scope, id)) {
       module = base.$$scope[id];
 
-      if (!module.$$is_module && module !== ObjectClass) {
+      if (!module.$$is_module && module !== _Object) {
         throw Opal.TypeError.$new(id + " is not a module");
       }
     }
@@ -334,7 +371,7 @@
       // initialize dependency tracking
       module.$$dep = [];
 
-      create_scope(base.$$scope, module, id);
+      Opal.create_scope(base.$$scope, module, id);
 
       // Name new module directly onto current scope (Opal.Foo.Baz = module)
       base[id] = base.$$scope[id] = module;
@@ -343,13 +380,12 @@
     return module;
   };
 
-  /*
-   * Internal function to create a new module instance. This simply sets up
-   * the prototype hierarchy and method tables.
-   */
+  // Internal function to create a new module instance. This simply sets up
+  // the prototype hierarchy and method tables.
+  //
   function boot_module_object() {
     var mtor = function() {};
-    mtor.prototype = ModuleClass.constructor.prototype;
+    mtor.prototype = Module_alloc.prototype;
 
     function module_constructor() {}
     module_constructor.prototype = new mtor();
@@ -357,24 +393,26 @@
     var module = new module_constructor();
     var module_prototype = {};
 
-    setup_module_or_class_object(module, module_constructor, ModuleClass, module_prototype);
+    setup_module_or_class_object(module, module_constructor, Module, module_prototype);
 
     return module;
   }
 
-  /**
-    Return the singleton class for the passed object.
-
-    If the given object alredy has a singleton class, then it will be stored on
-    the object as the `$$meta` property. If this exists, then it is simply
-    returned back.
-
-    Otherwise, a new singleton object for the class or object is created, set on
-    the object at `$$meta` for future use, and then returned.
-
-    @param [RubyObject] object the ruby object
-    @returns [RubyClass] the singleton class for object
-  */
+  // Make `boot_module_object` available to the JS-API
+  Opal.boot_module_object = boot_module_object;
+
+  // Return the singleton class for the passed object.
+  //
+  // If the given object alredy has a singleton class, then it will be stored on
+  // the object as the `$$meta` property. If this exists, then it is simply
+  // returned back.
+  //
+  // Otherwise, a new singleton object for the class or object is created, set on
+  // the object at `$$meta` for future use, and then returned.
+  //
+  // @param [RubyObject] object the ruby object
+  // @return [RubyClass] the singleton class for object
+  //
   Opal.get_singleton_class = function(object) {
     if (object.$$meta) {
       return object.$$meta;
@@ -387,15 +425,14 @@
     return build_object_singleton_class(object);
   };
 
-  /**
-    Build the singleton class for an existing class.
-
-    NOTE: Actually in MRI a class' singleton class inherits from its
-    superclass' singleton class which in turn inherits from Class.
-
-    @param [RubyClass] klass
-    @returns [RubyClass]
-   */
+  // Build the singleton class for an existing class.
+  //
+  // NOTE: Actually in MRI a class' singleton class inherits from its
+  // superclass' singleton class which in turn inherits from Class.
+  //
+  // @param [RubyClass] klass
+  // @return [RubyClass]
+  //
   function build_class_singleton_class(klass) {
     var meta = new Opal.Class.$$alloc();
 
@@ -410,18 +447,17 @@
     return klass.$$meta = meta;
   }
 
-  /**
-    Build the singleton class for a Ruby (non class) Object.
-
-    @param [RubyObject] object
-    @returns [RubyClass]
-   */
+  // Build the singleton class for a Ruby (non class) Object.
+  //
+  // @param [RubyObject] object
+  // @return [RubyClass]
+  //
   function build_object_singleton_class(object) {
     var orig_class = object.$$class,
         class_id   = "#<Class:#<" + orig_class.$$name + ":" + orig_class.$$id + ">>";
 
-    var Singleton = function () {};
-    var meta = Opal.boot(orig_class, Singleton);
+    var Singleton = function() {};
+    var meta = Opal.boot_class(orig_class, Singleton);
     meta.$$name   = class_id;
 
     meta.$$proto  = object;
@@ -434,109 +470,85 @@
     return object.$$meta = meta;
   }
 
-  /**
-    The actual inclusion of a module into a class.
-
-    ## Class `$$parent` and `iclass`
-
-    To handle `super` calls, every class has a `$$parent`. This parent is
-    used to resolve the next class for a super call. A normal class would
-    have this point to its superclass. However, if a class includes a module
-    then this would need to take into account the module. The module would
-    also have to then point its `$$parent` to the actual superclass. We
-    cannot modify modules like this, because it might be included in more
-    then one class. To fix this, we actually insert an `iclass` as the class'
-    `$$parent` which can then point to the superclass. The `iclass` acts as
-    a proxy to the actual module, so the `super` chain can then search it for
-    the required method.
-
-    @param [RubyModule] module the module to include
-    @param [RubyClass] klass the target class to include module into
-    @returns [null]
-  */
-  function bridge() {
-    var target, donator, from, name, body, ancestors, id, methods, method, i, ancestor, bridged, length;
-
-    if (arguments.length === 4) {
-      target    = arguments[0];
-      from      = arguments[1];
-      name      = arguments[2];
-      body      = arguments[3];
-      ancestors = target.$$bridge.$ancestors();
-
-      // order important here, we have to check for method presence in
-      // ancestors from the bridged class to the last ancestor
-      for (i = 0, length = ancestors.length; i < length; i++) {
-        ancestor = ancestors[i];
-
-        if ($hasOwn.call(ancestor.$$proto, name) &&
-            ancestor.$$proto[name] &&
-            !ancestor.$$proto[name].$$donated &&
-            !ancestor.$$proto[name].$$stub &&
-            ancestor !== from) {
-          break;
-        }
+  // Bridges a single method.
+  function bridge_method(target, from, name, body) {
+    var ancestors, i, ancestor, length;
 
-        if (ancestor === from) {
-          target.prototype[name] = body
-          break;
-        }
+    ancestors = target.$$bridge.$ancestors();
+
+    // order important here, we have to check for method presence in
+    // ancestors from the bridged class to the last ancestor
+    for (i = 0, length = ancestors.length; i < length; i++) {
+      ancestor = ancestors[i];
+
+      if ($hasOwn.call(ancestor.$$proto, name) &&
+          ancestor.$$proto[name] &&
+          !ancestor.$$proto[name].$$donated &&
+          !ancestor.$$proto[name].$$stub &&
+          ancestor !== from) {
+        break;
+      }
+
+      if (ancestor === from) {
+        target.prototype[name] = body
+        break;
       }
     }
-    else {
-      target  = arguments[0];
-      donator = arguments[1];
 
-      if (typeof(target) === "function") {
-        id      = donator.$__id__();
-        methods = donator.$instance_methods();
+  }
 
-        for (i = methods.length - 1; i >= 0; i--) {
-          method = '$' + methods[i];
+  // Bridges from *donator* to a *target*.
+  function _bridge(target, donator) {
+    var id, methods, method, i, bridged;
 
-          bridge(target, donator, method, donator.$$proto[method]);
-        }
+    if (typeof(target) === "function") {
+      id      = donator.$__id__();
+      methods = donator.$instance_methods();
 
-        if (!bridges[id]) {
-          bridges[id] = [];
-        }
+      for (i = methods.length - 1; i >= 0; i--) {
+        method = '$' + methods[i];
 
-        bridges[id].push(target);
+        bridge_method(target, donator, method, donator.$$proto[method]);
       }
-      else {
-        bridged = bridges[target.$__id__()];
 
-        if (bridged) {
-          for (i = bridged.length - 1; i >= 0; i--) {
-            bridge(bridged[i], donator);
-          }
+      if (!bridges[id]) {
+        bridges[id] = [];
+      }
 
-          bridges[donator.$__id__()] = bridged.slice();
+      bridges[id].push(target);
+    }
+    else {
+      bridged = bridges[target.$__id__()];
+
+      if (bridged) {
+        for (i = bridged.length - 1; i >= 0; i--) {
+          _bridge(bridged[i], donator);
         }
+
+        bridges[donator.$__id__()] = bridged.slice();
       }
     }
   }
 
-  /**
-    The actual inclusion of a module into a class.
-
-    ## Class `$$parent` and `iclass`
-
-    To handle `super` calls, every class has a `$$parent`. This parent is
-    used to resolve the next class for a super call. A normal class would
-    have this point to its superclass. However, if a class includes a module
-    then this would need to take into account the module. The module would
-    also have to then point its `$$parent` to the actual superclass. We
-    cannot modify modules like this, because it might be included in more
-    then one class. To fix this, we actually insert an `iclass` as the class'
-    `$$parent` which can then point to the superclass. The `iclass` acts as
-    a proxy to the actual module, so the `super` chain can then search it for
-    the required method.
-
-    @param [RubyModule] module the module to include
-    @param [RubyClass] klass the target class to include module into
-    @returns [null]
-  */
+  // The actual inclusion of a module into a class.
+  //
+  // ## Class `$$parent` and `iclass`
+  //
+  // To handle `super` calls, every class has a `$$parent`. This parent is
+  // used to resolve the next class for a super call. A normal class would
+  // have this point to its superclass. However, if a class includes a module
+  // then this would need to take into account the module. The module would
+  // also have to then point its `$$parent` to the actual superclass. We
+  // cannot modify modules like this, because it might be included in more
+  // then one class. To fix this, we actually insert an `iclass` as the class'
+  // `$$parent` which can then point to the superclass. The `iclass` acts as
+  // a proxy to the actual module, so the `super` chain can then search it for
+  // the required method.
+  //
+  // @param [RubyModule] module the module to include
+  // @param [RubyClass] klass the target class to include module into
+  // @return [null]
+  //
   Opal.append_features = function(module, klass) {
     var iclass, donator, prototype, methods, id, i;
 
@@ -549,7 +561,7 @@
 
     klass.$$inc.push(module);
     module.$$dep.push(klass);
-    bridge(klass, module);
+    _bridge(klass, module);
 
     // iclass
     iclass = {
@@ -588,14 +600,13 @@
   // Boot a base class (makes instances).
   function boot_class_alloc(id, constructor, superklass) {
     if (superklass) {
-      var ctor = function() {};
-          ctor.prototype   = superklass.$$proto || superklass.prototype;
-
-      if (id) {
-        ctor.displayName = id;
-      }
+      var alloc_proxy = function() {};
+      alloc_proxy.prototype  = superklass.$$proto || superklass.prototype;
+      constructor.prototype = new alloc_proxy();
+    }
 
-      constructor.prototype = new ctor();
+    if (id) {
+      constructor.displayName = id+'_alloc';
     }
 
     constructor.prototype.constructor = constructor;
@@ -603,15 +614,14 @@
     return constructor;
   }
 
-  /*
-   * Builds the class object for core classes:
-   * - make the class object have a singleton class
-   * - make the singleton class inherit from its parent singleton class
-   *
-   * @param id         [String]      the name of the class
-   * @param alloc      [Function]    the constructor for the core class instances
-   * @param superclass [Class alloc] the constructor of the superclass
-   */
+  // Builds the class object for core classes:
+  // - make the class object have a singleton class
+  // - make the singleton class inherit from its parent singleton class
+  //
+  // @param id         [String]      the name of the class
+  // @param alloc      [Function]    the constructor for the core class instances
+  // @param superclass [Class alloc] the constructor of the superclass
+  //
   function boot_core_class_object(id, alloc, superclass) {
     var superclass_constructor = function() {};
         superclass_constructor.prototype = superclass.prototype;
@@ -626,8 +636,9 @@
 
     setup_module_or_class_object(klass, singleton_class, superclass, alloc.prototype);
 
-    klass.$$alloc = alloc;
-    klass.$$name  = id;
+    klass.$$alloc     = alloc;
+    klass.$$name      = id;
+    klass.displayName = id;
 
     // Give all instances a ref to their class
     alloc.prototype.$$class = klass;
@@ -638,24 +649,23 @@
     return klass;
   }
 
-  /*
-   * For performance, some core Ruby classes are toll-free bridged to their
-   * native JavaScript counterparts (e.g. a Ruby Array is a JavaScript Array).
-   *
-   * This method is used to setup a native constructor (e.g. Array), to have
-   * its prototype act like a normal Ruby class. Firstly, a new Ruby class is
-   * created using the native constructor so that its prototype is set as the
-   * target for th new class. Note: all bridged classes are set to inherit
-   * from Object.
-   *
-   * Example:
-   *
-   *    Opal.bridge(self, Function);
-   *
-   * @param [Class] klass the Ruby class to bridge
-   * @param [Function] constructor native JavaScript constructor to use
-   * @return [Class] returns the passed Ruby class
-   */
+  // For performance, some core Ruby classes are toll-free bridged to their
+  // native JavaScript counterparts (e.g. a Ruby Array is a JavaScript Array).
+  //
+  // This method is used to setup a native constructor (e.g. Array), to have
+  // its prototype act like a normal Ruby class. Firstly, a new Ruby class is
+  // created using the native constructor so that its prototype is set as the
+  // target for th new class. Note: all bridged classes are set to inherit
+  // from Object.
+  //
+  // Example:
+  //
+  //    Opal.bridge(self, Function);
+  //
+  // @param [Class] klass the Ruby class to bridge
+  // @param [Function] constructor native JavaScript constructor to use
+  // @return [Class] returns the passed Ruby class
+  //
   Opal.bridge = function(klass, constructor) {
     if (constructor.$$bridge) {
       throw Opal.ArgumentError.$new("already bridged");
@@ -671,11 +681,11 @@
     // order important here, we have to bridge from the last ancestor to the
     // bridged class
     for (var i = ancestors.length - 1; i >= 0; i--) {
-      bridge(constructor, ancestors[i]);
+      _bridge(constructor, ancestors[i]);
     }
 
-    for (var name in BasicObject.prototype) {
-      var method = BasicObject.prototype[method];
+    for (var name in BasicObject_alloc.prototype) {
+      var method = BasicObject_alloc.prototype[method];
 
       if (method && method.$$stub && !(name in constructor.prototype)) {
         constructor.prototype[name] = method;
@@ -686,9 +696,8 @@
   }
 
 
-  /*
-   * constant assign
-   */
+  // constant assign
+  //
   Opal.casgn = function(base_module, name, value) {
     function update(klass, name) {
       klass.$$name = name;
@@ -705,8 +714,8 @@
     var scope = base_module.$$scope;
 
     if (value.$$is_class || value.$$is_module) {
-      // only checking ObjectClass prevents setting a const on an anonymous class that has a superclass that's not Object
-      if (value.$$is_class || value.$$base_module === ObjectClass) {
+      // only checking _Object prevents setting a const on an anonymous class that has a superclass that's not Object
+      if (value.$$is_class || value.$$base_module === _Object) {
         value.$$base_module = base_module;
       }
 
@@ -719,9 +728,7 @@
     return scope[name] = value;
   };
 
-  /*
-   * constant decl
-   */
+  // constant decl
   Opal.cdecl = function(base_scope, name, value) {
     if ((value.$$is_class || value.$$is_module) && value.$$orig_scope == null) {
       value.$$name = name;
@@ -733,10 +740,9 @@
     return base_scope[name] = value;
   };
 
-  /*
-   * When a source module is included into the target module, we must also copy
-   * its constants to the target.
-   */
+  // When a source module is included into the target module, we must also copy
+  // its constants to the target.
+  //
   function donate_constants(source_mod, target_mod) {
     var source_constants = source_mod.$$scope.constants,
         target_scope     = target_mod.$$scope,
@@ -748,9 +754,7 @@
     }
   };
 
-  /*
-   * Donate methods for a module.
-   */
+  // Donate methods for a module.
   function donate(module, jsid) {
     var included_in = module.$$dep,
         body = module.$$proto[jsid],
@@ -802,34 +806,33 @@
     }
   };
 
-  /*
-   * Methods stubs are used to facilitate method_missing in opal. A stub is a
-   * placeholder function which just calls `method_missing` on the receiver.
-   * If no method with the given name is actually defined on an object, then it
-   * is obvious to say that the stub will be called instead, and then in turn
-   * method_missing will be called.
-   *
-   * When a file in ruby gets compiled to javascript, it includes a call to
-   * this function which adds stubs for every method name in the compiled file.
-   * It should then be safe to assume that method_missing will work for any
-   * method call detected.
-   *
-   * Method stubs are added to the BasicObject prototype, which every other
-   * ruby object inherits, so all objects should handle method missing. A stub
-   * is only added if the given property name (method name) is not already
-   * defined.
-   *
-   * Note: all ruby methods have a `$` prefix in javascript, so all stubs will
-   * have this prefix as well (to make this method more performant).
-   *
-   *    Opal.add_stubs(["$foo", "$bar", "$baz="]);
-   *
-   * All stub functions will have a private `$$stub` property set to true so
-   * that other internal methods can detect if a method is just a stub or not.
-   * `Kernel#respond_to?` uses this property to detect a methods presence.
-   *
-   * @param [Array] stubs an array of method stubs to add
-   */
+  // Methods stubs are used to facilitate method_missing in opal. A stub is a
+  // placeholder function which just calls `method_missing` on the receiver.
+  // If no method with the given name is actually defined on an object, then it
+  // is obvious to say that the stub will be called instead, and then in turn
+  // method_missing will be called.
+  //
+  // When a file in ruby gets compiled to javascript, it includes a call to
+  // this function which adds stubs for every method name in the compiled file.
+  // It should then be safe to assume that method_missing will work for any
+  // method call detected.
+  //
+  // Method stubs are added to the BasicObject prototype, which every other
+  // ruby object inherits, so all objects should handle method missing. A stub
+  // is only added if the given property name (method name) is not already
+  // defined.
+  //
+  // Note: all ruby methods have a `$` prefix in javascript, so all stubs will
+  // have this prefix as well (to make this method more performant).
+  //
+  //    Opal.add_stubs(["$foo", "$bar", "$baz="]);
+  //
+  // All stub functions will have a private `$$stub` property set to true so
+  // that other internal methods can detect if a method is just a stub or not.
+  // `Kernel#respond_to?` uses this property to detect a methods presence.
+  //
+  // @param [Array] stubs an array of method stubs to add
+  //
   Opal.add_stubs = function(stubs) {
     var subscriber, subscribers = Opal.stub_subscribers,
         i, ilength = stubs.length,
@@ -850,30 +853,27 @@
     }
   };
 
-  /*
-   * Keep a list of prototypes that want method_missing stubs to be added.
-   *
-   * @default [Prototype List] BasicObject.prototype
-   */
-  Opal.stub_subscribers = [BasicObject.prototype];
-
-  /*
-   * Add a method_missing stub function to the given prototype for the
-   * given name.
-   *
-   * @param [Prototype] prototype the target prototype
-   * @param [String] stub stub name to add (e.g. "$foo")
-   */
-  function add_stub_for(prototype, stub) {
+  // Keep a list of prototypes that want method_missing stubs to be added.
+  //
+  // @default [Prototype List] BasicObject_alloc.prototype
+  //
+  Opal.stub_subscribers = [BasicObject_alloc.prototype];
+
+  // Add a method_missing stub function to the given prototype for the
+  // given name.
+  //
+  // @param [Prototype] prototype the target prototype
+  // @param [String] stub stub name to add (e.g. "$foo")
+  //
+  Opal.add_stub_for = function(prototype, stub) {
     var method_missing_stub = stub_for(stub);
     prototype[stub] = method_missing_stub;
   }
 
-  /*
-   * Generate the method_missing stub for a given method name.
-   *
-   * @param [String] method_name The js-name of the method to stub (e.g. "$foo")
-   */
+  // Generate the method_missing stub for a given method name.
+  //
+  // @param [String] method_name The js-name of the method to stub (e.g. "$foo")
+  //
   function stub_for(method_name) {
     function method_missing_stub() {
       // Copy any given block onto the method_missing dispatcher
@@ -891,9 +891,6 @@
     return method_missing_stub;
   }
 
-  // Expose for other parts of Opal to use
-  Opal.add_stub_for = add_stub_for;
-
   // Arity count error dispatcher
   Opal.ac = function(actual, expected, object, meth) {
     var inspect = '';
@@ -908,6 +905,23 @@
     throw Opal.ArgumentError.$new('[' + inspect + '] wrong number of arguments(' + actual + ' for ' + expected + ')');
   };
 
+  // The Array of ancestors for a given module/class
+  Opal.ancestors = function(module_or_class) {
+    var parent = module_or_class,
+        result = [];
+
+    while (parent) {
+      result.push(parent);
+      for (var i=0; i < parent.$$inc.length; i++) {
+        result = result.concat(Opal.ancestors(parent.$$inc[i]));
+      }
+
+      parent = parent.$$is_class ? parent.$$super : null;
+    }
+
+    return result;
+  }
+
   // Super dispatcher
   Opal.find_super_dispatcher = function(obj, jsid, current_func, iter, defs) {
     var dispatcher;
@@ -980,14 +994,13 @@
     return klass.$$proto;
   };
 
-  /*
-   * Used to return as an expression. Sometimes, we can't simply return from
-   * a javascript function as if we were a method, as the return is used as
-   * an expression, or even inside a block which must "return" to the outer
-   * method. This helper simply throws an error which is then caught by the
-   * method. This approach is expensive, so it is only used when absolutely
-   * needed.
-   */
+  // Used to return as an expression. Sometimes, we can't simply return from
+  // a javascript function as if we were a method, as the return is used as
+  // an expression, or even inside a block which must "return" to the outer
+  // method. This helper simply throws an error which is then caught by the
+  // method. This approach is expensive, so it is only used when absolutely
+  // needed.
+  //
   Opal.ret = function(val) {
     Opal.returner.$v = val;
     throw Opal.returner;
@@ -1071,13 +1084,28 @@
     return false;
   };
 
-  // Helper to convert the given object to an array
+  // Helpers for implementing multiple assignment
+  // Our code for extracting the values and assigning them only works if the
+  // return value is a JS array
+  // So if we get an Array subclass, extract the wrapped JS array from it
+
   Opal.to_ary = function(value) {
+    // Used for: a, b = something (no splat)
     if (value.$$is_array) {
-      return value;
+      return (value.constructor === Array) ? value : value.literal;
     }
-    else if (value.$to_ary && !value.$to_ary.$$stub) {
-      return value.$to_ary();
+    else if (value['$respond_to?']('to_ary', true)) {
+      var ary = value.$to_ary();
+      if (ary === nil) {
+        return [value];
+      }
+      else if (ary.$$is_array) {
+        return (ary.constructor === Array) ? ary : ary.literal;
+      }
+      else {
+        throw Opal.TypeError.$new("Can't convert " + value.$$class +
+          " to Array (" + value.$$class + "#to_ary gives " + ary.$$class + ")");
+      }
     }
     else {
       return [value];
@@ -1085,34 +1113,45 @@
   };
 
   Opal.to_a = function(value) {
-    if (value == null || value === nil) {
-      return [];
+    // Used for: a, b = *something (with splat)
+    if (value.$$is_array) {
+      // A splatted array must be copied
+      return (value.constructor === Array) ? value.slice() : value.literal.slice();
     }
-    else if (value.$to_a && !value.$to_a.$$stub) {
-      return value.$to_a();
+    else if (value['$respond_to?']('to_a', true)) {
+      var ary = value.$to_a();
+      if (ary === nil) {
+        return [value];
+      }
+      else if (ary.$$is_array) {
+        return (ary.constructor === Array) ? ary : ary.literal;
+      }
+      else {
+        throw Opal.TypeError.$new("Can't convert " + value.$$class +
+          " to Array (" + value.$$class + "#to_a gives " + ary.$$class + ")");
+      }
     }
     else {
       return [value];
     }
   };
 
-  /**
-    Used to get a list of rest keyword arguments. Method takes the given
-    keyword args, i.e. the hash literal passed to the method containing all
-    keyword arguemnts passed to method, as well as the used args which are
-    the names of required and optional arguments defined. This method then
-    just returns all key/value pairs which have not been used, in a new
-    hash literal.
-
-    @param given_args [Hash] all kwargs given to method
-    @param used_args [Object<String: true>] all keys used as named kwargs
-    @return [Hash]
-   */
+  // Used to get a list of rest keyword arguments. Method takes the given
+  // keyword args, i.e. the hash literal passed to the method containing all
+  // keyword arguemnts passed to method, as well as the used args which are
+  // the names of required and optional arguments defined. This method then
+  // just returns all key/value pairs which have not been used, in a new
+  // hash literal.
+  //
+  // @param given_args [Hash] all kwargs given to method
+  // @param used_args [Object<String: true>] all keys used as named kwargs
+  // @return [Hash]
+  //
   Opal.kwrestargs = function(given_args, used_args) {
     var keys      = [],
         map       = {},
         key       = null,
-        given_map = given_args.smap;
+        given_map = given_args.$$smap;
 
     for (key in given_map) {
       if (!used_args[key]) {
@@ -1124,21 +1163,20 @@
     return Opal.hash2(keys, map);
   };
 
-  /*
-   * Call a ruby method on a ruby object with some arguments:
-   *
-   *   var my_array = [1, 2, 3, 4]
-   *   Opal.send(my_array, 'length')     # => 4
-   *   Opal.send(my_array, 'reverse!')   # => [4, 3, 2, 1]
-   *
-   * A missing method will be forwarded to the object via
-   * method_missing.
-   *
-   * The result of either call with be returned.
-   *
-   * @param [Object] recv the ruby object
-   * @param [String] mid ruby method to call
-   */
+  // Call a ruby method on a ruby object with some arguments:
+  //
+  //   var my_array = [1, 2, 3, 4]
+  //   Opal.send(my_array, 'length')     # => 4
+  //   Opal.send(my_array, 'reverse!')   # => [4, 3, 2, 1]
+  //
+  // A missing method will be forwarded to the object via
+  // method_missing.
+  //
+  // The result of either call with be returned.
+  //
+  // @param [Object] recv the ruby object
+  // @param [String] mid ruby method to call
+  //
   Opal.send = function(recv, mid) {
     var args = $slice.call(arguments, 2),
         func = recv['$' + mid];
@@ -1162,43 +1200,42 @@
     return recv.$method_missing.apply(recv, [mid].concat(args));
   };
 
-  /**
-    Used to define methods on an object. This is a helper method, used by the
-    compiled source to define methods on special case objects when the compiler
-    can not determine the destination object, or the object is a Module
-    instance. This can get called by `Module#define_method` as well.
-
-    ## Modules
-
-    Any method defined on a module will come through this runtime helper.
-    The method is added to the module body, and the owner of the method is
-    set to be the module itself. This is used later when choosing which
-    method should show on a class if more than 1 included modules define
-    the same method. Finally, if the module is in `module_function` mode,
-    then the method is also defined onto the module itself.
-
-    ## Classes
-
-    This helper will only be called for classes when a method is being
-    defined indirectly; either through `Module#define_method`, or by a
-    literal `def` method inside an `instance_eval` or `class_eval` body. In
-    either case, the method is simply added to the class' prototype. A special
-    exception exists for `BasicObject` and `Object`. These two classes are
-    special because they are used in toll-free bridged classes. In each of
-    these two cases, extra work is required to define the methods on toll-free
-    bridged class' prototypes as well.
-
-    ## Objects
-
-    If a simple ruby object is the object, then the method is simply just
-    defined on the object as a singleton method. This would be the case when
-    a method is defined inside an `instance_eval` block.
-
-    @param [RubyObject or Class] obj the actual obj to define method for
-    @param [String] jsid the javascript friendly method name (e.g. '$foo')
-    @param [Function] body the literal javascript function used as method
-    @returns [null]
-  */
+  // Used to define methods on an object. This is a helper method, used by the
+  // compiled source to define methods on special case objects when the compiler
+  // can not determine the destination object, or the object is a Module
+  // instance. This can get called by `Module#define_method` as well.
+  //
+  // ## Modules
+  //
+  // Any method defined on a module will come through this runtime helper.
+  // The method is added to the module body, and the owner of the method is
+  // set to be the module itself. This is used later when choosing which
+  // method should show on a class if more than 1 included modules define
+  // the same method. Finally, if the module is in `module_function` mode,
+  // then the method is also defined onto the module itself.
+  //
+  // ## Classes
+  //
+  // This helper will only be called for classes when a method is being
+  // defined indirectly; either through `Module#define_method`, or by a
+  // literal `def` method inside an `instance_eval` or `class_eval` body. In
+  // either case, the method is simply added to the class' prototype. A special
+  // exception exists for `BasicObject` and `Object`. These two classes are
+  // special because they are used in toll-free bridged classes. In each of
+  // these two cases, extra work is required to define the methods on toll-free
+  // bridged class' prototypes as well.
+  //
+  // ## Objects
+  //
+  // If a simple ruby object is the object, then the method is simply just
+  // defined on the object as a singleton method. This would be the case when
+  // a method is defined inside an `instance_eval` block.
+  //
+  // @param [RubyObject or Class] obj the actual obj to define method for
+  // @param [String] jsid the javascript friendly method name (e.g. '$foo')
+  // @param [Function] body the literal javascript function used as method
+  // @return [null]
+  //
   Opal.defn = function(obj, jsid, body) {
     obj.$$proto[jsid] = body;
 
@@ -1215,7 +1252,7 @@
 
       if (bridged) {
         for (var i = bridged.length - 1; i >= 0; i--) {
-          bridge(bridged[i], obj, jsid, body);
+          bridge_method(bridged[i], obj, jsid, body);
         }
       }
     }
@@ -1232,9 +1269,8 @@
     return nil;
   };
 
-  /*
-   * Define a singleton method on the given object.
-   */
+
+  // Define a singleton method on the given object.
   Opal.defs = function(obj, jsid, body) {
     Opal.defn(Opal.get_singleton_class(obj), jsid, body)
   };
@@ -1249,9 +1285,7 @@
     }
   };
 
-  /*
-   * Called from #remove_method.
-   */
+  // Called from #remove_method.
   Opal.rdef = function(obj, jsid) {
     // TODO: remove from bridges as well
 
@@ -1273,9 +1307,7 @@
     }
   };
 
-  /*
-   * Called from #undef_method.
-   */
+  // Called from #undef_method.
   Opal.udef = function(obj, jsid) {
     if (!obj.$$proto[jsid] || obj.$$proto[jsid].$$stub) {
       throw Opal.NameError.$new("method '" + jsid.substr(1) + "' not defined in " + obj.$name());
@@ -1295,33 +1327,11 @@
     }
   };
 
-  // This black magic is required to avoid clashes of internal special fields,
-  // like $$donated.
-  function wrap(body) {
-    function alias() {
-      body.$$p = alias.$$p;
-      body.$$s = alias.$$s;
-
-      try {
-        return body.apply(this, $slice.call(arguments));
-      }
-      finally {
-        alias.$$s = null;
-        alias.$$p = null;
-      }
-    }
-
-    alias.$$target = body;
-    alias.$$arity  = body.length;
-
-    return alias;
-  }
-
   Opal.alias = function(obj, name, old) {
     var id     = '$' + name,
         old_id = '$' + old,
         body   = obj.$$proto['$' + old];
-    
+
     // instance_eval is being run on a class/module, so that need to alias class methods
     if (obj.$$eval) {
       return Opal.alias(Opal.get_singleton_class(obj), name, old);
@@ -1340,7 +1350,7 @@
       }
     }
 
-    Opal.defn(obj, id, wrap(body));
+    Opal.defn(obj, id, body);
 
     return obj;
   };
@@ -1353,26 +1363,26 @@
       throw Opal.NameError.$new("undefined native method `" + native_name + "' for class `" + obj.$name() + "'")
     }
 
-    Opal.defn(obj, id, wrap(body));
+    Opal.defn(obj, id, body);
 
     return obj;
   };
 
-  Opal.hash_init = function (hash) {
-    hash.map  = {};
-    hash.smap = {};
-    hash.keys = [];
+  Opal.hash_init = function(hash) {
+    hash.$$map  = {};
+    hash.$$smap = {};
+    hash.$$keys = [];
   };
 
-  Opal.hash_clone = function (from_hash, to_hash) {
+  Opal.hash_clone = function(from_hash, to_hash) {
     to_hash.none = from_hash.none;
     to_hash.proc = from_hash.proc;
 
-    for (var i = 0, keys = from_hash.keys, length = keys.length, key, value; i < length; i++) {
-      key = from_hash.keys[i];
+    for (var i = 0, keys = from_hash.$$keys, length = keys.length, key, value; i < length; i++) {
+      key = from_hash.$$keys[i];
 
       if (key.$$is_string) {
-        value = from_hash.smap[key];
+        value = from_hash.$$smap[key];
       } else {
         value = key.value;
         key = key.key;
@@ -1382,25 +1392,25 @@
     }
   };
 
-  Opal.hash_put = function (hash, key, value) {
+  Opal.hash_put = function(hash, key, value) {
     if (key.$$is_string) {
-      if (!hash.smap.hasOwnProperty(key)) {
-        hash.keys.push(key);
+      if (!hash.$$smap.hasOwnProperty(key)) {
+        hash.$$keys.push(key);
       }
-      hash.smap[key] = value;
+      hash.$$smap[key] = value;
       return;
     }
 
     var key_hash = key.$hash(), bucket, last_bucket;
 
-    if (!hash.map.hasOwnProperty(key_hash)) {
+    if (!hash.$$map.hasOwnProperty(key_hash)) {
       bucket = {key: key, key_hash: key_hash, value: value};
-      hash.keys.push(bucket);
-      hash.map[key_hash] = bucket;
+      hash.$$keys.push(bucket);
+      hash.$$map[key_hash] = bucket;
       return;
     }
 
-    bucket = hash.map[key_hash];
+    bucket = hash.$$map[key_hash];
 
     while (bucket) {
       if (key === bucket.key || key['$eql?'](bucket.key)) {
@@ -1414,23 +1424,23 @@
 
     if (last_bucket) {
       bucket = {key: key, key_hash: key_hash, value: value};
-      hash.keys.push(bucket);
+      hash.$$keys.push(bucket);
       last_bucket.next = bucket;
     }
   };
 
-  Opal.hash_get = function (hash, key) {
+  Opal.hash_get = function(hash, key) {
     if (key.$$is_string) {
-      if (hash.smap.hasOwnProperty(key)) {
-        return hash.smap[key];
+      if (hash.$$smap.hasOwnProperty(key)) {
+        return hash.$$smap[key];
       }
       return;
     }
 
     var key_hash = key.$hash(), bucket;
 
-    if (hash.map.hasOwnProperty(key_hash)) {
-      bucket = hash.map[key_hash];
+    if (hash.$$map.hasOwnProperty(key_hash)) {
+      bucket = hash.$$map[key_hash];
 
       while (bucket) {
         if (key === bucket.key || key['$eql?'](bucket.key)) {
@@ -1441,11 +1451,11 @@
     }
   };
 
-  Opal.hash_delete = function (hash, key) {
-    var i, keys = hash.keys, length = keys.length, value;
+  Opal.hash_delete = function(hash, key) {
+    var i, keys = hash.$$keys, length = keys.length, value;
 
     if (key.$$is_string) {
-      if (!hash.smap.hasOwnProperty(key)) {
+      if (!hash.$$smap.hasOwnProperty(key)) {
         return;
       }
 
@@ -1456,18 +1466,18 @@
         }
       }
 
-      value = hash.smap[key];
-      delete hash.smap[key];
+      value = hash.$$smap[key];
+      delete hash.$$smap[key];
       return value;
     }
 
     var key_hash = key.$hash();
 
-    if (!hash.map.hasOwnProperty(key_hash)) {
+    if (!hash.$$map.hasOwnProperty(key_hash)) {
       return;
     }
 
-    var bucket = hash.map[key_hash], last_bucket;
+    var bucket = hash.$$map[key_hash], last_bucket;
 
     while (bucket) {
       if (key === bucket.key || key['$eql?'](bucket.key)) {
@@ -1487,10 +1497,10 @@
           delete last_bucket.next;
         }
         else if (bucket.next) {
-          hash.map[key_hash] = bucket.next;
+          hash.$$map[key_hash] = bucket.next;
         }
         else {
-          delete hash.map[key_hash];
+          delete hash.$$map[key_hash];
         }
 
         return value;
@@ -1500,24 +1510,24 @@
     }
   };
 
-  Opal.hash_rehash = function (hash) {
-    for (var i = 0, length = hash.keys.length, key_hash, bucket, last_bucket; i < length; i++) {
+  Opal.hash_rehash = function(hash) {
+    for (var i = 0, length = hash.$$keys.length, key_hash, bucket, last_bucket; i < length; i++) {
 
-      if (hash.keys[i].$$is_string) {
+      if (hash.$$keys[i].$$is_string) {
         continue;
       }
 
-      key_hash = hash.keys[i].key.$hash();
+      key_hash = hash.$$keys[i].key.$hash();
 
-      if (key_hash === hash.keys[i].key_hash) {
+      if (key_hash === hash.$$keys[i].key_hash) {
         continue;
       }
 
-      bucket = hash.map[hash.keys[i].key_hash];
+      bucket = hash.$$map[hash.$$keys[i].key_hash];
       last_bucket = undefined;
 
       while (bucket) {
-        if (bucket === hash.keys[i]) {
+        if (bucket === hash.$$keys[i]) {
           if (last_bucket && bucket.next) {
             last_bucket.next = bucket.next;
           }
@@ -1525,10 +1535,10 @@
             delete last_bucket.next;
           }
           else if (bucket.next) {
-            hash.map[hash.keys[i].key_hash] = bucket.next;
+            hash.$$map[hash.$$keys[i].key_hash] = bucket.next;
           }
           else {
-            delete hash.map[hash.keys[i].key_hash];
+            delete hash.$$map[hash.$$keys[i].key_hash];
           }
           break;
         }
@@ -1536,18 +1546,18 @@
         bucket = bucket.next;
       }
 
-      hash.keys[i].key_hash = key_hash;
+      hash.$$keys[i].key_hash = key_hash;
 
-      if (!hash.map.hasOwnProperty(key_hash)) {
-        hash.map[key_hash] = hash.keys[i];
+      if (!hash.$$map.hasOwnProperty(key_hash)) {
+        hash.$$map[key_hash] = hash.$$keys[i];
         continue;
       }
 
-      bucket = hash.map[key_hash];
+      bucket = hash.$$map[key_hash];
       last_bucket = undefined;
 
       while (bucket) {
-        if (bucket === hash.keys[i]) {
+        if (bucket === hash.$$keys[i]) {
           last_bucket = undefined;
           break;
         }
@@ -1556,7 +1566,7 @@
       }
 
       if (last_bucket) {
-        last_bucket.next = hash.keys[i];
+        last_bucket.next = hash.$$keys[i];
       }
     }
   };
@@ -1616,26 +1626,24 @@
     return hash;
   };
 
-  /*
-   * hash2 is a faster creator for hashes that just use symbols and
-   * strings as keys. The map and keys array can be constructed at
-   * compile time, so they are just added here by the constructor
-   * function
-   */
+  // hash2 is a faster creator for hashes that just use symbols and
+  // strings as keys. The map and keys array can be constructed at
+  // compile time, so they are just added here by the constructor
+  // function
+  //
   Opal.hash2 = function(keys, smap) {
     var hash = new Opal.Hash.$$alloc();
 
-    hash.map  = {};
-    hash.keys = keys;
-    hash.smap = smap;
+    hash.$$map  = {};
+    hash.$$keys = keys;
+    hash.$$smap = smap;
 
     return hash;
   };
 
-  /*
-   * Create a new range instance with first and last values, and whether the
-   * range excludes the last value.
-   */
+  // Create a new range instance with first and last values, and whether the
+  // range excludes the last value.
+  //
   Opal.range = function(first, last, exc) {
     var range         = new Opal.Range.$$alloc();
         range.begin   = first;
@@ -1646,17 +1654,19 @@
   };
 
   Opal.ivar = function(name) {
-    if (name === "constructor" ||
-        name === "__proto__" ||
-        name === "__parent__" ||
+    if (
+        // properties
+        name === "constructor" ||
+        name === "displayName" ||
+        name === "__count__" ||
         name === "__noSuchMethod__" ||
-        name === "__count__")
-    {
-      return name + "$";
-    }
+        name === "__parent__" ||
+        name === "__proto__" ||
 
-    if (name === "hasOwnProperty" ||
-        name === "valueOf")
+        // methods
+        name === "hasOwnProperty" ||
+        name === "valueOf"
+       )
     {
       return name + "$";
     }
@@ -1666,169 +1676,133 @@
 
   // Require system
   // --------------
-  (function(Opal) {
-    var loaded_features = ['corelib/runtime'],
-        require_table   = {'corelib/runtime': true},
-        modules         = {};
 
-    var current_dir  = '.';
+  Opal.modules         = {};
+  Opal.loaded_features = ['corelib/runtime'];
+  Opal.current_dir     = '.'
+  Opal.require_table   = {'corelib/runtime': true};
 
-    function normalize(path) {
-      var parts, part, new_parts = [], SEPARATOR = '/';
+  function normalize(path) {
+    var parts, part, new_parts = [], SEPARATOR = '/';
 
-      if (current_dir !== '.') {
-        path = current_dir.replace(/\/*$/, '/') + path;
-      }
-
-      path = path.replace(/\.(rb|opal|js)$/, '');
-      parts = path.split(SEPARATOR);
+    if (Opal.current_dir !== '.') {
+      path = Opal.current_dir.replace(/\/*$/, '/') + path;
+    }
 
-      for (var i = 0, ii = parts.length; i < ii; i++) {
-        part = parts[i];
-        if (part === '') continue;
-        (part === '..') ? new_parts.pop() : new_parts.push(part)
-      }
+    path = path.replace(/\.(rb|opal|js)$/, '');
+    parts = path.split(SEPARATOR);
 
-      return new_parts.join(SEPARATOR);
+    for (var i = 0, ii = parts.length; i < ii; i++) {
+      part = parts[i];
+      if (part === '') continue;
+      (part === '..') ? new_parts.pop() : new_parts.push(part)
     }
 
-    function loaded(paths) {
-      var i, l, path;
+    return new_parts.join(SEPARATOR);
+  }
 
-      for (i = 0, l = paths.length; i < l; i++) {
-        path = normalize(paths[i]);
+  Opal.loaded = function(paths) {
+    var i, l, path;
 
-        if (require_table[path]) {
-          return;
-        }
+    for (i = 0, l = paths.length; i < l; i++) {
+      path = normalize(paths[i]);
 
-        loaded_features.push(path);
-        require_table[path] = true;
+      if (Opal.require_table[path]) {
+        return;
       }
+
+      Opal.loaded_features.push(path);
+      Opal.require_table[path] = true;
     }
+  }
 
-    function load(path) {
-      path = normalize(path);
+  Opal.load = function(path) {
+    path = normalize(path);
 
-      loaded([path]);
+    Opal.loaded([path]);
 
-      var module = modules[path];
+    var module = Opal.modules[path];
 
-      if (module) {
-        module(Opal);
-      }
-      else {
-        var severity = Opal.dynamic_require_severity || 'warning';
-        var message  = 'cannot load such file -- ' + path;
+    if (module) {
+      module(Opal);
+    }
+    else {
+      var severity = Opal.dynamic_require_severity || 'warning';
+      var message  = 'cannot load such file -- ' + path;
 
-        if (severity === "error") {
-          Opal.LoadError ? Opal.LoadError.$new(message) : function(){throw message}();
-        }
-        else if (severity === "warning") {
-          console.warn('WARNING: LoadError: ' + message);
-        }
+      if (severity === "error") {
+        Opal.LoadError ? Opal.LoadError.$new(message) : function(){throw message}();
+      }
+      else if (severity === "warning") {
+        console.warn('WARNING: LoadError: ' + message);
       }
-
-      return true;
     }
 
-    function require(path) {
-      path = normalize(path);
+    return true;
+  }
 
-      if (require_table[path]) {
-        return false;
-      }
+  Opal.require = function(path) {
+    path = normalize(path);
 
-      return load(path);
+    if (Opal.require_table[path]) {
+      return false;
     }
 
-    Opal.modules         = modules;
-    Opal.loaded_features = loaded_features;
-    Opal.loaded          = loaded;
-
-    Opal.load    = load;
-    Opal.require = require;
-  })(Opal);
+    return Opal.load(path);
+  }
 
   // Initialization
   // --------------
 
-  // The actual class for BasicObject
-  var BasicObjectClass;
-
-  // The actual Object class
-  var ObjectClass;
-
-  // The actual Module class
-  var ModuleClass;
-
-  // The actual Class class
-  var ClassClass;
-
-  // Constructor for instances of BasicObject
-  function BasicObject(){}
-
-  // Constructor for instances of Object
-  function Object(){}
-
-  // Constructor for instances of Class
-  function Class(){}
-
-  // Constructor for instances of Module
-  function Module(){}
-
-  // Constructor for instances of NilClass (nil)
-  function NilClass(){}
-
   // Constructors for *instances* of core objects
-  boot_class_alloc('BasicObject', BasicObject);
-  boot_class_alloc('Object',      Object,       BasicObject);
-  boot_class_alloc('Module',      Module,       Object);
-  boot_class_alloc('Class',       Class,        Module);
+  boot_class_alloc('BasicObject', BasicObject_alloc);
+  boot_class_alloc('Object',      Object_alloc,       BasicObject_alloc);
+  boot_class_alloc('Module',      Module_alloc,       Object_alloc);
+  boot_class_alloc('Class',       Class_alloc,        Module_alloc);
 
   // Constructors for *classes* of core objects
-  BasicObjectClass = boot_core_class_object('BasicObject', BasicObject, Class);
-  ObjectClass      = boot_core_class_object('Object',      Object,      BasicObjectClass.constructor);
-  ModuleClass      = boot_core_class_object('Module',      Module,      ObjectClass.constructor);
-  ClassClass       = boot_core_class_object('Class',       Class,       ModuleClass.constructor);
+  BasicObject = boot_core_class_object('BasicObject', BasicObject_alloc, Class_alloc);
+  _Object     = boot_core_class_object('Object',      Object_alloc,      BasicObject.constructor);
+  Module      = boot_core_class_object('Module',      Module_alloc,      _Object.constructor);
+  Class       = boot_core_class_object('Class',       Class_alloc,       Module.constructor);
 
   // Fix booted classes to use their metaclass
-  BasicObjectClass.$$class = ClassClass;
-  ObjectClass.$$class      = ClassClass;
-  ModuleClass.$$class      = ClassClass;
-  ClassClass.$$class       = ClassClass;
+  BasicObject.$$class = Class;
+  _Object.$$class     = Class;
+  Module.$$class      = Class;
+  Class.$$class       = Class;
 
   // Fix superclasses of booted classes
-  BasicObjectClass.$$super = null;
-  ObjectClass.$$super      = BasicObjectClass;
-  ModuleClass.$$super      = ObjectClass;
-  ClassClass.$$super       = ModuleClass;
-
-  BasicObjectClass.$$parent = null;
-  ObjectClass.$$parent      = BasicObjectClass;
-  ModuleClass.$$parent      = ObjectClass;
-  ClassClass.$$parent       = ModuleClass;
-
-  Opal.base                     = ObjectClass;
-  BasicObjectClass.$$scope      = ObjectClass.$$scope = Opal;
-  BasicObjectClass.$$orig_scope = ObjectClass.$$orig_scope = Opal;
-
-  ModuleClass.$$scope      = ObjectClass.$$scope;
-  ModuleClass.$$orig_scope = ObjectClass.$$orig_scope;
-  ClassClass.$$scope       = ObjectClass.$$scope;
-  ClassClass.$$orig_scope  = ObjectClass.$$orig_scope;
-
-  ObjectClass.$$proto.toString = function() {
+  BasicObject.$$super = null;
+  _Object.$$super     = BasicObject;
+  Module.$$super      = _Object;
+  Class.$$super       = Module;
+
+  BasicObject.$$parent = null;
+  _Object.$$parent     = BasicObject;
+  Module.$$parent      = _Object;
+  Class.$$parent       = Module;
+
+  Opal.base                = _Object;
+  BasicObject.$$scope      = _Object.$$scope = Opal;
+  BasicObject.$$orig_scope = _Object.$$orig_scope = Opal;
+
+  Module.$$scope      = _Object.$$scope;
+  Module.$$orig_scope = _Object.$$orig_scope;
+  Class.$$scope       = _Object.$$scope;
+  Class.$$orig_scope  = _Object.$$orig_scope;
+
+  _Object.$$proto.toString = function() {
     return this.$to_s();
   };
 
-  ObjectClass.$$proto.$require = Opal.require;
+  _Object.$$proto.$require = Opal.require;
 
-  Opal.top = new ObjectClass.$$alloc();
+  Opal.top = new _Object.$$alloc();
 
   // Nil
-  Opal.klass(ObjectClass, ObjectClass, 'NilClass', NilClass);
-  var nil = Opal.nil = new NilClass();
+  Opal.klass(_Object, _Object, 'NilClass', NilClass_alloc);
+  nil = Opal.nil = new NilClass_alloc();
   nil.$$id = nil_id;
   nil.call = nil.apply = function() { throw Opal.LocalJumpError.$new('no block given'); };
 
@@ -1842,6 +1816,7 @@ if (typeof(global) !== 'undefined') {
   global.Opal = this.Opal;
   Opal.global = global;
 }
+
 if (typeof(window) !== 'undefined') {
   window.Opal = this.Opal;
   Opal.global = window;