opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/string.rb

@@ -1,15 +1,15 @@
-# helpers: coerce_to, respond_to
+# helpers: coerce_to, respond_to, global_multiline_regexp
 
 require 'corelib/comparable'
 require 'corelib/regexp'
 
-class String < `String`
-  include Comparable
+class ::String < `String`
+  include ::Comparable
 
   %x{
-    Opal.defineProperty(#{self}.$$prototype, '$$is_string', true);
+    Opal.prop(#{self}.$$prototype, '$$is_string', true);
 
-    Opal.defineProperty(#{self}.$$prototype, '$$cast', function(string) {
+    Opal.prop(#{self}.$$prototype, '$$cast', function(string) {
       var klass = this.$$class;
       if (klass.$$constructor === String) {
         return string;
@@ -23,17 +23,15 @@ class String < `String`
     `self.toString()`
   end
 
-  alias object_id __id__
-
   def self.try_convert(what)
-    Opal.coerce_to?(what, String, :to_str)
+    ::Opal.coerce_to?(what, ::String, :to_str)
   end
 
   def self.new(*args)
     %x{
       var str = args[0] || "";
       var opts = args[args.length-1];
-      str = $coerce_to(str, #{String}, 'to_str');
+      str = $coerce_to(str, #{::String}, 'to_str');
       if (opts && opts.$$is_hash) {
         if (opts.$$smap.encoding) str = str.$force_encoding(opts.$$smap.encoding);
       }
@@ -52,7 +50,7 @@ class String < `String`
   end
 
   def %(data)
-    if Array === data
+    if ::Array === data
       format(self, *data)
     else
       format(self, data)
@@ -61,10 +59,10 @@ class String < `String`
 
   def *(count)
     %x{
-      count = $coerce_to(count, #{Integer}, 'to_int');
+      count = $coerce_to(count, #{::Integer}, 'to_int');
 
       if (count < 0) {
-        #{raise ArgumentError, 'negative argument'}
+        #{::Kernel.raise ::ArgumentError, 'negative argument'}
       }
 
       if (count === 0) {
@@ -79,7 +77,7 @@ class String < `String`
       // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat
 
       if (string.length * count >= 1 << 28) {
-        #{raise RangeError, 'multiply count must not overflow maximum string size'}
+        #{::Kernel.raise ::RangeError, 'multiply count must not overflow maximum string size'}
       }
 
       for (;;) {
@@ -98,7 +96,7 @@ class String < `String`
   end
 
   def +(other)
-    other = `$coerce_to(#{other}, #{String}, 'to_str')`
+    other = `$coerce_to(#{other}, #{::String}, 'to_str')`
 
     %x{
       if (other == "" && self.$$class === Opal.String) return #{self};
@@ -141,13 +139,10 @@ class String < `String`
     }
   end
 
-  alias eql? ==
-  alias === ==
-
   def =~(other)
     %x{
       if (other.$$is_string) {
-        #{raise TypeError, 'type mismatch: String given'};
+        #{::Kernel.raise ::TypeError, 'type mismatch: String given'};
       }
 
       return #{other =~ self};
@@ -156,12 +151,13 @@ class String < `String`
 
   def [](index, length = undefined)
     %x{
-      var size = self.length, exclude;
+      var size = self.length, exclude, range;
 
       if (index.$$is_range) {
         exclude = index.excl;
-        length  = $coerce_to(index.end, #{Integer}, 'to_int');
-        index   = $coerce_to(index.begin, #{Integer}, 'to_int');
+        range   = index;
+        length  = index.end === nil ? -1 : $coerce_to(index.end, #{::Integer}, 'to_int');
+        index   = index.begin === nil ? 0 : $coerce_to(index.begin, #{::Integer}, 'to_int');
 
         if (Math.abs(index) > size) {
           return nil;
@@ -175,7 +171,7 @@ class String < `String`
           length += size;
         }
 
-        if (!exclude) {
+        if (!exclude || range.end === nil) {
           length += 1;
         }
 
@@ -191,7 +187,7 @@ class String < `String`
 
       if (index.$$is_string) {
         if (length != null) {
-          #{raise TypeError}
+          #{::Kernel.raise ::TypeError}
         }
         return self.indexOf(index) !== -1 ? self.$$cast(index) : nil;
       }
@@ -205,13 +201,13 @@ class String < `String`
           return nil;
         }
 
-        #{$~ = MatchData.new(`index`, `match`)}
+        #{$~ = ::MatchData.new(`index`, `match`)}
 
         if (length == null) {
           return self.$$cast(match[0]);
         }
 
-        length = $coerce_to(length, #{Integer}, 'to_int');
+        length = $coerce_to(length, #{::Integer}, 'to_int');
 
         if (length < 0 && -length < match.length) {
           return self.$$cast(match[length += match.length]);
@@ -225,7 +221,7 @@ class String < `String`
       }
 
 
-      index = $coerce_to(index, #{Integer}, 'to_int');
+      index = $coerce_to(index, #{::Integer}, 'to_int');
 
       if (index < 0) {
         index += size;
@@ -238,7 +234,7 @@ class String < `String`
         return self.$$cast(self.substr(index, 1));
       }
 
-      length = $coerce_to(length, #{Integer}, 'to_int');
+      length = $coerce_to(length, #{::Integer}, 'to_int');
 
       if (length < 0) {
         return nil;
@@ -252,8 +248,6 @@ class String < `String`
     }
   end
 
-  alias byteslice []
-
   def b
     `new String(#{self})`.force_encoding('binary')
   end
@@ -264,7 +258,7 @@ class String < `String`
 
   def casecmp(other)
     return nil unless other.respond_to?(:to_str)
-    other = `$coerce_to(other, #{String}, 'to_str')`.to_s
+    other = `$coerce_to(other, #{::String}, 'to_str')`.to_s
     %x{
       var ascii_only = /^[\x00-\x7F]*$/;
       if (ascii_only.test(self) && ascii_only.test(other)) {
@@ -287,11 +281,11 @@ class String < `String`
   end
 
   def center(width, padstr = ' ')
-    width  = `$coerce_to(#{width}, #{Integer}, 'to_int')`
-    padstr = `$coerce_to(#{padstr}, #{String}, 'to_str')`.to_s
+    width  = `$coerce_to(#{width}, #{::Integer}, 'to_int')`
+    padstr = `$coerce_to(#{padstr}, #{::String}, 'to_str')`.to_s
 
     if padstr.empty?
-      raise ArgumentError, 'zero width padding'
+      ::Kernel.raise ::ArgumentError, 'zero width padding'
     end
 
     return self if `width <= self.length`
@@ -307,7 +301,7 @@ class String < `String`
   def chomp(separator = $/)
     return self if `separator === nil || self.length === 0`
 
-    separator = Opal.coerce_to!(separator, String, :to_str).to_s
+    separator = ::Opal.coerce_to!(separator, ::String, :to_str).to_s
 
     %x{
       var result;
@@ -370,7 +364,7 @@ class String < `String`
   def count(*sets)
     %x{
       if (sets.length === 0) {
-        #{raise ArgumentError, 'ArgumentError: wrong number of arguments (0 for 1+)'}
+        #{::Kernel.raise ::ArgumentError, 'ArgumentError: wrong number of arguments (0 for 1+)'}
       }
       var char_class = char_class_from_char_sets(sets);
       if (char_class === null) {
@@ -383,7 +377,7 @@ class String < `String`
   def delete(*sets)
     %x{
       if (sets.length === 0) {
-        #{raise ArgumentError, 'ArgumentError: wrong number of arguments (0 for 1+)'}
+        #{::Kernel.raise ::ArgumentError, 'ArgumentError: wrong number of arguments (0 for 1+)'}
       }
       var char_class = char_class_from_char_sets(sets);
       if (char_class === null) {
@@ -396,7 +390,7 @@ class String < `String`
   def delete_prefix(prefix)
     %x{
       if (!prefix.$$is_string) {
-        prefix = $coerce_to(prefix, #{String}, 'to_str');
+        prefix = $coerce_to(prefix, #{::String}, 'to_str');
       }
 
       if (self.slice(0, prefix.length) === prefix) {
@@ -410,7 +404,7 @@ class String < `String`
   def delete_suffix(suffix)
     %x{
       if (!suffix.$$is_string) {
-        suffix = $coerce_to(suffix, #{String}, 'to_str');
+        suffix = $coerce_to(suffix, #{::String}, 'to_str');
       }
 
       if (self.slice(self.length - suffix.length) === suffix) {
@@ -425,8 +419,8 @@ class String < `String`
     `self.$$cast(self.toLowerCase())`
   end
 
-  def each_line(separator = $/, &block)
-    return enum_for :each_line, separator unless block_given?
+  def each_line(separator = $/, chomp: false, &block)
+    return enum_for :each_line, separator, chomp: chomp unless block_given?
 
     %x{
       if (separator === nil) {
@@ -435,15 +429,18 @@ class String < `String`
         return self;
       }
 
-      separator = $coerce_to(separator, #{String}, 'to_str')
+      separator = $coerce_to(separator, #{::String}, 'to_str');
 
-      var a, i, n, length, chomped, trailing, splitted;
+      var a, i, n, length, chomped, trailing, splitted, value;
 
       if (separator.length === 0) {
-        for (a = self.split(/(\n{2,})/), i = 0, n = a.length; i < n; i += 2) {
+        for (a = self.split(/((?:\r?\n){2})(?:(?:\r?\n)*)/), i = 0, n = a.length; i < n; i += 2) {
           if (a[i] || a[i + 1]) {
-            var value = (a[i] || "") + (a[i + 1] || "");
-            Opal.yield1(block, self.$$cast(value));
+            value = (a[i] || "") + (a[i + 1] || "");
+            if (chomp) {
+              value = #{`value`.chomp("\n")};
+            }
+            Opal.yield1(block, value);
           }
         }
 
@@ -455,12 +452,14 @@ class String < `String`
       splitted = chomped.split(separator);
 
       for (i = 0, length = splitted.length; i < length; i++) {
+        value = splitted[i];
         if (i < length - 1 || trailing) {
-          Opal.yield1(block, self.$$cast(splitted[i] + separator));
+          value += separator;
         }
-        else {
-          Opal.yield1(block, self.$$cast(splitted[i]));
+        if (chomp) {
+          value = #{`value`.chomp(separator)};
         }
+        Opal.yield1(block, value);
       }
     }
 
@@ -474,7 +473,7 @@ class String < `String`
   def end_with?(*suffixes)
     %x{
       for (var i = 0, length = suffixes.length; i < length; i++) {
-        var suffix = $coerce_to(suffixes[i], #{String}, 'to_str').$to_s();
+        var suffix = $coerce_to(suffixes[i], #{::String}, 'to_str').$to_s();
 
         if (self.length >= suffix.length &&
             self.substr(self.length - suffix.length, suffix.length) == suffix) {
@@ -486,8 +485,6 @@ class String < `String`
     false
   end
 
-  alias equal? ===
-
   def gsub(pattern, replacement = undefined, &block)
     %x{
       if (replacement === undefined && block === nil) {
@@ -497,9 +494,9 @@ class String < `String`
       var result = '', match_data = nil, index = 0, match, _replacement;
 
       if (pattern.$$is_regexp) {
-        pattern = Opal.global_multiline_regexp(pattern);
+        pattern = $global_multiline_regexp(pattern);
       } else {
-        pattern = $coerce_to(pattern, #{String}, 'to_str');
+        pattern = $coerce_to(pattern, #{::String}, 'to_str');
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
       }
 
@@ -513,7 +510,7 @@ class String < `String`
           break;
         }
 
-        match_data = #{MatchData.new `pattern`, `match`};
+        match_data = #{::MatchData.new `pattern`, `match`};
 
         if (replacement === undefined) {
           lastIndex = pattern.lastIndex;
@@ -525,7 +522,7 @@ class String < `String`
         }
         else {
           if (!replacement.$$is_string) {
-            replacement = $coerce_to(replacement, #{String}, 'to_str');
+            replacement = $coerce_to(replacement, #{::String}, 'to_str');
           }
           _replacement = replacement.replace(/([\\]+)([0-9+&`'])/g, function (original, slashes, command) {
             if (slashes.length % 2 === 0) {
@@ -573,7 +570,7 @@ class String < `String`
   def include?(other)
     %x{
       if (!other.$$is_string) {
-        other = $coerce_to(other, #{String}, 'to_str');
+        other = $coerce_to(other, #{::String}, 'to_str');
       }
       return self.indexOf(other) !== -1;
     }
@@ -588,7 +585,7 @@ class String < `String`
       if (offset === undefined) {
         offset = 0;
       } else {
-        offset = $coerce_to(offset, #{Integer}, 'to_int');
+        offset = $coerce_to(offset, #{::Integer}, 'to_int');
         if (offset < 0) {
           offset += self.length;
           if (offset < 0) {
@@ -598,7 +595,7 @@ class String < `String`
       }
 
       if (search.$$is_regexp) {
-        regex = Opal.global_multiline_regexp(search);
+        regex = $global_multiline_regexp(search);
         while (true) {
           match = regex.exec(self);
           if (match === null) {
@@ -607,14 +604,14 @@ class String < `String`
             break;
           }
           if (match.index >= offset) {
-            #{$~ = MatchData.new(`regex`, `match`)}
+            #{$~ = ::MatchData.new(`regex`, `match`)}
             index = match.index;
             break;
           }
           regex.lastIndex = match.index + 1;
         }
       } else {
-        search = $coerce_to(search, #{String}, 'to_str');
+        search = $coerce_to(search, #{::String}, 'to_str');
         if (search.length === 0 && offset > self.length) {
           index = -1;
         } else {
@@ -660,17 +657,17 @@ class String < `String`
     `self.toString()`
   end
 
-  def lines(separator = $/, &block)
-    e = each_line(separator, &block)
+  def lines(separator = $/, chomp: false, &block)
+    e = each_line(separator, chomp: chomp, &block)
     block ? self : e.to_a
   end
 
   def ljust(width, padstr = ' ')
-    width  = `$coerce_to(#{width}, #{Integer}, 'to_int')`
-    padstr = `$coerce_to(#{padstr}, #{String}, 'to_str')`.to_s
+    width  = `$coerce_to(#{width}, #{::Integer}, 'to_int')`
+    padstr = `$coerce_to(#{padstr}, #{::String}, 'to_str')`.to_s
 
     if padstr.empty?
-      raise ArgumentError, 'zero width padding'
+      ::Kernel.raise ::ArgumentError, 'zero width padding'
     end
 
     return self if `width <= self.length`
@@ -690,7 +687,7 @@ class String < `String`
   end
 
   def lstrip
-    `self.replace(/^\s*/, '')`
+    `self.replace(/^[\u0000\s]*/, '')`
   end
 
   def ascii_only?
@@ -703,11 +700,11 @@ class String < `String`
 
   def match(pattern, pos = undefined, &block)
     if String === pattern || pattern.respond_to?(:to_str)
-      pattern = Regexp.new(pattern.to_str)
+      pattern = ::Regexp.new(pattern.to_str)
     end
 
-    unless Regexp === pattern
-      raise TypeError, "wrong argument type #{pattern.class} (expected Regexp)"
+    unless ::Regexp === pattern
+      ::Kernel.raise ::TypeError, "wrong argument type #{pattern.class} (expected Regexp)"
     end
 
     pattern.match(self, pos, &block)
@@ -715,11 +712,11 @@ class String < `String`
 
   def match?(pattern, pos = undefined)
     if String === pattern || pattern.respond_to?(:to_str)
-      pattern = Regexp.new(pattern.to_str)
+      pattern = ::Regexp.new(pattern.to_str)
     end
 
-    unless Regexp === pattern
-      raise TypeError, "wrong argument type #{pattern.class} (expected Regexp)"
+    unless ::Regexp === pattern
+      ::Kernel.raise ::TypeError, "wrong argument type #{pattern.class} (expected Regexp)"
     end
 
     pattern.match?(self, pos)
@@ -858,12 +855,12 @@ class String < `String`
         if (m === null) {
           i = -1;
         } else {
-          #{MatchData.new `sep`, `m`};
+          #{::MatchData.new `sep`, `m`};
           sep = m[0];
           i = m.index;
         }
       } else {
-        sep = $coerce_to(sep, #{String}, 'to_str');
+        sep = $coerce_to(sep, #{::String}, 'to_str');
         i = self.indexOf(sep);
       }
 
@@ -890,7 +887,7 @@ class String < `String`
       if (offset === undefined) {
         offset = self.length;
       } else {
-        offset = $coerce_to(offset, #{Integer}, 'to_int');
+        offset = $coerce_to(offset, #{::Integer}, 'to_int');
         if (offset < 0) {
           offset += self.length;
           if (offset < 0) {
@@ -901,7 +898,7 @@ class String < `String`
 
       if (search.$$is_regexp) {
         m = null;
-        r = Opal.global_multiline_regexp(search);
+        r = $global_multiline_regexp(search);
         while (true) {
           _m = r.exec(self);
           if (_m === null || _m.index > offset) {
@@ -914,11 +911,11 @@ class String < `String`
           #{$~ = nil}
           i = -1;
         } else {
-          #{MatchData.new `r`, `m`};
+          #{::MatchData.new `r`, `m`};
           i = m.index;
         }
       } else {
-        search = $coerce_to(search, #{String}, 'to_str');
+        search = $coerce_to(search, #{::String}, 'to_str');
         i = self.lastIndexOf(search, offset);
       }
 
@@ -927,11 +924,11 @@ class String < `String`
   end
 
   def rjust(width, padstr = ' ')
-    width  = `$coerce_to(#{width}, #{Integer}, 'to_int')`
-    padstr = `$coerce_to(#{padstr}, #{String}, 'to_str')`.to_s
+    width  = `$coerce_to(#{width}, #{::Integer}, 'to_int')`
+    padstr = `$coerce_to(#{padstr}, #{::String}, 'to_str')`.to_s
 
     if padstr.empty?
-      raise ArgumentError, 'zero width padding'
+      ::Kernel.raise ::ArgumentError, 'zero width padding'
     end
 
     return self if `width <= self.length`
@@ -952,7 +949,7 @@ class String < `String`
 
       if (sep.$$is_regexp) {
         m = null;
-        r = Opal.global_multiline_regexp(sep);
+        r = $global_multiline_regexp(sep);
 
         while (true) {
           _m = r.exec(self);
@@ -966,13 +963,13 @@ class String < `String`
         if (m === null) {
           i = -1;
         } else {
-          #{MatchData.new `r`, `m`};
+          #{::MatchData.new `r`, `m`};
           sep = m[0];
           i = m.index;
         }
 
       } else {
-        sep = $coerce_to(sep, #{String}, 'to_str');
+        sep = $coerce_to(sep, #{::String}, 'to_str');
         i = self.lastIndexOf(sep);
       }
 
@@ -999,14 +996,14 @@ class String < `String`
           match;
 
       if (pattern.$$is_regexp) {
-        pattern = Opal.global_multiline_regexp(pattern);
+        pattern = $global_multiline_regexp(pattern);
       } else {
-        pattern = $coerce_to(pattern, #{String}, 'to_str');
+        pattern = $coerce_to(pattern, #{::String}, 'to_str');
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
       }
 
       while ((match = pattern.exec(self)) != null) {
-        match_data = #{MatchData.new `pattern`, `match`};
+        match_data = #{::MatchData.new `pattern`, `match`, no_matchdata: no_matchdata};
         if (block === nil) {
           match.length == 1 ? result.push(match[0]) : result.push(#{`match_data`.captures});
         } else {
@@ -1023,7 +1020,14 @@ class String < `String`
     }
   end
 
-  alias slice []
+  # We redefine this method on String, as kernel.rb is in strict mode
+  # so that things like Boolean don't get boxed. For String though -
+  # we either need to box it to define properties on it, or run it in
+  # non-strict mode. This is a mess and we need to come back to it
+  # at a later time.
+  def singleton_class
+    `Opal.get_singleton_class(self)`
+  end
 
   def split(pattern = undefined, limit = undefined)
     %x{
@@ -1034,7 +1038,7 @@ class String < `String`
       if (limit === undefined) {
         limit = 0;
       } else {
-        limit = #{Opal.coerce_to!(limit, Integer, :to_int)};
+        limit = #{::Opal.coerce_to!(limit, ::Integer, :to_int)};
         if (limit === 1) {
           return [self];
         }
@@ -1051,9 +1055,9 @@ class String < `String`
           i, ii;
 
       if (pattern.$$is_regexp) {
-        pattern = Opal.global_multiline_regexp(pattern);
+        pattern = $global_multiline_regexp(pattern);
       } else {
-        pattern = $coerce_to(pattern, #{String}, 'to_str').$to_s();
+        pattern = $coerce_to(pattern, #{::String}, 'to_str').$to_s();
         if (pattern === ' ') {
           pattern = /\s+/gm;
           string = string.replace(/^\s+/, '');
@@ -1145,13 +1149,13 @@ class String < `String`
           var match = regexp.exec(self);
 
           if (match != null && match.index === 0) {
-            #{$~ = MatchData.new(`regexp`, `match`)};
+            #{$~ = ::MatchData.new(`regexp`, `match`)};
             return true;
           } else {
             #{$~ = nil}
           }
         } else {
-          var prefix = $coerce_to(prefixes[i], #{String}, 'to_str').$to_s();
+          var prefix = $coerce_to(prefixes[i], #{::String}, 'to_str').$to_s();
 
           if (self.indexOf(prefix) === 0) {
             return true;
@@ -1164,13 +1168,13 @@ class String < `String`
   end
 
   def strip
-    `self.replace(/^\s*/, '').replace(/[\s\u0000]*$/, '')`
+    `self.replace(/^[\s\u0000]*|[\s\u0000]*$/g, '')`
   end
 
   def sub(pattern, replacement = undefined, &block)
     %x{
       if (!pattern.$$is_regexp) {
-        pattern = $coerce_to(pattern, #{String}, 'to_str');
+        pattern = $coerce_to(pattern, #{::String}, 'to_str');
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
       }
 
@@ -1180,12 +1184,12 @@ class String < `String`
         #{$~ = nil}
         result = self.toString();
       } else {
-        #{MatchData.new `pattern`, `match`}
+        #{::MatchData.new `pattern`, `match`}
 
         if (replacement === undefined) {
 
           if (block === nil) {
-            #{raise ArgumentError, 'wrong number of arguments (1 for 2)'}
+            #{::Kernel.raise ::ArgumentError, 'wrong number of arguments (1 for 2)'}
           }
           result = self.slice(0, match.index) + block(match[0]) + self.slice(match.index + match[0].length);
 
@@ -1195,7 +1199,7 @@ class String < `String`
 
         } else {
 
-          replacement = $coerce_to(replacement, #{String}, 'to_str');
+          replacement = $coerce_to(replacement, #{::String}, 'to_str');
 
           replacement = replacement.replace(/([\\]+)([0-9+&`'])/g, function (original, slashes, command) {
             if (slashes.length % 2 === 0) {
@@ -1224,11 +1228,9 @@ class String < `String`
     }
   end
 
-  alias succ next
-
   def sum(n = 16)
     %x{
-      n = $coerce_to(n, #{Integer}, 'to_int');
+      n = $coerce_to(n, #{::Integer}, 'to_int');
 
       var result = 0,
           length = self.length,
@@ -1281,10 +1283,10 @@ class String < `String`
     %x{
       var result,
           string = self.toLowerCase(),
-          radix = $coerce_to(base, #{Integer}, 'to_int');
+          radix = $coerce_to(base, #{::Integer}, 'to_int');
 
       if (radix === 1 || radix < 0 || radix > 36) {
-        #{raise ArgumentError, "invalid radix #{`radix`}"}
+        #{::Kernel.raise ::ArgumentError, "invalid radix #{`radix`}"}
       }
 
       if (/^\s*_/.test(string)) {
@@ -1339,10 +1341,10 @@ class String < `String`
   def to_proc
     method_name = '$' + `self.valueOf()`
 
-    proc do |*args, &block|
+    ::Kernel.proc do |*args, &block|
       %x{
         if (args.length === 0) {
-          #{raise ArgumentError, 'no receiver given'}
+          #{::Kernel.raise ::ArgumentError, 'no receiver given'}
         }
 
         var recv = args[0];
@@ -1372,14 +1374,10 @@ class String < `String`
     `self.toString()`
   end
 
-  alias to_str to_s
-
-  alias to_sym intern
-
   def tr(from, to)
     %x{
-      from = $coerce_to(from, #{String}, 'to_str').$to_s();
-      to = $coerce_to(to, #{String}, 'to_str').$to_s();
+      from = $coerce_to(from, #{::String}, 'to_str').$to_s();
+      to = $coerce_to(to, #{::String}, 'to_str').$to_s();
 
       if (from.length == 0 || from === to) {
         return self;
@@ -1426,7 +1424,7 @@ class String < `String`
           start = last_from.charCodeAt(0);
           end = ch.charCodeAt(0);
           if (start > end) {
-            #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+            #{::Kernel.raise ::ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
           }
           for (c = start + 1; c < end; c++) {
             from_chars_expanded.push(String.fromCharCode(c));
@@ -1475,7 +1473,7 @@ class String < `String`
               start = last_to.charCodeAt(0);
               end = ch.charCodeAt(0);
               if (start > end) {
-                #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+                #{::Kernel.raise ::ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
               }
               for (c = start + 1; c < end; c++) {
                 to_chars_expanded.push(String.fromCharCode(c));
@@ -1523,8 +1521,8 @@ class String < `String`
 
   def tr_s(from, to)
     %x{
-      from = $coerce_to(from, #{String}, 'to_str').$to_s();
-      to = $coerce_to(to, #{String}, 'to_str').$to_s();
+      from = $coerce_to(from, #{::String}, 'to_str').$to_s();
+      to = $coerce_to(to, #{::String}, 'to_str').$to_s();
 
       if (from.length == 0) {
         return self;
@@ -1571,7 +1569,7 @@ class String < `String`
           start = last_from.charCodeAt(0);
           end = ch.charCodeAt(0);
           if (start > end) {
-            #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+            #{::Kernel.raise ::ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
           }
           for (c = start + 1; c < end; c++) {
             from_chars_expanded.push(String.fromCharCode(c));
@@ -1620,7 +1618,7 @@ class String < `String`
               start = last_from.charCodeAt(0);
               end = ch.charCodeAt(0);
               if (start > end) {
-                #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+                #{::Kernel.raise ::ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
               }
               for (c = start + 1; c < end; c++) {
                 to_chars_expanded.push(String.fromCharCode(c));
@@ -1693,7 +1691,7 @@ class String < `String`
     %x{
       var a, b, s = self.toString();
 
-      stop = $coerce_to(stop, #{String}, 'to_str');
+      stop = $coerce_to(stop, #{::String}, 'to_str');
 
       if (s.length === 1 && stop.length === 1) {
 
@@ -1758,7 +1756,7 @@ class String < `String`
             char_code_from = set.charCodeAt(i - 1);
             char_code_upto = set.charCodeAt(i + 1);
             if (char_code_from > char_code_upto) {
-              #{raise ArgumentError, "invalid range \"#{`char_code_from`}-#{`char_code_upto`}\" in string transliteration"}
+              #{::Kernel.raise ::ArgumentError, "invalid range \"#{`char_code_from`}-#{`char_code_upto`}\" in string transliteration"}
             }
             for (char_code = char_code_from + 1; char_code < char_code_upto + 1; char_code++) {
               result += String.fromCharCode(char_code);
@@ -1794,7 +1792,7 @@ class String < `String`
           neg_intersection = '';
 
       for (i = 0, len = sets.length; i < len; i++) {
-        set = $coerce_to(sets[i], #{String}, 'to_str');
+        set = $coerce_to(sets[i], #{::String}, 'to_str');
         neg = (set.charAt(0) === '^' && set.length > 1);
         set = explode_sequences_in_character_set(neg ? set.slice(1) : set);
         if (neg) {
@@ -1817,11 +1815,11 @@ class String < `String`
       }
 
       if (pos_intersection.length > 0) {
-        return '[' + #{Regexp.escape(`pos_intersection`)} + ']';
+        return '[' + #{::Regexp.escape(`pos_intersection`)} + ']';
       }
 
       if (neg_intersection.length > 0) {
-        return '[^' + #{Regexp.escape(`neg_intersection`)} + ']';
+        return '[^' + #{::Regexp.escape(`neg_intersection`)} + ']';
       }
 
       return null;
@@ -1837,7 +1835,7 @@ class String < `String`
   end
 
   def unicode_normalize(form = :nfc)
-    raise ArgumentError, "Invalid normalization form #{form}" unless %i[nfc nfd nfkc nfkd].include?(form)
+    ::Kernel.raise ::ArgumentError, "Invalid normalization form #{form}" unless %i[nfc nfd nfkc nfkd].include?(form)
     `self.normalize(#{form.upcase})`
   end
 
@@ -1846,11 +1844,11 @@ class String < `String`
   end
 
   def unpack(format)
-    raise "To use String#unpack, you must first require 'corelib/string/unpack'."
+    ::Kernel.raise "To use String#unpack, you must first require 'corelib/string/unpack'."
   end
 
   def unpack1(format)
-    raise "To use String#unpack1, you must first require 'corelib/string/unpack'."
+    ::Kernel.raise "To use String#unpack1, you must first require 'corelib/string/unpack'."
   end
 
   def freeze
@@ -1861,8 +1859,6 @@ class String < `String`
     }
   end
 
-  alias +@ dup
-
   def -@
     %x{
       if (typeof self === 'string') return self;
@@ -1876,7 +1872,18 @@ class String < `String`
     `typeof self === 'string' || self.$$frozen === true`
   end
 
-  Opal.pristine self, :initialize
+  alias +@ dup
+  alias === ==
+  alias byteslice []
+  alias eql? ==
+  alias equal? ===
+  alias object_id __id__
+  alias slice []
+  alias succ next
+  alias to_str to_s
+  alias to_sym intern
+
+  ::Opal.pristine self, :initialize
 end
 
 Symbol = String