opal 0.9.4 → 0.10.0.beta1

data/opal/corelib/number.rb

@@ -209,16 +209,13 @@ class Number < Numeric
     bit = Opal.coerce_to! bit, Integer, :to_int
 
     %x{
-      if (#{bit} < #{Integer::MIN} || #{bit} > #{Integer::MAX}) {
+      if (#{bit} < 0) {
         return 0;
       }
-
-      if (self < 0) {
-        return (((~self) + 1) >> #{bit}) % 2;
-      }
-      else {
-        return (self >> #{bit}) % 2;
+      if (#{bit} >= 32) {
+        return #{ self } < 0 ? 1 : 0;
       }
+      return (self >> #{bit}) & 1;
     }
   end
 
@@ -345,9 +342,7 @@ class Number < Numeric
         #{raise ArgumentError, "comparison of #{self.class} with #{stop.class} failed"}
       }
       for (var i = self; i >= stop; i--) {
-        if (block(i) === $breaker) {
-          return $breaker.$v;
-        }
+        block(i);
       }
     }
 
@@ -595,9 +590,7 @@ class Number < Numeric
 
     %x{
       for (var i = 0; i < self; i++) {
-        if (block(i) === $breaker) {
-          return $breaker.$v;
-        }
+        block(i);
       }
     }
 
@@ -659,9 +652,7 @@ class Number < Numeric
         #{raise ArgumentError, "comparison of #{self.class} with #{stop.class} failed"}
       }
       for (var i = self; i <= stop; i++) {
-        if (block(i) === $breaker) {
-          return $breaker.$v;
-        }
+        block(i);
       }
     }
 

data/opal/corelib/proc.rb

@@ -16,17 +16,32 @@ class Proc < `Function`
         self.$$p = block;
       }
 
-      var result;
-
-      if (self.$$is_lambda) {
-        result = self.apply(null, args);
+      var result, $brk = self.$$brk;
+
+      if ($brk) {
+        try {
+          if (self.$$is_lambda) {
+            result = self.apply(null, args);
+          }
+          else {
+            result = Opal.yieldX(self, args);
+          }
+        } catch (err) {
+          if (err === $brk) {
+            return $brk.$v
+          }
+          else {
+            throw err
+          }
+        }
       }
       else {
-        result = Opal.yieldX(self, args);
-      }
-
-      if (result === $breaker) {
-        return $breaker.$v;
+        if (self.$$is_lambda) {
+          result = self.apply(null, args);
+        }
+        else {
+          result = Opal.yieldX(self, args);
+        }
       }
 
       return result;

data/opal/corelib/range.rb

@@ -39,7 +39,7 @@ class Range
     return enum_for :each unless block_given?
 
     %x{
-      var i, limit, value;
+      var i, limit;
 
       if (#@begin.$$is_number && #@end.$$is_number) {
         if (#@begin % 1 !== 0 || #@end % 1 !== 0) {
@@ -47,24 +47,15 @@ class Range
         }
 
         for (i = #@begin, limit = #@end + #{@exclude ? 0 : 1}; i < limit; i++) {
-          value = block(i);
-          if (value === $breaker) { return $breaker.$v; }
+          block(i);
         }
 
         return self;
       }
 
       if (#@begin.$$is_string && #@end.$$is_string) {
-        value = #{@begin.upto(@end, @exclude, &block)};
-
-        // The following is a bit hackish: we know that
-        // String#upto normally returns self, but may
-        // return a different value if there's a `break`
-        // statement in the supplied block. We need to
-        // propagate this `break` value here, so we
-        // test for equality with `@begin` string to
-        // determine the return value:
-        return value === #@begin ? self : value;
+        #{@begin.upto(@end, @exclude, &block)}
+        return self;
       }
     }
 

data/opal/corelib/runtime.js

@@ -1,4 +1,18 @@
 (function(undefined) {
+  // @note
+  //   A few conventions for the documentation of this file:
+  //   1. Always use "//" (in contrast with "/**/")
+  //   2. The syntax used is Yardoc (yardoc.org), which is intended for Ruby (se below)
+  //   3. `@param` and `@return` types should be preceded by `JS.` when referring to
+  //      JavaScript constructors (e.g. `JS.Function`) otherwise Ruby is assumed.
+  //   4. `nil` and `null` being unambiguous refer to the respective
+  //      objects/values in Ruby and JavaScript
+  //   5. This is still WIP :) so please give feedback and suggestions on how
+  //      to improve or for alternative solutions
+  //
+  //   The way the code is digested before going through Yardoc is a secret kept
+  //   in the docs repo (https://github.com/opal/docs/tree/master).
+
   if (typeof(this.Opal) !== 'undefined') {
     console.warn('Opal already loaded. Loading twice can cause troubles, please fix your setup.');
     return this.Opal;
@@ -55,6 +69,12 @@
   // This is a useful reference to global object inside ruby files
   Opal.global = this;
 
+  // Configure runtime behavior with regards to require and unsupported fearures
+  Opal.config = {
+    missing_require_severity: 'error', // error, warning, ignore
+    unsupported_features_severity: 'warning' // error, warning, ignore
+  }
+
   // Minify common function calls
   var $hasOwn = Opal.hasOwnProperty;
   var $slice  = Opal.slice = Array.prototype.slice;
@@ -85,6 +105,16 @@
   // keeps track of exceptions for $!
   Opal.exceptions = [];
 
+  // @private
+  // Pops an exception from the stack and updates `$!`.
+  Opal.pop_exception = function() {
+    Opal.gvars["!"] = Opal.exceptions.pop() || nil;
+  }
+
+
+  // Constants
+  // ---------
+
   // 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`.
@@ -97,8 +127,8 @@
   // 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]
+  // @param name [String] the name of the constant to lookup
+  // @return [Object]
   //
   Opal.get = function(name) {
     var constant = this[name];
@@ -133,7 +163,88 @@
       Opal.cdecl(base_scope, id, klass);
       const_alloc.displayName = id+"_scope_alloc";
     }
-  }
+  };
+
+  // Constant assignment, see also `Opal.cdecl`
+  //
+  // @param base_module [Module, Class] the constant namespace
+  // @param name        [String] the name of the constant
+  // @param value       [Object] the value of the constant
+  //
+  // @example Assigning a namespaced constant
+  //   self::FOO = 'bar'
+  //
+  // @example Assigning with Module#const_set
+  //   Foo.const_set :BAR, 123
+  //
+  Opal.casgn = function(base_module, name, value) {
+    function update(klass, name) {
+      klass.$$name = name;
+
+      for (name in klass.$$scope) {
+        var value = klass.$$scope[name];
+
+        if (value.$$name === nil && (value.$$is_class || value.$$is_module)) {
+          update(value, name)
+        }
+      }
+    }
+
+    var scope = base_module.$$scope;
+
+    if (value.$$is_class || value.$$is_module) {
+      // 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;
+      }
+
+      if (value.$$name === nil && value.$$base_module.$$name !== nil) {
+        update(value, name);
+      }
+    }
+
+    scope.constants.push(name);
+    scope[name] = value;
+
+    // If we dynamically declare a constant in a module,
+    // we should populate all the classes that include this module
+    // with the same constant
+    if (base_module.$$is_module && base_module.$$dep) {
+      for (var i = 0; i < base_module.$$dep.length; i++) {
+        var dep = base_module.$$dep[i];
+        Opal.casgn(dep, name, value);
+      }
+    }
+
+    return value;
+  };
+
+  // Constant declaration
+  //
+  // @example
+  //   FOO = :bar
+  //
+  // @param base_scope [$$scope] the current scope
+  // @param name       [String] the name of the constant
+  // @param value      [Object] the value of the constant
+  Opal.cdecl = function(base_scope, name, value) {
+    if ((value.$$is_class || value.$$is_module) && value.$$orig_scope == null) {
+      value.$$name = name;
+      value.$$orig_scope = base_scope;
+      // Here we should explicitly set a base module
+      // (a module where the constant was initially defined)
+      value.$$base_module = base_scope.base;
+      base_scope.constructor[name] = value;
+    }
+
+    base_scope.constants.push(name);
+    return base_scope[name] = value;
+  };
+
+
+  // Modules & Classes
+  // -----------------
 
   // 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
@@ -141,8 +252,8 @@
   //
   // 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.
+  // fail, then we raise a `TypeError`. Note, `superclass` 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
@@ -154,13 +265,13 @@
   // use that as the base instead.
   //
   // @param base        [Object] where the class is being created
-  // @param superklass  [Class,null] superclass of the new class (may be null)
+  // @param superclass  [Class,null] superclass of the new class (may be null)
   // @param id          [String] the name of the class to be created
-  // @param constructor [Function] function to use as constructor
+  // @param constructor [JS.Function] function to use as constructor
   //
   // @return new [Class]  or existing ruby class
   //
-  Opal.klass = function(base, superklass, id, constructor) {
+  Opal.klass = function(base, superclass, name, constructor) {
     var klass, bridged, alloc;
 
     // If base is an object, use its class
@@ -169,24 +280,24 @@
     }
 
     // If the superclass is a function then we're bridging a native JS class
-    if (typeof(superklass) === 'function') {
-      bridged = superklass;
-      superklass = _Object;
+    if (typeof(superclass) === 'function') {
+      bridged = superclass;
+      superclass = _Object;
     }
 
     // Try to find the class in the current scope
-    klass = base.$$scope[id];
+    klass = base.$$scope[name];
 
     // If the class exists in the scope, then we must use that
     if (klass && klass.$$orig_scope === base.$$scope) {
       // Make sure the existing constant is a class, or raise error
       if (!klass.$$is_class) {
-        throw Opal.TypeError.$new(id + " is not a class");
+        throw Opal.TypeError.$new(name + " is not a class");
       }
 
       // Make sure existing class has same superclass
-      if (superklass && klass.$$super !== superklass) {
-        throw Opal.TypeError.$new("superclass mismatch for class " + id);
+      if (superclass && klass.$$super !== superclass) {
+        throw Opal.TypeError.$new("superclass mismatch for class " + name);
       }
 
       return klass;
@@ -195,141 +306,134 @@
     // 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 = _Object;
+    if (superclass == null) {
+      superclass = _Object;
     }
 
     // If bridged the JS class will also be the alloc function
-    alloc = bridged || boot_class_alloc(id, constructor, superklass);
+    alloc = bridged || Opal.boot_class_alloc(name, constructor, superclass);
 
     // Create the class object (instance of Class)
-    klass = boot_class_object(id, superklass, alloc);
+    klass = Opal.setup_class_object(name, alloc, superclass.$$name, superclass.constructor);
 
-    // Name the class
-    klass.$$name = id;
-    klass.displayName = id;
+    // @property $$super the superclass, doesn't get changed by module inclusions
+    klass.$$super = superclass;
 
-    // Mark the object as a class
-    klass.$$is_class = true;
+    // @property $$parent direct parent class
+    //                    starts with the superclass, after klass inclusion is
+    //                    the last included klass
+    klass.$$parent = superclass;
 
     // 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;
+    Opal.create_scope(base.$$scope, klass, name);
 
     if (bridged) {
       Opal.bridge(klass, alloc);
     }
     else {
       // Copy all parent constants to child, unless parent is Object
-      if (superklass !== _Object && superklass !== BasicObject) {
-        donate_constants(superklass, klass);
+      if (superclass !== _Object && superclass !== BasicObject) {
+        Opal.donate_constants(superclass, klass);
       }
 
       // Call .inherited() hook with new class on the superclass
-      if (superklass.$inherited) {
-        superklass.$inherited(klass);
+      if (superclass.$inherited) {
+        superclass.$inherited(klass);
       }
     }
 
     return klass;
   };
 
-  // Create generic class with given superclass.
-  Opal.boot_class = function(superklass, constructor) {
-    var alloc = boot_class_alloc(null, constructor, superklass)
+  // Boot a base class (makes instances).
+  //
+  // @param name [String,null] the class name
+  // @param constructor [JS.Function] the class' instances constructor/alloc function
+  // @param superclass  [Class,null] the superclass object
+  // @return [JS.Function] the consturctor holding the prototype for the class' instances
+  Opal.boot_class_alloc = function(name, constructor, superclass) {
+    if (superclass) {
+      var alloc_proxy = function() {};
+      alloc_proxy.prototype  = superclass.$$proto || superclass.prototype;
+      constructor.prototype = new alloc_proxy();
+    }
+
+    if (name) {
+      constructor.displayName = name+'_alloc';
+    }
 
-    return boot_class_object(null, superklass, alloc);
-  }
+    constructor.prototype.constructor = constructor;
 
-  // The class object itself (as in `Class.new`)
+    return constructor;
+  };
+
+  // Adds common/required properties to class object (as in `Class.new`)
+  //
+  // @param name  [String,null] The name of the class
+  //
+  // @param alloc [JS.Function] The constructor of the class' instances
+  //
+  // @param superclass_name [String,null]
+  //   The name of the super class, this is
+  //   usefule to build the `.displayName` of the singleton class
   //
-  // @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) {
+  // @param superclass_alloc [JS.Function]
+  //   The constructor of the superclass from which the singleton_class is
+  //   derived.
+  //
+  // @return [Class]
+  Opal.setup_class_object = function(name, alloc, superclass_name, superclass_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();
+    var superclass_alloc_proxy = function() {};
+        superclass_alloc_proxy.prototype = superclass_alloc.prototype;
+        superclass_alloc_proxy.displayName = superclass_name;
 
-    if (id) {
-      SingletonClass_alloc.displayName = "SingletonClass_alloc("+id+")";
-    }
+    var singleton_class_alloc = function() {}
+        singleton_class_alloc.prototype = new superclass_alloc_proxy();
 
     // The built class is the only instance of its singleton_class
-    var klass = new SingletonClass_alloc();
-
-    setup_module_or_class_object(klass, SingletonClass_alloc, superklass, alloc.prototype);
+    var klass = new singleton_class_alloc();
 
     // @property $$alloc This is the constructor of instances of the current
     //                   class. Its prototype will be used for method lookup
     klass.$$alloc = alloc;
 
-    // @property $$proto.$$class Make available to instances a reference to the
-    //                           class they belong to.
-    klass.$$proto.$$class = klass;
+    klass.$$name = name || nil;
 
-    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 `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`
-    module.$$id = Opal.uid();
+    klass.$$id = Opal.uid();
+
+    // Set a displayName for the singleton_class
+    singleton_class_alloc.displayName = "#<Class:"+(name || ("#<Class:"+klass.$$id+">"))+">";
 
     // @property $$proto This is the prototype on which methods will be defined
-    module.$$proto = prototype;
+    klass.$$proto = alloc.prototype;
+
+    // @property $$proto.$$class Make available to instances a reference to the
+    //                           class they belong to.
+    klass.$$proto.$$class = klass;
 
     // @property constructor keeps a ref to the constructor, but apparently the
     //                       constructor is already set on:
     //
-    //                          `var module = new constructor` is called.
+    //                          `var klass = new constructor` is called.
     //
     //                       Maybe there are some browsers not abiding (IE6?)
-    module.constructor = constructor;
-
-    if (superklass === Module) {
-      // @property $$is_module Clearly mark this as a module
-      module.$$is_module = true;
-      module.$$class     = Module;
-    }
-    else {
-      // @property $$is_class Clearly mark this as a class
-      module.$$is_class = true;
-      module.$$class    = Class;
-    }
+    klass.constructor = singleton_class_alloc;
 
-    // @property $$super the superclass, doesn't get changed by module inclusions
-    module.$$super = superklass;
+    // @property $$is_class Clearly mark this as a class
+    klass.$$is_class = true;
 
-    // @property $$parent direct parent class or module
-    //                    starts with the superclass, after module inclusion is
-    //                    the last included module
-    module.$$parent = superklass;
+    // @property $$class Classes are instances of the class Class
+    klass.$$class    = Class;
 
     // @property $$inc included modules
-    module.$$inc = [];
-  }
+    klass.$$inc = [];
+
+    return klass;
+  };
 
   // 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
@@ -347,48 +451,49 @@
   // new instance is returned back (to be referenced at runtime).
   //
   // @param  base [Module, Class] class or module this definition is inside
-  // @param  id [String] the name of the new (or existing) module
-  // @return [Module]
+  // @param  id   [String] the name of the new (or existing) module
   //
-  Opal.module = function(base, id) {
+  // @return [Module]
+  Opal.module = function(base, name) {
     var module;
 
     if (!base.$$is_class && !base.$$is_module) {
       base = base.$$class;
     }
 
-    if ($hasOwn.call(base.$$scope, id)) {
-      module = base.$$scope[id];
+    if ($hasOwn.call(base.$$scope, name)) {
+      module = base.$$scope[name];
 
       if (!module.$$is_module && module !== _Object) {
-        throw Opal.TypeError.$new(id + " is not a module");
+        throw Opal.TypeError.$new(name + " is not a module");
       }
     }
     else {
-      module = boot_module_object();
-
-      // name module using base (e.g. Foo or Foo::Baz)
-      module.$$name = id;
-
-      // mark the object as a module
-      module.$$is_module = true;
-
-      // initialize dependency tracking
-      module.$$dep = [];
-
-      Opal.create_scope(base.$$scope, module, id);
-
-      // Name new module directly onto current scope (Opal.Foo.Baz = module)
-      base[id] = base.$$scope[id] = module;
+      module = Opal.module_allocate();
+      Opal.create_scope(base.$$scope, module, name);
     }
 
     return module;
   };
 
+  // The implementation for Module#initialize
+  // @param module [Module]
+  // @param block [Proc,nil]
+  // @return nil
+  Opal.module_initialize = function(module, block) {
+    if (block !== nil) {
+      var block_self = block.$$s;
+      block.$$s = null;
+      block.call(module);
+      block.$$s = block_self;
+    }
+    return nil;
+  };
+
   // Internal function to create a new module instance. This simply sets up
   // the prototype hierarchy and method tables.
   //
-  function boot_module_object() {
+  Opal.module_allocate = function() {
     var mtor = function() {};
     mtor.prototype = Module_alloc.prototype;
 
@@ -397,14 +502,55 @@
 
     var module = new module_constructor();
     var module_prototype = {};
+    var superclass = Module;
+
+    // @property $$id Each class is assigned a unique `id` that helps
+    //                comparation and implementation of `#object_id`
+    module.$$id = Opal.uid();
 
-    setup_module_or_class_object(module, module_constructor, Module, module_prototype);
+    // Set the display name of the singleton prototype holder
+    module_constructor.displayName = "#<Class:#<Module:"+module.$$id+">>"
 
-    return module;
-  }
+    // @property $$proto This is the prototype on which methods will be defined
+    module.$$proto = module_prototype;
+
+    // @property constructor
+    //   keeps a ref to the constructor, but apparently the
+    //   constructor is already set on:
+    //
+    //      `var module = new constructor` is called.
+    //
+    //   Maybe there are some browsers not abiding (IE6?)
+    module.constructor = module_constructor;
+
+    // @property $$is_module Clearly mark this as a module
+    module.$$is_module = true;
+    module.$$class     = Module;
+
+    // @property $$super
+    //   the superclass, doesn't get changed by module inclusions
+    module.$$super = superclass;
 
-  // Make `boot_module_object` available to the JS-API
-  Opal.boot_module_object = boot_module_object;
+    // @property $$parent
+    //   direct parent class or module
+    //   starts with the superclass, after module inclusion is
+    //   the last included module
+    module.$$parent = superclass;
+
+    // @property $$inc included modules
+    module.$$inc = [];
+
+    // mark the object as a module
+    module.$$is_module = true;
+
+    // initialize dependency tracking
+    module.$$dep = [];
+
+    // initialize the name with nil
+    module.$$name = nil;
+
+    return module;
+  };
 
   // Return the singleton class for the passed object.
   //
@@ -415,68 +561,83 @@
   // 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
-  //
+  // @param object [Object] the ruby object
+  // @return [Class] the singleton class for object
   Opal.get_singleton_class = function(object) {
     if (object.$$meta) {
       return object.$$meta;
     }
 
     if (object.$$is_class || object.$$is_module) {
-      return build_class_singleton_class(object);
+      return Opal.build_class_singleton_class(object);
     }
 
-    return build_object_singleton_class(object);
+    return Opal.build_object_singleton_class(object);
   };
 
-  // Build the singleton class for an existing class.
+  // Build the singleton class for an existing class. Class object are built
+  // with their singleton class already in the prototype chain and inheriting
+  // from their superclass object (up to `Class` itself).
   //
   // 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();
+  // @param klass [Class]
+  // @return [Class]
+  Opal.build_class_singleton_class = function(object) {
+    var alloc, superclass, klass;
 
-    meta.$$class = Opal.Class;
-    meta.$$proto = klass.constructor.prototype;
+    if (object.$$meta) {
+      return object.$$meta;
+    }
 
-    meta.$$is_singleton = true;
-    meta.$$singleton_of = klass;
-    meta.$$inc          = [];
-    meta.$$scope        = klass.$$scope;
+    // The constructor and prototype of the singleton_class instances is the
+    // current class constructor and prototype.
+    alloc = object.constructor;
 
-    return klass.$$meta = meta;
-  }
+    // The singleton_class superclass is the singleton_class of its superclass;
+    // but BasicObject has no superclass (its `$$super` is null), thus we
+    // fallback on `Class`.
+    superclass = object === BasicObject ? Class : Opal.build_class_singleton_class(object.$$super);
+
+    klass = Opal.setup_class_object(null, alloc, superclass.$$name, superclass.constructor);
+    klass.$$super = superclass;
+    klass.$$parent = superclass;
+
+    // The singleton_class retains the same scope as the original class
+    Opal.create_scope(object.$$scope, klass);
+
+    klass.$$is_singleton = true;
+    klass.$$singleton_of = object;
+
+    return object.$$meta = klass;
+  };
 
   // 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 + ">>";
+  // @param object [Object]
+  // @return [Class]
+  Opal.build_object_singleton_class = function(object) {
+    var superclass = object.$$class,
+        name = "#<Class:#<" + superclass.$$name + ":" + superclass.$$id + ">>";
 
-    var Singleton = function() {};
-    var meta = Opal.boot_class(orig_class, Singleton);
-    meta.$$name   = class_id;
+    var alloc = Opal.boot_class_alloc(name, function(){}, superclass)
+    var klass = Opal.setup_class_object(name, alloc, superclass.$$name, superclass.constructor);
 
-    meta.$$proto  = object;
-    meta.$$class  = orig_class.$$class;
-    meta.$$scope  = orig_class.$$scope;
-    meta.$$parent = orig_class;
-    meta.$$is_singleton = true;
-    meta.$$singleton_of = object;
+    klass.$$super  = superclass;
+    klass.$$parent = superclass;
+    klass.$$class  = superclass.$$class;
+    klass.$$scope  = superclass.$$scope;
+    klass.$$proto  = object;
 
-    return object.$$meta = meta;
-  }
+    klass.$$is_singleton = true;
+    klass.$$singleton_of = object;
+
+    return object.$$meta = klass;
+  };
 
   // Bridges a single method.
-  function bridge_method(target, from, name, body) {
+  Opal.bridge_method = function(target, from, name, body) {
     var ancestors, i, ancestor, length;
 
     ancestors = target.$$bridge.$ancestors();
@@ -500,10 +661,10 @@
       }
     }
 
-  }
+  };
 
   // Bridges from *donator* to a *target*.
-  function _bridge(target, donator) {
+  Opal._bridge = function(target, donator) {
     var id, methods, method, i, bridged;
 
     if (typeof(target) === "function") {
@@ -513,7 +674,7 @@
       for (i = methods.length - 1; i >= 0; i--) {
         method = '$' + methods[i];
 
-        bridge_method(target, donator, method, donator.$$proto[method]);
+        Opal.bridge_method(target, donator, method, donator.$$proto[method]);
       }
 
       if (!bridges[id]) {
@@ -527,13 +688,13 @@
 
       if (bridged) {
         for (i = bridged.length - 1; i >= 0; i--) {
-          _bridge(bridged[i], donator);
+          Opal._bridge(bridged[i], donator);
         }
 
         bridges[donator.$__id__()] = bridged.slice();
       }
     }
-  }
+  };
 
   // The actual inclusion of a module into a class.
   //
@@ -550,10 +711,9 @@
   // 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
+  // @param module [Module] the module to include
+  // @param klass  [Class] the target class to include module into
   // @return [null]
-  //
   Opal.append_features = function(module, klass) {
     var iclass, donator, prototype, methods, id, i;
 
@@ -566,7 +726,7 @@
 
     klass.$$inc.push(module);
     module.$$dep.push(klass);
-    _bridge(klass, module);
+    Opal._bridge(klass, module);
 
     // iclass
     iclass = {
@@ -599,60 +759,12 @@
       prototype[id].$$donated = module;
     }
 
-    donate_constants(module, klass);
+    Opal.donate_constants(module, klass);
   };
 
-  // Boot a base class (makes instances).
-  function boot_class_alloc(id, constructor, superklass) {
-    if (superklass) {
-      var alloc_proxy = function() {};
-      alloc_proxy.prototype  = superklass.$$proto || superklass.prototype;
-      constructor.prototype = new alloc_proxy();
-    }
-
-    if (id) {
-      constructor.displayName = id+'_alloc';
-    }
-
-    constructor.prototype.constructor = constructor;
-
-    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
-  //
-  function boot_core_class_object(id, alloc, superclass) {
-    var superclass_constructor = function() {};
-        superclass_constructor.prototype = superclass.prototype;
-
-    var singleton_class = function() {};
-        singleton_class.prototype = new superclass_constructor();
-
-    singleton_class.displayName = "#<Class:"+id+">";
-
-    // the singleton_class acts as the class object constructor
-    var klass = new singleton_class();
-
-    setup_module_or_class_object(klass, singleton_class, superclass, alloc.prototype);
-
-    klass.$$alloc     = alloc;
-    klass.$$name      = id;
-    klass.displayName = id;
-
-    // Give all instances a ref to their class
-    alloc.prototype.$$class = klass;
-
-    Opal[id] = klass;
-    Opal.constants.push(id);
-
-    return klass;
-  }
+  // Table that holds all methods that have been defined on all objects
+  // It is used for defining method stubs for new coming native classes
+  Opal.stubs = {};
 
   // For performance, some core Ruby classes are toll-free bridged to their
   // native JavaScript counterparts (e.g. a Ruby Array is a JavaScript Array).
@@ -667,8 +779,8 @@
   //
   //    Opal.bridge(self, Function);
   //
-  // @param [Class] klass the Ruby class to bridge
-  // @param [Function] constructor native JavaScript constructor to use
+  // @param klass       [Class] the Ruby class to bridge
+  // @param constructor [JS.Function] native JavaScript constructor to use
   // @return [Class] returns the passed Ruby class
   //
   Opal.bridge = function(klass, constructor) {
@@ -678,6 +790,13 @@
 
     Opal.stub_subscribers.push(constructor.prototype);
 
+    // Populate constructor with previously stored stubs
+    for (var method_name in Opal.stubs) {
+      if (!(method_name in constructor.prototype)) {
+        constructor.prototype[method_name] = Opal.stub_for(method_name);
+      }
+    }
+
     constructor.prototype.$$class = klass;
     constructor.$$bridge          = klass;
 
@@ -686,7 +805,7 @@
     // 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]);
+      Opal._bridge(constructor, ancestors[i]);
     }
 
     for (var name in BasicObject_alloc.prototype) {
@@ -698,68 +817,12 @@
     }
 
     return klass;
-  }
-
-
-  // Constant assignment, see also `Opal.cdecl`
-  //
-  // @param base_module [Module, Class] the constant namespace
-  // @param name        [String] the name of the constant
-  // @param value       [Object] the value of the constant
-  //
-  // @example Assigning a namespaced constant
-  //   self::FOO = 'bar'
-  //
-  // @example Assigning with Module#const_set
-  //   Foo.const_set :BAR, 123
-  //
-  Opal.casgn = function(base_module, name, value) {
-    function update(klass, name) {
-      klass.$$name = name;
-
-      for (name in klass.$$scope) {
-        var value = klass.$$scope[name];
-
-        if (value.$$name === nil && (value.$$is_class || value.$$is_module)) {
-          update(value, name)
-        }
-      }
-    }
-
-    var scope = base_module.$$scope;
-
-    if (value.$$is_class || value.$$is_module) {
-      // 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;
-      }
-
-      if (value.$$name === nil && value.$$base_module.$$name !== nil) {
-        update(value, name);
-      }
-    }
-
-    scope.constants.push(name);
-    return scope[name] = value;
-  };
-
-  // constant decl
-  Opal.cdecl = function(base_scope, name, value) {
-    if ((value.$$is_class || value.$$is_module) && value.$$orig_scope == null) {
-      value.$$name = name;
-      value.$$orig_scope = base_scope;
-      base_scope.constructor[name] = value;
-    }
-
-    base_scope.constants.push(name);
-    return base_scope[name] = value;
   };
 
   // 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) {
+  Opal.donate_constants = function(source_mod, target_mod) {
     var source_constants = source_mod.$$scope.constants,
         target_scope     = target_mod.$$scope,
         target_constants = target_scope.constants;
@@ -771,7 +834,7 @@
   };
 
   // Donate methods for a module.
-  function donate(module, jsid) {
+  Opal.donate = function(module, jsid) {
     var included_in = module.$$dep,
         body = module.$$proto[jsid],
         i, length, includee, dest, current,
@@ -817,11 +880,37 @@
       }
 
       if (includee.$$dep) {
-        donate(includee, jsid);
+        Opal.donate(includee, jsid);
+      }
+    }
+  };
+
+  // The Array of ancestors for a given module/class
+  Opal.ancestors = function(module_or_class) {
+    var parent = module_or_class,
+        result = [],
+        modules;
+
+    while (parent) {
+      result.push(parent);
+      for (var i=0; i < parent.$$inc.length; i++) {
+        modules = Opal.ancestors(parent.$$inc[i]);
+
+        for(var j = 0; j < modules.length; j++) {
+          result.push(modules[j]);
+        }
       }
+
+      parent = parent.$$is_class ? parent.$$super : null;
     }
+
+    return result;
   };
 
+
+  // Method Missing
+  // --------------
+
   // 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
@@ -847,8 +936,8 @@
   // 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
-  //
+  // @param stubs [Array] an array of method stubs to add
+  // @return [undefined]
   Opal.add_stubs = function(stubs) {
     var subscriber, subscribers = Opal.stub_subscribers,
         i, ilength = stubs.length,
@@ -857,7 +946,9 @@
 
     for (i = 0; i < ilength; i++) {
       method_name = stubs[i];
-      stub = stub_for(method_name);
+      // Save method name to populate other subscribers with this stub
+      Opal.stubs[method_name] = true;
+      stub = Opal.stub_for(method_name);
 
       for (j = 0; j < jlength; j++) {
         subscriber = subscribers[j];
@@ -878,19 +969,19 @@
   // 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")
-  //
+  // @param prototype [Prototype] the target prototype
+  // @param stub [String] stub name to add (e.g. "$foo")
+  // @return [undefined]
   Opal.add_stub_for = function(prototype, stub) {
-    var method_missing_stub = stub_for(stub);
+    var method_missing_stub = Opal.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")
-  //
-  function stub_for(method_name) {
+  // @param method_name [String] The js-name of the method to stub (e.g. "$foo")
+  // @return [undefined]
+  Opal.stub_for = function(method_name) {
     function method_missing_stub() {
       // Copy any given block onto the method_missing dispatcher
       this.$method_missing.$$p = method_missing_stub.$$p;
@@ -905,7 +996,11 @@
     method_missing_stub.$$stub = true;
 
     return method_missing_stub;
-  }
+  };
+
+
+  // Methods
+  // -------
 
   // Arity count error dispatcher
   Opal.ac = function(actual, expected, object, meth) {
@@ -921,25 +1016,8 @@
     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) {
+  Opal.find_super_dispatcher = function(obj, jsid, current_func, defcheck, defs) {
     var dispatcher;
 
     if (defs) {
@@ -955,33 +1033,47 @@
         dispatcher = obj.$$super;
       }
       else {
-        dispatcher = find_obj_super_dispatcher(obj, jsid, current_func);
+        dispatcher = Opal.find_obj_super_dispatcher(obj, jsid, current_func);
       }
     }
 
     dispatcher = dispatcher['$' + jsid];
-    dispatcher.$$p = iter;
+
+    if (!defcheck && dispatcher.$$stub && Opal.Kernel.$method_missing === obj.$method_missing) {
+      // method_missing hasn't been explicitly defined
+      throw Opal.NoMethodError.$new('super: no superclass method `'+jsid+"' for "+obj, jsid);
+    }
 
     return dispatcher;
   };
 
   // Iter dispatcher for super in a block
-  Opal.find_iter_super_dispatcher = function(obj, jsid, current_func, iter, defs) {
-    if (current_func.$$def) {
-      return Opal.find_super_dispatcher(obj, current_func.$$jsid, current_func, iter, defs);
+  Opal.find_iter_super_dispatcher = function(obj, jsid, current_func, defcheck, implicit) {
+    var call_jsid = jsid;
+
+    if (!current_func) {
+      throw Opal.RuntimeError.$new("super called outside of method");
     }
-    else {
-      return Opal.find_super_dispatcher(obj, jsid, current_func, iter, defs);
+
+    if (implicit && current_func.$$define_meth) {
+      throw Opal.RuntimeError.$new("implicit argument passing of super from method defined by define_method() is not supported. Specify all arguments explicitly");
     }
+
+    if (current_func.$$def) {
+      call_jsid = current_func.$$jsid;
+    }
+
+    return Opal.find_super_dispatcher(obj, call_jsid, current_func, defcheck);
   };
 
-  function find_obj_super_dispatcher(obj, jsid, current_func) {
+  Opal.find_obj_super_dispatcher = function(obj, jsid, current_func) {
     var klass = obj.$$meta || obj.$$class;
     jsid = '$' + jsid;
 
+    // first we need to find the class/module current_func is defined/donated on
     while (klass) {
-      if (klass.$$proto[jsid] === current_func) {
-        // ok
+      // when a module has been included in a class, look for that
+      if ((klass.$$iclass && klass.$$module === current_func.$$owner) || klass === current_func.$$owner) {
         break;
       }
 
@@ -995,7 +1087,7 @@
 
     klass = klass.$$parent;
 
-    // else, let's find the next one
+    // now we can find the super
     while (klass) {
       var working = klass.$$proto[jsid];
 
@@ -1022,6 +1114,18 @@
     throw Opal.returner;
   };
 
+  // Used to break out of a block.
+  Opal.brk = function(val, breaker) {
+    breaker.$v = val;
+    throw breaker;
+  };
+
+  // Builds a new unique breaker, this is to avoid multiple nested breaks to get
+  // in the way of each other.
+  Opal.new_brk = function() {
+    return new Error('unexpected break');
+  };
+
   // handles yield calls for 1 yielded arg
   Opal.yield1 = function(block, arg) {
     if (typeof(block) !== "function") {
@@ -1081,20 +1185,20 @@
       return true;
     }
 
-    var search = object.$$class;
+    var i, length, ancestors = Opal.ancestors(object.$$class);
 
-    while (search) {
-      if (search === klass) {
+    for (i = 0, length = ancestors.length; i < length; i++) {
+      if (ancestors[i] === klass) {
         return true;
       }
+    }
 
-      for (var i = 0, length = search.$$inc.length; i < length; i++) {
-        if (search.$$inc[i] === klass) {
-          return true;
-        }
-      }
+    ancestors = Opal.ancestors(object.$$meta);
 
-      search = search.$$super;
+    for (i = 0, length = ancestors.length; i < length; i++) {
+      if (ancestors[i] === klass) {
+        return true;
+      }
     }
 
     return false;
@@ -1102,13 +1206,13 @@
 
   // Helpers for implementing multiple assignment
   // Our code for extracting the values and assigning them only works if the
-  // return value is a JS array
+  // return value is a JS array.
   // So if we get an Array subclass, extract the wrapped JS array from it
 
+  // Used for: a, b = something (no splat)
   Opal.to_ary = function(value) {
-    // Used for: a, b = something (no splat)
     if (value.$$is_array) {
-      return (value.constructor === Array) ? value : value.literal;
+      return value;
     }
     else if (value['$respond_to?']('to_ary', true)) {
       var ary = value.$to_ary();
@@ -1116,7 +1220,7 @@
         return [value];
       }
       else if (ary.$$is_array) {
-        return (ary.constructor === Array) ? ary : ary.literal;
+        return ary;
       }
       else {
         throw Opal.TypeError.$new("Can't convert " + value.$$class +
@@ -1128,11 +1232,11 @@
     }
   };
 
+  // Used for: a, b = *something (with splat)
   Opal.to_a = function(value) {
-    // 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();
+      return value.slice();
     }
     else if (value['$respond_to?']('to_a', true)) {
       var ary = value.$to_a();
@@ -1140,7 +1244,7 @@
         return [value];
       }
       else if (ary.$$is_array) {
-        return (ary.constructor === Array) ? ary : ary.literal;
+        return ary;
       }
       else {
         throw Opal.TypeError.$new("Can't convert " + value.$$class +
@@ -1152,6 +1256,24 @@
     }
   };
 
+  // Used for extracting keyword arguments from arguments passed to
+  // JS function. If provided +arguments+ list doesn't have a Hash
+  // as a last item, returns a blank Hash.
+  //
+  // @param parameters [Array]
+  // @return [Hash]
+  //
+  Opal.extract_kwargs = function(parameters) {
+    var kwargs = parameters[parameters.length - 1];
+    if (kwargs != null && kwargs['$respond_to?']('to_hash', true)) {
+      Array.prototype.splice.call(parameters, parameters.length - 1, 1);
+      return kwargs.$to_hash();
+    }
+    else {
+      return Opal.hash2([], {});
+    }
+  }
+
   // 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
@@ -1181,6 +1303,7 @@
 
   // Call a ruby method on a ruby object with some arguments:
   //
+  // @example
   //   var my_array = [1, 2, 3, 4]
   //   Opal.send(my_array, 'length')     # => 4
   //   Opal.send(my_array, 'reverse!')   # => [4, 3, 2, 1]
@@ -1190,9 +1313,9 @@
   //
   // The result of either call with be returned.
   //
-  // @param [Object] recv the ruby object
-  // @param [String] mid ruby method to call
-  //
+  // @param recv [Object] the ruby object
+  // @param mid  [String] ruby method to call
+  // @return [Object] forwards the return value of the method (or of method_missing)
   Opal.send = function(recv, mid) {
     var args = $slice.call(arguments, 2),
         func = recv['$' + mid];
@@ -1247,16 +1370,18 @@
   // 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
+  // @param obj  [Object, Class] the actual obj to define method for
+  // @param jsid [String] the javascript friendly method name (e.g. '$foo')
+  // @param body [JS.Function] the literal javascript function used as method
   // @return [null]
   //
   Opal.defn = function(obj, jsid, body) {
     obj.$$proto[jsid] = body;
+    // for super dispatcher, etc.
+    body.$$owner = obj;
 
     if (obj.$$is_module) {
-      donate(obj, jsid);
+      Opal.donate(obj, jsid);
 
       if (obj.$$module_function) {
         Opal.defs(obj, jsid, body);
@@ -1268,24 +1393,22 @@
 
       if (bridged) {
         for (var i = bridged.length - 1; i >= 0; i--) {
-          bridge_method(bridged[i], obj, jsid, body);
+          Opal.bridge_method(bridged[i], obj, jsid, body);
         }
       }
     }
 
-    if (obj.$method_added && !obj.$method_added.$$stub) {
+    var singleton_of = obj.$$singleton_of;
+    if (obj.$method_added && !obj.$method_added.$$stub && !singleton_of) {
       obj.$method_added(jsid.substr(1));
     }
-
-    var singleton_of = obj.$$singleton_of;
-    if (singleton_of && singleton_of.$singleton_method_added && !singleton_of.$singleton_method_added.$$stub) {
+    else if (singleton_of && singleton_of.$singleton_method_added && !singleton_of.$singleton_method_added.$$stub) {
       singleton_of.$singleton_method_added(jsid.substr(1));
     }
 
     return nil;
   };
 
-
   // Define a singleton method on the given object.
   Opal.defs = function(obj, jsid, body) {
     Opal.defn(Opal.get_singleton_class(obj), jsid, body)
@@ -1384,15 +1507,19 @@
     return obj;
   };
 
+
+  // Hashes
+  // ------
+
   Opal.hash_init = function(hash) {
-    hash.$$map  = {};
     hash.$$smap = {};
+    hash.$$map  = {};
     hash.$$keys = [];
   };
 
   Opal.hash_clone = function(from_hash, to_hash) {
-    to_hash.none = from_hash.none;
-    to_hash.proc = from_hash.proc;
+    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];
@@ -1650,9 +1777,9 @@
   Opal.hash2 = function(keys, smap) {
     var hash = new Opal.Hash.$$alloc();
 
+    hash.$$smap = smap;
     hash.$$map  = {};
     hash.$$keys = keys;
-    hash.$$smap = smap;
 
     return hash;
   };
@@ -1690,6 +1817,7 @@
     return name;
   };
 
+
   // Require system
   // --------------
 
@@ -1698,7 +1826,7 @@
   Opal.current_dir     = '.'
   Opal.require_table   = {'corelib/runtime': true};
 
-  function normalize(path) {
+  Opal.normalize = function(path) {
     var parts, part, new_parts = [], SEPARATOR = '/';
 
     if (Opal.current_dir !== '.') {
@@ -1715,13 +1843,13 @@
     }
 
     return new_parts.join(SEPARATOR);
-  }
+  };
 
   Opal.loaded = function(paths) {
     var i, l, path;
 
     for (i = 0, l = paths.length; i < l; i++) {
-      path = normalize(paths[i]);
+      path = Opal.normalize(paths[i]);
 
       if (Opal.require_table[path]) {
         return;
@@ -1730,10 +1858,10 @@
       Opal.loaded_features.push(path);
       Opal.require_table[path] = true;
     }
-  }
+  };
 
   Opal.load = function(path) {
-    path = normalize(path);
+    path = Opal.normalize(path);
 
     Opal.loaded([path]);
 
@@ -1743,7 +1871,7 @@
       module(Opal);
     }
     else {
-      var severity = Opal.dynamic_require_severity || 'warning';
+      var severity = Opal.config.missing_require_severity;
       var message  = 'cannot load such file -- ' + path;
 
       if (severity === "error") {
@@ -1755,32 +1883,38 @@
     }
 
     return true;
-  }
+  };
 
   Opal.require = function(path) {
-    path = normalize(path);
+    path = Opal.normalize(path);
 
     if (Opal.require_table[path]) {
       return false;
     }
 
     return Opal.load(path);
-  }
+  };
+
 
   // Initialization
   // --------------
 
   // Constructors for *instances* of core objects
-  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);
+  Opal.boot_class_alloc('BasicObject', BasicObject_alloc);
+  Opal.boot_class_alloc('Object',      Object_alloc,       BasicObject_alloc);
+  Opal.boot_class_alloc('Module',      Module_alloc,       Object_alloc);
+  Opal.boot_class_alloc('Class',       Class_alloc,        Module_alloc);
 
   // Constructors for *classes* of core objects
-  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);
+  Opal.BasicObject = BasicObject = Opal.setup_class_object('BasicObject', BasicObject_alloc, 'Class',       Class_alloc);
+  Opal.Object      = _Object     = Opal.setup_class_object('Object',      Object_alloc,      'BasicObject', BasicObject.constructor);
+  Opal.Module      = Module      = Opal.setup_class_object('Module',      Module_alloc,      'Object',      _Object.constructor);
+  Opal.Class       = Class       = Opal.setup_class_object('Class',       Class_alloc,       'Module',      Module.constructor);
+
+  Opal.constants.push("BasicObject");
+  Opal.constants.push("Object");
+  Opal.constants.push("Module");
+  Opal.constants.push("Class");
 
   // Fix booted classes to use their metaclass
   BasicObject.$$class = Class;
@@ -1808,12 +1942,16 @@
   Class.$$scope       = _Object.$$scope;
   Class.$$orig_scope  = _Object.$$orig_scope;
 
+  // Forward .toString() to #to_s
   _Object.$$proto.toString = function() {
     return this.$to_s();
   };
 
+  // Make Kernel#require immediately available as it's needed to require all the
+  // other corelib files.
   _Object.$$proto.$require = Opal.require;
 
+  // Instantiate the top object
   Opal.top = new _Object.$$alloc();
 
   // Nil
@@ -1821,8 +1959,7 @@
   nil = Opal.nil = new NilClass_alloc();
   nil.$$id = nil_id;
   nil.call = nil.apply = function() { throw Opal.LocalJumpError.$new('no block given'); };
-
-  Opal.breaker  = new Error('unexpected break');
+  Opal.breaker  = new Error('unexpected break (old)');
   Opal.returner = new Error('unexpected return');
 
   TypeError.$$super = Error;