opal 0.3.19 → 0.3.20

data/core/regexp.rb

@@ -20,10 +20,11 @@ class Regexp < `RegExp`
       var result = this.exec(string);
 
       if (result) {
-        var match       = new #{MatchData}._alloc();
-            match.$data = result;
+        result.$to_s    = match_to_s;
+        result.$inspect = match_inspect;
+        result._real    = result._klass = #{ MatchData };
 
-        #{$~ = `match`};
+        #{$~ = `result`};
       }
       else {
         #{$~ = nil};
@@ -44,10 +45,11 @@ class Regexp < `RegExp`
       var result  = this.exec(pattern);
 
       if (result) {
-        var match   = new #{MatchData}._alloc();
-        match.$data = result;
+        result.$to_s    = match_to_s;
+        result.$inspect = match_inspect;
+        result._real    = result._klass = #{ MatchData };
 
-        return #{$~ = `match`};
+        return #{$~ = `result`};
       }
       else {
         return #{$~ = nil};
@@ -58,4 +60,17 @@ class Regexp < `RegExp`
   def to_s
     `this.source`
   end
+
+  %x{
+    function match_inspect() {
+      return "<#MatchData " + this[0].$inspect() + ">";
+    }
+
+    function match_to_s() {
+      return this[0];
+    }
+  }
 end
+
+class MatchData
+end

data/core/runtime.js

@@ -1,14 +1,35 @@
-// Top level Object scope (used by object and top_self).
-var top_const_alloc     = function(){};
-var top_const_scope     = top_const_alloc.prototype;
-top_const_scope.alloc   = top_const_alloc; 
+// The Opal object that is exposed globally
+var Opal = this.Opal = {};
 
-var Opal = this.Opal = top_const_scope;
+// Very root class
+function BasicObject(){}
 
+// Core Object class
+function Object(){}
+
+// Class' class
+function Class(){}
+
+// Modules are just classes that cannot be instantiated
+var Module = Class;
+
+// the class of nil
+function NilClass(){}
+
+// TopScope is used for inheriting constants from the top scope
+var TopScope = function(){};
+
+// Opal just acts as the top scope
+TopScope.prototype = Opal;
+
+// To inherit scopes
+Opal.alloc  = TopScope;
+
+// This is a useful reference to global object inside ruby files
 Opal.global = this;
 
 // Minify common function calls
-var __hasOwn = Object.prototype.hasOwnProperty;
+var __hasOwn = Opal.hasOwnProperty;
 var __slice  = Opal.slice = Array.prototype.slice;
 
 // Generates unique id for every ruby object
@@ -20,35 +41,80 @@ Opal.cvars = {};
 // Globals table
 Opal.gvars = {};
 
-Opal.klass = function(base, superklass, id, body) {
+// Runtime method used to either define a new class, or re-open an old
+// class. The base may be an object (rather than a class), which is
+// always the case when defining classes in the top level as the top
+// level is just the 'main' Object instance.
+//
+// The given ruby code:
+//
+//     class Foo
+//       42
+//     end
+//
+//     class Bar < Foo
+//       3.142
+//     end
+//
+// Would be compiled to something like:
+//
+//     var __klass = Opal.klass;
+//
+//     __klass(this, null, 'Foo', function() {
+//       return 42;
+//     });
+//
+//     __klass(this, __scope.Foo, 'Bar', function() {
+//       return 3.142;
+//     });
+//
+// @param [RubyObject] base the scope in which to define the class
+// @param [RubyClass] superklass the superklass, may be null
+// @param [String] id the name for the class
+// @param [Function] body the class body
+// @return returns last value from running body
+Opal.klass = function(base, superklass, id, constructor) {
   var klass;
   if (base._isObject) {
     base = base._real;
   }
 
   if (superklass === null) {
-    superklass = RubyObject;
+    superklass = Object;
   }
 
   if (__hasOwn.call(base._scope, id)) {
     klass = base._scope[id];
   }
-  else if (!superklass._klass || !superklass._proto) {
-    klass = bridge_class(superklass, id);
-  }
   else {
-    klass = define_class(base, id, superklass);
+    if (!superklass._methods) {
+      var bridged = superklass;
+      superklass  = Object;
+      klass       = bridge_class(bridged);
+    }
+    else {
+      klass = boot_class(superklass, constructor);
+    }
+
+    klass._name = (base === Object ? id : base._name + '::' + id);
+
+    var const_alloc   = function() {};
+    var const_scope   = const_alloc.prototype = new base._scope.alloc();
+    klass._scope      = const_scope;
+    const_scope.alloc = const_alloc;
+
+    base[id] = base._scope[id] = klass;
+
+    if (superklass.$inherited) {
+      superklass.$inherited(klass);
+    }
   }
 
-  return body.call(klass);
+  return klass;
 };
 
-Opal.sklass = function(shift, body) {
-  var klass = shift.$singleton_class();
-  return body.call(klass);
-}
-
-Opal.module = function(base, id, body) {
+// Define new module (or return existing module)
+Opal.module = function(base, id, constructor) {
   var klass;
   if (base._isObject) {
     base = base._real;
@@ -58,10 +124,8 @@ Opal.module = function(base, id, body) {
     klass = base._scope[id];
   }
   else {
-    klass = boot_module();
-    klass._name = (base === RubyObject ? id : base._name + '::' + id);
-
-    make_metaclass(klass, RubyModule);
+    klass = boot_module(constructor, id);
+    klass._name = (base === Object ? id : base._name + '::' + id);
 
     klass._isModule = true;
     klass.$included_in = [];
@@ -71,268 +135,161 @@ Opal.module = function(base, id, body) {
     klass._scope      = const_scope;
     const_scope.alloc = const_alloc;
 
-    base._scope[id]    = klass;
+    base[id] = base._scope[id]    = klass;
   }
 
-  return body.call(klass);
+  return klass;
 }
 
-/**
-  This function serves two purposes. The first is to allow methods
-  defined in modules to be included into classes that have included
-  them. This is done at the end of a module body by calling this
-  method will all the defined methods. They are then passed onto
-  the includee classes.
-
-  The second purpose is to store an array of all the methods defined
-  directly in this class or module. This makes features such as
-  #methods and #instance_methods work. It is also used internally to
-  create subclasses of Arrays, as an annoyance with javascript is that
-  arrays cannot be subclassed (or they can't without problems arrising
-  with tracking the array length). Therefore, when a new instance of a
-  subclass is created, behind the scenes we copy all the methods from
-  the subclass onto an array prototype.
-
-  If the includee is also included into other modules or classes, then
-  this method will also set up donations for that module. If this is
-  the case, then 'indirect' will be set to true as we don't want those
-  modules/classes to think they had that method set on themselves. This
-  stops `Object` thinking it defines `#sprintf` when it is actually
-  `Kernel` that defines that method. Indirect is false by default when
-  called by generated code in the compiler output.
-
-  @param [RubyClass] klass the class or module that defined methods
-  @param [Array<String>] methods an array of jsid method names defined
-  @param [Boolean] indirect whether this is an indirect method define
-*/
-Opal.donate = function(klass, methods, indirect) {
-  var included_in = klass.$included_in, includee, method,
-      table = klass._proto, dest;
-
-  if (!indirect) {
-    klass._methods = klass._methods.concat(methods);
-  }
-
-  if (included_in) {
-    for (var i = 0, length = included_in.length; i < length; i++) {
-      includee = included_in[i];
-      dest = includee._proto;
-
-      for (var j = 0, jj = methods.length; j < jj; j++) {
-        method = methods[j];
-          dest[method] = table[method];
-      }
-
-      if (includee.$included_in) {
-        Opal.donate(includee, methods, true);
-      }
-    }
-  }
-};
-
-var mid_to_jsid = Opal.mid_to_jsid = function(mid) {
-  if (method_names[mid]) {
-    return method_names[mid];
-  }
-
-  return '$' + mid.replace('!', '$b').replace('?', '$p').replace('=', '$e');
-};
-
-var jsid_to_mid = Opal.jsid_to_mid = function(jsid) {
-  if (reverse_method_names[jsid]) {
-    return reverse_method_names[jsid];
-  }
-
-  jsid = jsid.substr(1); // remove '$'
-
-  return jsid.replace('$b', '!').replace('$p', '?').replace('$e', '=');
+// Convert a ruby method name into a javascript identifier
+var mid_to_jsid = function(mid) {
+  return method_names[mid] ||
+    ('$' + mid.replace('!', '$b').replace('?', '$p').replace('=', '$e'));
 };
 
+// Utility function to raise a "no block given" error
 var no_block_given = function() {
   throw new Error('no block given');
 };
 
-// Boot a base class (makes instances).
-function boot_defclass(superklass) {
-  var cls = function() {
-    this._id = unique_id++;
-  };
+// An array of all classes inside Opal. Used for donating methods from
+// Module and Class.
+var classes = Opal.classes = [];
 
+// Boot a base class (makes instances).
+var boot_defclass = function(id, constructor, superklass) {
   if (superklass) {
     var ctor           = function() {};
         ctor.prototype = superklass.prototype;
 
-    cls.prototype = new ctor();
+    constructor.prototype = new ctor();
   }
 
-  cls.prototype.constructor = cls;
-  cls.prototype._isObject   = true;
+  var prototype = constructor.prototype;
 
-  return cls;
-}
-
-// Boot actual (meta classes) of core objects.
-function boot_makemeta(id, klass, superklass) {
-  var meta = function() {
-    this._id = unique_id++;
-  };
+  prototype.constructor = constructor;
+  prototype._isObject   = true;
+  prototype._klass      = constructor;
+  prototype._real       = constructor;
 
-  var ctor           = function() {};
-      ctor.prototype = superklass.prototype;
+  constructor._included_in  = [];
+  constructor._isClass      = true;
+  constructor._name         = id;
+  constructor._super        = superklass;
+  constructor._methods      = [];
+  constructor._smethods     = [];
+  constructor._isObject     = false;
+  constructor._subclasses   = [];
 
-  meta.prototype = new ctor();
+  constructor._donate = __donate;
+  constructor._sdonate = __sdonate;
 
-  var proto              = meta.prototype;
-      proto.$included_in = [];
-      proto._alloc       = klass;
-      proto._isClass     = true;
-      proto._name        = id;
-      proto._super       = superklass;
-      proto.constructor  = meta;
-      proto._methods     = [];
-      proto._isObject    = false;
+  Opal[id] = constructor;
 
-  var result = new meta();
-  klass.prototype._klass = result;
-  klass.prototype._real  = result;
+  classes.push(constructor);
 
-  result._proto = klass.prototype;
-
-  top_const_scope[id] = result;
-
-  return result;
-}
+  return constructor;
+};
 
 // Create generic class with given superclass.
-function boot_class(superklass) {
-  // instances
-  var cls = function() {
-    this._id = unique_id++;
-  };
-
+var boot_class = function(superklass, constructor) {
   var ctor = function() {};
-      ctor.prototype = superklass._alloc.prototype;
-
-  cls.prototype = new ctor();
-
-  var proto             = cls.prototype;
-      proto.constructor = cls;
-      proto._isObject   = true;
-
-  // class itself
-  var meta = function() {
-    this._id = unique_id++;
-  };
-
-  var mtor = function() {};
-      mtor.prototype = superklass.constructor.prototype;
-
-  meta.prototype = new mtor();
+      ctor.prototype = superklass.prototype;
 
-  proto             = meta.prototype;
-  proto._alloc      = cls;
-  proto._isClass    = true;
-  proto.constructor = meta;
-  proto._super      = superklass;
-  proto._methods    = [];
+  constructor.prototype = new ctor();
+  var prototype = constructor.prototype;
 
-  var result = new meta();
-  cls.prototype._klass = result;
-  cls.prototype._real  = result;
+  prototype._klass      = constructor;
+  prototype._real       = constructor;
+  prototype.constructor = constructor;
 
-  result._proto = cls.prototype;
+  constructor._included_in  = [];
+  constructor._isClass      = true;
+  constructor._super        = superklass;
+  constructor._methods      = [];
+  constructor._isObject     = false;
+  constructor._klass        = Class;
+  constructor._real         = Class;
+  constructor._donate       = __donate
+  constructor._sdonate      = __sdonate;
+  constructor._subclasses   = [];
 
-  return result;
-}
+  constructor.$eqq$ = module_eqq;
 
-function boot_module() {
-  // where module "instance" methods go. will never be instantiated so it
-  // can be a regular object
-  var module_cons = function(){};
-  var module_inst = module_cons.prototype;
+  superklass._subclasses.push(constructor);
 
-  // Module itself
-  var meta = function() {
-    this._id = unique_id++;
-  };
+  var smethods;
 
-  var mtor = function(){};
-  mtor.prototype = RubyModule.constructor.prototype;
-  meta.prototype = new mtor();
+  smethods = superklass._smethods.slice();
 
-  var proto = meta.prototype;
+  constructor._smethods = smethods;
+  for (var i = 0, length = smethods.length; i < length; i++) {
+    var m = smethods[i];
+    constructor[m] = superklass[m];
+  }
 
-  proto._alloc      = module_cons;
-  proto._isModule   = true;
-  proto.constructor = meta;
-  proto._super      = null;
-  proto._methods    = [];
+  classes.push(constructor);
 
-  var module        = new meta();
-  module._proto     = module_inst;
+  return constructor;
+};
 
-  return module;
-}
+var boot_module = function(constructor, id) {
+  var ctor = function() {};
+      ctor.prototype = Module.prototype;
 
-// Make metaclass for the given class
-function make_metaclass(klass, superklass) {
-  if (klass._isClass) {
-    if (klass._isSingleton) {
-      throw RubyException.$new('too much meta: return klass?');
-    }
-    else {
-      var class_id = "#<Class:" + klass._name + ">",
-          meta     = boot_class(superklass);
+  constructor.prototype = new ctor();
+  var prototype = constructor.prototype;
 
-      meta._name = class_id;
-      meta._alloc.prototype = klass.constructor.prototype;
-      meta._proto = meta._alloc.prototype;
-      meta._isSingleton = true;
-      meta._klass = RubyClass;
-      meta._real  = RubyClass;
+  prototype.constructor = constructor;
 
-      klass._klass = meta;
+  constructor._isModule = true;
+  constructor._name     = id;
+  constructor._methods  = [];
+  constructor._smethods = [];
+  constructor._klass    = Module;
+  constructor._donate   = __donate;
+  constructor._sdonate  = function(){};
 
-      meta._scope = klass._scope;
-      meta.__attached__ = klass;
+  classes.push(constructor);
 
-      return meta;
-    }
+  var smethods = constructor._smethods = Module._methods.slice();
+  for (var i = 0, length = smethods.length; i < length; i++) {
+    var m = smethods[i];
+    constructor[m] = Object[m];
   }
-  else {
-    var orig_class = klass._klass,
-        class_id   = "#<Class:#<" + orig_class._name + ":" + orig_class._id + ">>";
 
-    var meta   = boot_class(orig_class);
-    meta._name = class_id;
+  return constructor;
+};
 
-    meta._isSingleton = true;
-    meta._proto  = klass;
-    // FIXME: this should be removed. _proto should always point to this.
-    meta._alloc.prototype = klass;
-    klass._klass = meta;
-    meta.__attached__ = klass;
-    meta._klass = orig_class._real._klass
+var bridge_class = function(constructor) {
+  constructor.prototype._klass = constructor;
+  constructor.prototype._real = constructor;
 
-    return meta;
-  }
-}
+  constructor._included_in  = [];
+  constructor._isClass      = true;
+  constructor._super        = Object;
+  constructor._klass        = Class;
+  constructor._methods      = [];
+  constructor._smethods     = [];
+  constructor._isObject     = false;
+  constructor._subclasses   = [];
 
-function bridge_class(constructor, id) {
-  var klass     = define_class(RubyObject, id, RubyObject),
-      prototype = constructor.prototype;
+  constructor._donate = function(){};
+  constructor._sdonate = __sdonate;
 
-  klass._alloc = constructor;
-  klass._proto = prototype;
+  constructor.$eqq$ = module_eqq;
 
-  bridged_classes.push(klass);
+  var smethods = constructor._smethods = Module._methods.slice();
+  for (var i = 0, length = smethods.length; i < length; i++) {
+    var m = smethods[i];
+    constructor[m] = Object[m];
+  }
 
-  prototype._klass    = klass;
-  prototype._real     = klass;
-  prototype._isObject = true;
+  bridgedClasses.push(constructor);
+  classes.push(constructor);
 
   var allocator = function(initializer) {
-    var result, kls = this, methods = kls._methods, proto = kls._proto;
+    var result, kls = this, methods = kls._methods, proto = kls.prototype;
 
     if (initializer == null) {
       result = new constructor
@@ -341,7 +298,7 @@ function bridge_class(constructor, id) {
       result = new constructor(initializer);
     }
 
-    if (kls === klass) {
+    if (kls === constructor) {
       return result;
     }
 
@@ -356,71 +313,32 @@ function bridge_class(constructor, id) {
     return result;
   };
 
-  klass.constructor.prototype.$allocate = allocator;
+  var table = Object.prototype, methods = Object._methods;
 
-  var donator = RubyObject, table, methods;
-
-  while (donator) {
-    table = donator._proto;
-    methods = donator._methods;
-
-    for (var i = 0, length = methods.length; i < length; i++) {
-      var method = methods[i];
-      prototype[method] = table[method];
-    }
-
-    donator = donator._super;
+  for (var i = 0, length = methods.length; i < length; i++) {
+    var m = methods[i];
+    constructor.prototype[m] = table[m];
   }
 
-  return klass;
-}
+  constructor.$allocate = allocator;
 
-/**
-  Actually define a new class with the name `id`. The superklass is
-  required, and Object is currently the root class. The base is the
-  parent scope of this class. For example, defining a root `Foo`
-  class would have `Object` as the parent. Defining `Foo::Bar` would
-  use `Foo` as the parent.
-
-  @param [RubyClass] base the base class/module for this new class
-  @param [String] id the name for this class
-  @param [RubyClass] superklass the super class
-  @return [RubyClass] returns new class with given attributes
-*/
-function define_class(base, id, superklass) {
-  var klass   = boot_class(superklass);
-  klass._name = (base === RubyObject ? id : base._name + '::' + id);
-
-  make_metaclass(klass, superklass._klass);
-
-  var const_alloc   = function() {};
-  var const_scope   = const_alloc.prototype = new base._scope.alloc();
-  klass._scope      = const_scope;
-  const_scope.alloc = const_alloc;
-
-  base._scope[id] = klass;
-
-  if (superklass.$inherited) {
-    superklass.$inherited(klass);
-  }
+  constructor._smethods.push('$allocate');
 
-  return klass;
-}
+  return constructor;
+};
 
-/**
-  An IClass is a fake class created when a module is included into a
-  class or another module. It is a "copy" of the module that is then
-  injected into the hierarchy so it appears internally that the iclass
-  is the super of the class instead of the old super class. This is
-  actually hidden from the ruby side of things, but allows internal
-  features such as super() etc to work. All useful properties from the
-  module are copied onto this iclass.
-
-  @param [RubyClass] klass the klass which is including the module
-  @param [RubyModule] module the module which is being included
-  @return [RubyIClass] returns newly created iclass
-*/
-function define_iclass(klass, module) {
+// An IClass is a fake class created when a module is included into a
+// class or another module. It is a "copy" of the module that is then
+// injected into the hierarchy so it appears internally that the iclass
+// is the super of the class instead of the old super class. This is
+// actually hidden from the ruby side of things, but allows internal
+// features such as super() etc to work. All useful properties from the
+// module are copied onto this iclass.
+//
+// @param [RubyClass] klass the klass which is including the module
+// @param [RubyModule] module the module which is being included
+// @return [RubyIClass] returns newly created iclass
+var define_iclass = function(klass, module) {
   var iclass = {
     _proto:     module._proto,
     _super:     klass._super,
@@ -433,112 +351,102 @@ function define_iclass(klass, module) {
   klass._super = iclass;
 
   return iclass;
-}
-
-/**
-  This is a map of all file ids to their bodies. The file id is the
-  id used to require a file, and it does not have an extension name.
+};
 
-  @type { String: Function }
-*/
-var factories = Opal.factories = {};
+// Initialization
+// --------------
 
-/**
-  This holds the name of the current file being executed by opal. This
-  gets set in require() below and it allows the file to get the
-  __FILE__ variable. This should never be accessed manually.
+boot_defclass('BasicObject', BasicObject);
+boot_defclass('Object', Object, BasicObject);
+boot_defclass('Class', Class, Object);
 
-  @type {String}
-*/
-Opal.file = "";
+Class.prototype = Function.prototype;
 
-/**
-  Register the body for the given file id name. This will then allow
-  the file to be loaded with require().
+BasicObject._klass = Object._klass = Class._klass = Class;
 
-  @param [String] id the file id
-  @param [Function] body the body representing the file
-*/
-Opal.define = function(id, body) {
-  factories[id] = body;
+Module._donate = function(defined) {
+  // ...
 };
 
-/**
-  Require a specific file by id.
+// Implementation of Module#===
+function module_eqq(object) {
+  if (object == null) {
+    return false;
+  }
 
-  @param [String] id file id to require
-  @return [Boolean] if file has already been required
-*/
-Opal.require = function(id) {
-  var body = factories[id];
+  var search = object._klass;
 
-  if (!body) {
-    throw new Error("No file: '" + id + "'");
-  }
+  while (search) {
+    if (search === this) {
+      return true;
+    }
 
-  if (body._loaded) {
-    return false;
+    search = search._super;
   }
 
-  Opal.file = id;
+  return false;
+}
 
-  body._loaded = true;
-  body.call(Opal.top);
+// Donator for all 'normal' classes and modules
+function __donate(defined, indirect) {
+  var methods = this._methods, included_in = this.$included_in;
 
-  return true;
-};
+  if (!indirect) {
+    this._methods = methods.concat(defined);
+  }
 
-// Initialization
-// --------------
+  if (included_in) {
+    for (var i = 0, length = included_in.length; i < length; i++) {
+      var includee = included_in[i];
+      var dest = includee.prototype;
 
-// The *instances* of core objects
-var BootBasicObject = boot_defclass();
-var BootObject      = boot_defclass(BootBasicObject);
-var BootModule      = boot_defclass(BootObject);
-var BootClass       = boot_defclass(BootModule);
+      for (var j = 0, jj = defined.length; j < jj; j++) {
+        var method = defined[j];
+        dest[method] = this.prototype[method];
+      }
 
-// The *classes' of core objects
-var RubyBasicObject = boot_makemeta('BasicObject', BootBasicObject, BootClass); 
-var RubyObject      = boot_makemeta('Object', BootObject, RubyBasicObject.constructor);
-var RubyModule      = boot_makemeta('Module', BootModule, RubyObject.constructor);
-var RubyClass       = boot_makemeta('Class', BootClass, RubyModule.constructor);
+      if (includee.$included_in) {
+        includee._donate(defined, true);
+      }
+    }
 
-// Fix boot classes to use meta class
-RubyBasicObject._klass = RubyClass;
-RubyObject._klass = RubyClass;
-RubyModule._klass = RubyClass;
-RubyClass._klass = RubyClass;
+  }
+}
+
+// Donator for singleton (class) methods
+function __sdonate(defined) {
+  var smethods = this._smethods, subclasses = this._subclasses;
+
+  this._smethods = smethods.concat(defined);
 
-// fix superclasses
-RubyBasicObject._super = null;
-RubyObject._super = RubyBasicObject;
-RubyModule._super = RubyObject;
-RubyClass._super = RubyModule;
+  for (var i = 0, length = subclasses.length; i < length; i++) {
+    var s = subclasses[i];
 
-var bridged_classes = RubyObject.$included_in = [];
-RubyBasicObject.$included_in = bridged_classes;
+    for (var j = 0, jj = defined.length; j < jj; j++) {
+    }
+  }
+}
 
-RubyObject._scope = RubyBasicObject._scope = top_const_scope;
+var bridgedClasses = Object.$included_in = [];
+BasicObject.$included_in = bridgedClasses;
 
-var module_const_alloc = function(){};
-var module_const_scope = new top_const_alloc();
-module_const_scope.alloc = module_const_alloc;
-RubyModule._scope = module_const_scope;
+BasicObject._scope = Object._scope = Opal;
+Opal.Module = Opal.Class;
+Opal.Kernel = Object;
 
 var class_const_alloc = function(){};
-var class_const_scope = new top_const_alloc();
+var class_const_scope = new TopScope();
 class_const_scope.alloc = class_const_alloc;
-RubyClass._scope = class_const_scope;
+Class._scope = class_const_scope;
 
-RubyObject._proto.toString = function() {
+Object.prototype.toString = function() {
   return this.$to_s();
 };
 
-Opal.top = new RubyObject._alloc();
+Opal.top = new Object;
 
-var RubyNilClass  = define_class(RubyObject, 'NilClass', RubyObject);
-Opal.nil = new RubyNilClass._alloc();
+Opal.klass(Object, Object, 'NilClass', NilClass)
+Opal.nil = new NilClass;
 Opal.nil.call = Opal.nil.apply = no_block_given;
 
-var breaker = Opal.breaker  = new Error('unexpected break');
-    breaker.$t              = function() { throw this; };
+Opal.breaker  = new Error('unexpected break');