opal 1.5.1 → 1.6.0.rc1

data/opal/corelib/kernel.rb

@@ -1,4 +1,4 @@
-# helpers: truthy, coerce_to, respond_to, Opal
+# helpers: truthy, coerce_to, respond_to, Opal, deny_frozen_access, freeze, freeze_props
 # use_strict: true
 
 module ::Kernel
@@ -106,6 +106,12 @@ module ::Kernel
     }
   end
 
+  def caller_locations(*args)
+    caller(*args).map do |loc|
+      ::Thread::Backtrace::Location.new(loc)
+    end
+  end
+
   def class
     `self.$$class`
   end
@@ -126,7 +132,7 @@ module ::Kernel
     %x{
       var i, name, names, length;
 
-      if (other.hasOwnProperty('$$meta')) {
+      if (other.hasOwnProperty('$$meta') && other.$$meta !== null) {
         var other_singleton_class = Opal.get_singleton_class(other);
         var self_singleton_class = Opal.get_singleton_class(self);
         names = Object.getOwnPropertyNames(other_singleton_class.$$prototype);
@@ -154,18 +160,27 @@ module ::Kernel
     }
   end
 
-  def clone(freeze: true)
+  def clone(freeze: nil)
+    unless freeze.nil? || freeze == true || freeze == false
+      raise ArgumentError, "unexpected value for freeze: #{freeze.class}"
+    end
+
     copy = self.class.allocate
 
     copy.copy_instance_variables(self)
     copy.copy_singleton_methods(self)
-    copy.initialize_clone(self)
+    copy.initialize_clone(self, freeze: freeze)
+
+    if freeze == true || (freeze.nil? && frozen?)
+      copy.freeze
+    end
 
     copy
   end
 
-  def initialize_clone(other)
+  def initialize_clone(other, freeze: nil)
     initialize_copy(other)
+    self
   end
 
   def define_singleton_method(name, method = undefined, &block)
@@ -215,6 +230,12 @@ module ::Kernel
 
   def extend(*mods)
     %x{
+      if (mods.length == 0) {
+        #{raise ::ArgumentError, 'wrong number of arguments (given 0, expected 1+)'}
+      }
+
+      $deny_frozen_access(self);
+
       var singleton = #{singleton_class};
 
       for (var i = mods.length - 1; i >= 0; i--) {
@@ -233,6 +254,34 @@ module ::Kernel
     self
   end
 
+  def freeze
+    return self if frozen?
+
+    %x{
+      if (typeof(self) === "object") {
+        $freeze_props(self);
+        return $freeze(self);
+      }
+      return self;
+    }
+  end
+
+  def frozen?
+    %x{
+      switch (typeof(self)) {
+      case "string":
+      case "symbol":
+      case "number":
+      case "boolean":
+        return true;
+      case "object":
+        return (self.$$frozen || false);
+      default:
+        return false;
+      }
+    }
+  end
+
   def gets(*args)
     $stdin.gets(*args)
   end
@@ -294,6 +343,8 @@ module ::Kernel
   end
 
   def instance_variable_set(name, value)
+    `$deny_frozen_access(self)`
+
     name = ::Opal.instance_variable_name!(name)
 
     `self[Opal.ivar(name.substr(1))] = value`

data/opal/corelib/module.rb

@@ -1,4 +1,4 @@
-# helpers: truthy, coerce_to, const_set, Object, return_ivar, assign_ivar, ivar
+# helpers: truthy, coerce_to, const_set, Object, return_ivar, assign_ivar, ivar, deny_frozen_access, freeze, prop
 
 class ::Module
   def self.allocate
@@ -84,6 +84,8 @@ class ::Module
   end
 
   def alias_method(newname, oldname)
+    `$deny_frozen_access(self)`
+
     newname = `$coerce_to(newname, #{::String}, 'to_str')`
     oldname = `$coerce_to(oldname, #{::String}, 'to_str')`
     `Opal.alias(self, newname, oldname)`
@@ -92,6 +94,8 @@ class ::Module
   end
 
   def alias_native(mid, jsid = mid)
+    `$deny_frozen_access(self)`
+
     `Opal.alias_native(self, mid, jsid)`
 
     self
@@ -102,6 +106,8 @@ class ::Module
   end
 
   def append_features(includer)
+    `$deny_frozen_access(includer)`
+
     `Opal.append_features(self, includer)`
     self
   end
@@ -126,6 +132,8 @@ class ::Module
 
   def attr_reader(*names)
     %x{
+      $deny_frozen_access(self);
+
       var proto = self.$$prototype;
 
       for (var i = names.length - 1; i >= 0; i--) {
@@ -150,6 +158,8 @@ class ::Module
 
   def attr_writer(*names)
     %x{
+      $deny_frozen_access(self);
+
       var proto = self.$$prototype;
 
       for (var i = names.length - 1; i >= 0; i--) {
@@ -174,6 +184,8 @@ class ::Module
 
   def autoload(const, path)
     %x{
+      $deny_frozen_access(self);
+
       if (!#{Opal.const_name?(const)}) {
         #{::Kernel.raise ::NameError, "autoload must be constant name: #{const}"}
       }
@@ -221,6 +233,8 @@ class ::Module
   end
 
   def class_variable_set(name, value)
+    `$deny_frozen_access(self)`
+
     name = ::Opal.class_variable_name!(name)
 
     `Opal.class_variable_set(self, name, value)`
@@ -233,6 +247,8 @@ class ::Module
   end
 
   def remove_class_variable(name)
+    `$deny_frozen_access(self)`
+
     name = ::Opal.class_variable_name!(name)
 
     %x{
@@ -341,6 +357,8 @@ class ::Module
   end
 
   def const_set(name, value)
+    `$deny_frozen_access(self)`
+
     name = ::Opal.const_name!(name)
 
     if name !~ ::Opal::CONST_NAME_REGEXP || name.start_with?('::')
@@ -357,6 +375,8 @@ class ::Module
 
   def define_method(name, method = undefined, &block)
     %x{
+      $deny_frozen_access(self);
+
       if (method === undefined && block === nil)
         #{::Kernel.raise ::ArgumentError, 'tried to create a Proc object without a block'}
     }
@@ -389,6 +409,9 @@ class ::Module
             target.$$jsid = name;
             try {
               return target.apply(self, args);
+            } catch(e) {
+              if (e === target.$$brk || e === target.$$ret) return e.$v;
+              throw e;
             } finally {
               target.$$jsid = old_name
             }
@@ -405,10 +428,29 @@ class ::Module
     }
   end
 
+  def freeze
+    # Specialized version of freeze, because the $$base_module property needs to be
+    # accessible despite the frozen status
+
+    return self if frozen?
+
+    %x{
+      if (!self.hasOwnProperty('$$base_module')) { $prop(self, '$$base_module', null); }
+
+      return $freeze(self);
+    }
+  end
+
   def remove_method(*names)
     %x{
-      for (var i = 0, length = names.length; i < length; i++) {
-        Opal.rdef(self, "$" + names[i]);
+      for (var i = 0; i < names.length; i++) {
+        var name = names[i];
+        if (!(typeof name === "string" || name.$$is_string)) {
+          #{raise ::TypeError, "#{name} is not a symbol nor a string"}
+        }
+        $deny_frozen_access(self);
+
+        Opal.rdef(self, "$" + name);
       }
     }
 
@@ -488,6 +530,8 @@ class ::Module
   end
 
   def extend_object(object)
+    `$deny_frozen_access(object)`
+    nil
   end
 
   def method_added(*)
@@ -552,6 +596,8 @@ class ::Module
 
   def module_function(*methods)
     %x{
+      $deny_frozen_access(self);
+
       if (methods.length === 0) {
         self.$$module_function = true;
         return nil;
@@ -623,6 +669,8 @@ class ::Module
 
   def prepend_features(prepender)
     %x{
+      $deny_frozen_access(prepender);
+
       if (!self.$$is_module) {
         #{::Kernel.raise ::TypeError, "wrong argument type #{self.class} (expected Module)"};
       }
@@ -636,6 +684,8 @@ class ::Module
   end
 
   def remove_const(name)
+    `$deny_frozen_access(self)`
+
     `Opal.const_remove(self, name)`
   end
 
@@ -645,7 +695,13 @@ class ::Module
 
   def undef_method(*names)
     %x{
-      for (var i = 0, length = names.length; i < length; i++) {
+      for (var i = 0; i < names.length; i++) {
+        var name = names[i];
+        if (!(typeof name === "string" || name.$$is_string)) {
+          #{raise ::TypeError, "#{name} is not a symbol nor a string"}
+        }
+        $deny_frozen_access(self);
+
         Opal.udef(self, "$" + names[i]);
       }
     }

data/opal/corelib/proc.rb

@@ -18,9 +18,9 @@ class ::Proc < `Function`
         self.$$p = block;
       }
 
-      var result, $brk = self.$$brk;
+      var result, $brk = self.$$brk, $ret = self.$$ret;
 
-      if ($brk) {
+      if ($brk || ($ret && self.$$is_lambda)) {
         try {
           if (self.$$is_lambda) {
             result = self.apply(null, args);
@@ -30,10 +30,13 @@ class ::Proc < `Function`
           }
         } catch (err) {
           if (err === $brk) {
-            return $brk.$v
+            return err.$v;
+          }
+          else if (self.$$is_lambda && err === $ret) {
+            return err.$v;
           }
           else {
-            throw err
+            throw err;
           }
         }
       }
@@ -86,7 +89,7 @@ class ::Proc < `Function`
 
   def source_location
     `if (self.$$is_curried) { return nil; }`
-    nil
+    `self.$$source_location` || nil
   end
 
   def binding

data/opal/corelib/rational.rb

@@ -49,6 +49,7 @@ class ::Rational < ::Numeric
   def initialize(num, den)
     @num = num
     @den = den
+    freeze
   end
 
   def numerator

data/opal/corelib/regexp.rb

@@ -1,4 +1,4 @@
-# helpers: coerce_to
+# helpers: coerce_to, prop, freeze
 
 class ::RegexpError < ::StandardError; end
 
@@ -119,6 +119,20 @@ class ::Regexp < `RegExp`
     match(string) && $~.begin(0)
   end
 
+  def freeze
+    # Specialized version of freeze, because the $$gm and $$g properties need to be set
+    # especially for RegExp.
+
+    return self if frozen?
+
+    %x{
+      if (!self.hasOwnProperty('$$g')) { $prop(self, '$$g', null); }
+      if (!self.hasOwnProperty('$$gm')) { $prop(self, '$$gm', null); }
+
+      return $freeze(self);
+    }
+  end
+
   def inspect
     # Use a regexp to extract the regular expression and the optional mode modifiers from the string.
     # In the regular expression, escape any front slash (not already escaped) with a backslash.