Merge branch 'master' into truffle-head

jruby · Jun 29, 2016 · fafbe32 · fafbe32
2 parents 4c69fe4 + 3ddc21c
commit fafbe32
Showing 61 changed files with 1,131 additions and 564 deletions.
diff --git a/core/src/main/java/org/jruby/RubyThread.java b/core/src/main/java/org/jruby/RubyThread.java
@@ -1768,14 +1768,6 @@ public boolean select(Channel channel, OpenFile fptr, int ops, long timeout) {
                     // so that we can ensure one failing does not affect the others
                     // running.
 
-                    // clean up the key in the selector
-                    try {
-                        if (key != null) key.cancel();
-                        if (currentSelector != null) currentSelector.selectNow();
-                    } catch (Exception e) {
-                        // ignore
-                    }
-
                     // shut down and null out the selector
                     try {
                         if (currentSelector != null) {

diff --git a/core/src/main/java/org/jruby/util/io/SelectExecutor.java b/core/src/main/java/org/jruby/util/io/SelectExecutor.java
@@ -50,17 +50,12 @@ IRubyObject selectCall(ThreadContext context) throws IOException {
     }
 
     IRubyObject selectEnd(ThreadContext context) throws IOException {
-        fdTerm(readKeyList);
-        fdTerm(writeKeyList);
-        fdTerm(errorKeyList);
-
         if (selectors != null) {
             for (int i = 0; i < selectors.size(); i++) {
                 Selector selector = selectors.get(i);
                 // if it is a JDK selector, cache it
                 if (selector.provider() == SelectorProvider.provider()) {
-                    // clear cancelled keys (with selectNow) and return to pool
-                    selector.selectNow();
+                    // return to pool
                     context.runtime.getSelectorPool().put(selector);
                 } else {
                     selector.close();
@@ -277,20 +272,6 @@ private boolean fdIsSet(List<SelectionKey> fds, ChannelFD fd, int operations) {
         return false;
     }
 
-    private void fdTerm(List<SelectionKey> keys) {
-        if (keys == null) return;
-        for (int i = 0; i < keys.size(); i++) {
-            SelectionKey key = keys.get(i);
-            killKey(key);
-        }
-    }
-
-    private void killKey(SelectionKey key) {
-        try {
-            if (key.isValid()) key.cancel();
-        } catch (Exception e) {}
-    }
-
     private SelectionKey trySelectRead(ThreadContext context, ChannelFD fd) throws IOException {
         if (fd.chSelect != null) {
             return registerSelect(getSelector(context, fd.chSelect), fd, fd.chSelect, READ_ACCEPT_OPS);

diff --git a/core/src/main/java/org/jruby/util/io/SelectorPool.java b/core/src/main/java/org/jruby/util/io/SelectorPool.java
@@ -30,6 +30,7 @@
 package org.jruby.util.io;
 
 import java.io.IOException;
+import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.util.ArrayList;
 import java.util.List;
@@ -38,6 +39,7 @@
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.Map;
+import java.util.Iterator;
 
 /**
  * This is a simple implementation of a hard-referenced java.nio.channels.Selector
@@ -82,7 +84,16 @@ public synchronized Selector get(SelectorProvider provider) throws IOException{
      *
      * @param selector the selector to put back
      */
-    public synchronized void put(Selector selector) {
+    public void put(Selector selector) {
+        Iterator<SelectionKey> key_iterator = selector.keys().iterator();
+        while(key_iterator.hasNext()) key_iterator.next().cancel();
+
+        try {
+            selector.selectNow();
+        } catch (Exception e) {
+            //ignore
+        }
+
         returnToPool(selector);
     }
 
@@ -130,7 +141,7 @@ private Selector retrieveFromPool(SelectorProvider provider) throws IOException
         return selector;
     }
 
-    private void returnToPool(Selector selector) {
+    private synchronized void returnToPool(Selector selector) {
         openSelectors.remove(selector);
         if (selector.isOpen()) {
             SelectorProvider provider = selector.provider();

diff --git a/lib/ruby/stdlib/rubygems.rb b/lib/ruby/stdlib/rubygems.rb
@@ -10,7 +10,7 @@
 require 'thread'
 
 module Gem
-  VERSION = '2.6.4'
+  VERSION = '2.6.6'
 end
 
 # Must be first since it unloads the prelude from 1.9.2
@@ -154,6 +154,26 @@ module Gem
     specifications/default
   ]
 
+  ##
+  # Exception classes used in a Gem.read_binary +rescue+ statement. Not all of
+  # these are defined in Ruby 1.8.7, hence the need for this convoluted setup.
+
+  READ_BINARY_ERRORS = begin
+    read_binary_errors = [Errno::EACCES]
+    read_binary_errors << Errno::ENOTSUP if Errno.const_defined?(:ENOTSUP)
+    read_binary_errors
+  end.freeze
+
+  ##
+  # Exception classes used in Gem.write_binary +rescue+ statement. Not all of
+  # these are defined in Ruby 1.8.7.
+
+  WRITE_BINARY_ERRORS = begin
+    write_binary_errors = []
+    write_binary_errors << Errno::ENOTSUP if Errno.const_defined?(:ENOTSUP)
+    write_binary_errors
+  end.freeze
+
   @@win_platform = nil
 
   @configuration = nil
@@ -829,7 +849,7 @@ def self.read_binary(path)
       f.flock(File::LOCK_EX)
       f.read
     end
-  rescue Errno::EACCES
+  rescue *READ_BINARY_ERRORS
     open path, 'rb' do |f|
       f.read
     end
@@ -843,6 +863,26 @@ def self.read_binary(path)
     end
   end
 
+  ##
+  # Safely write a file in binary mode on all platforms.
+  def self.write_binary(path, data)
+    open(path, 'wb') do |io|
+      begin
+        io.flock(File::LOCK_EX)
+      rescue *WRITE_BINARY_ERRORS
+      end
+      io.write data
+    end
+  rescue Errno::ENOLCK # NFS
+    if Thread.main != Thread.current
+      raise
+    else
+      open(path, 'wb') do |io|
+        io.write data
+      end
+    end
+  end
+
   ##
   # The path to the running Ruby interpreter.
 

diff --git a/lib/ruby/stdlib/rubygems/commands/update_command.rb b/lib/ruby/stdlib/rubygems/commands/update_command.rb
@@ -241,7 +241,7 @@ def update_rubygems
     update_gem 'rubygems-update', version
 
     installed_gems = Gem::Specification.find_all_by_name 'rubygems-update', requirement
-    version        = installed_gems.last.version
+    version        = installed_gems.first.version
 
     install_rubygems version
   end

diff --git a/lib/ruby/stdlib/rubygems/config_file.rb b/lib/ruby/stdlib/rubygems/config_file.rb
@@ -54,7 +54,7 @@ class Gem::ConfigFile
   # For Ruby implementers to set configuration defaults.  Set in
   # rubygems/defaults/#{RUBY_ENGINE}.rb
 
-  PLATFORM_DEFAULTS = {}
+  PLATFORM_DEFAULTS = Gem.platform_defaults
 
   # :stopdoc:
 

diff --git a/lib/ruby/stdlib/rubygems/defaults.rb b/lib/ruby/stdlib/rubygems/defaults.rb
@@ -175,4 +175,22 @@ def self.vendor_dir # :nodoc:
               RbConfig::CONFIG['ruby_version']
   end
 
+  ##
+  # Default options for gem commands.
+  #
+  # The options here should be structured as an array of string "gem"
+  # command names as keys and a string of the default options as values.
+  #
+  # Example:
+  #
+  # def self.platform_defaults
+  #   {
+  #       'install' => '--no-rdoc --no-ri --env-shebang',
+  #       'update' => '--no-rdoc --no-ri --env-shebang'
+  #   }
+  # end
+
+  def self.platform_defaults
+    {}
+  end
 end
diff --git a/lib/ruby/stdlib/rubygems/defaults/jruby.rb b/lib/ruby/stdlib/rubygems/defaults/jruby.rb
@@ -1,12 +1,8 @@
-require 'rubygems/config_file'
 require 'rbconfig'
 require 'jruby/util'
 
 module Gem
 
-  ConfigFile::PLATFORM_DEFAULTS['install'] = '--no-rdoc --no-ri --env-shebang'
-  ConfigFile::PLATFORM_DEFAULTS['update']  = '--no-rdoc --no-ri --env-shebang'
-
   class << self
     alias_method :original_ruby, :ruby
     def ruby
@@ -22,6 +18,13 @@ def jarred_path?(p)
     end
   end
 
+  def self.platform_defaults
+    return {
+        'install' => '--no-rdoc --no-ri --env-shebang',
+        'update' => '--no-rdoc --no-ri --env-shebang'
+    }
+  end
+
   # Default home directory path to be used if an alternate value is not
   # specified in the environment.
   #

diff --git a/lib/ruby/stdlib/rubygems/installer.rb b/lib/ruby/stdlib/rubygems/installer.rb
@@ -284,6 +284,7 @@ def install
 
     # Completely remove any previous gem files
     FileUtils.rm_rf gem_dir
+    FileUtils.rm_rf spec.extension_dir
 
     FileUtils.mkdir_p gem_dir
 

diff --git a/lib/ruby/stdlib/rubygems/package.rb b/lib/ruby/stdlib/rubygems/package.rb
@@ -211,7 +211,9 @@ def add_files tar # :nodoc:
       stat = File.lstat file
 
       if stat.symlink?
-        tar.add_symlink file, File.readlink(file), stat.mode
+        relative_dir = File.dirname(file).sub("#{Dir.pwd}/", '')
+        target_path = File.join(relative_dir, File.readlink(file))
+        tar.add_symlink file, target_path, stat.mode
       end
 
       next unless stat.file?

diff --git a/lib/ruby/stdlib/rubygems/package/tar_writer.rb b/lib/ruby/stdlib/rubygems/package/tar_writer.rb
@@ -310,27 +310,21 @@ def mkdir(name, mode)
   # Splits +name+ into a name and prefix that can fit in the TarHeader
 
   def split_name(name) # :nodoc:
-    if name.bytesize > 256
+    if name.bytesize > 256 then
       raise Gem::Package::TooLongFileName.new("File \"#{name}\" has a too long path (should be 256 or less)")
     end
 
-    if name.bytesize <= 100 then
-      prefix = ""
-    else
-      parts = name.split(/\//)
-      newname = parts.pop
-      nxt = ""
-
-      loop do
-        nxt = parts.pop
-        break if newname.bytesize + 1 + nxt.bytesize > 100
-        newname = nxt + "/" + newname
+    prefix = ''
+    if name.bytesize > 100 then
+      parts = name.split('/', -1) # parts are never empty here
+      name = parts.pop            # initially empty for names with a trailing slash ("foo/.../bar/")
+      prefix = parts.join('/')    # if empty, then it's impossible to split (parts is empty too)
+      while !parts.empty? && (prefix.bytesize > 155 || name.empty?)
+        name = parts.pop + '/' + name
+        prefix = parts.join('/')
       end
 
-      prefix = (parts + [nxt]).join "/"
-      name = newname
-
-      if name.bytesize > 100
+      if name.bytesize > 100 or prefix.empty? then
         raise Gem::Package::TooLongFileName.new("File \"#{prefix}/#{name}\" has a too long name (should be 100 or less)")
       end
 

diff --git a/lib/ruby/stdlib/rubygems/remote_fetcher.rb b/lib/ruby/stdlib/rubygems/remote_fetcher.rb
@@ -328,20 +328,7 @@ def cache_update_path uri, path = nil, update = true
     end
 
     if update and path
-      begin
-        open(path, 'wb') do |io|
-          io.flock(File::LOCK_EX)
-          io.write data
-        end
-      rescue Errno::ENOLCK # NFS
-        if Thread.main != Thread.current
-          raise
-        else
-          open(path, 'wb') do |io|
-            io.write data
-          end
-        end
-      end
+      Gem.write_binary(path, data)
     end
 
     data
@@ -427,4 +414,3 @@ def pools_for proxy
     end
   end
 end
-
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/delegates/resolution_state.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/delegates/resolution_state.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Gem::Resolver::Molinillo
+  # @!visibility private
+  module Delegates
+    # Delegates all {Gem::Resolver::Molinillo::ResolutionState} methods to a `#state` property.
+    module ResolutionState
+      # (see Gem::Resolver::Molinillo::ResolutionState#name)
+      def name
+        current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty
+        current_state.name
+      end
+
+      # (see Gem::Resolver::Molinillo::ResolutionState#requirements)
+      def requirements
+        current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty
+        current_state.requirements
+      end
+
+      # (see Gem::Resolver::Molinillo::ResolutionState#activated)
+      def activated
+        current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty
+        current_state.activated
+      end
+
+      # (see Gem::Resolver::Molinillo::ResolutionState#requirement)
+      def requirement
+        current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty
+        current_state.requirement
+      end
+
+      # (see Gem::Resolver::Molinillo::ResolutionState#possibilities)
+      def possibilities
+        current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty
+        current_state.possibilities
+      end
+
+      # (see Gem::Resolver::Molinillo::ResolutionState#depth)
+      def depth
+        current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty
+        current_state.depth
+      end
+
+      # (see Gem::Resolver::Molinillo::ResolutionState#conflicts)
+      def conflicts
+        current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty
+        current_state.conflicts
+      end
+    end
+  end
+end
diff --git a/...ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/delegates/specification_provider.rb b/...ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/delegates/specification_provider.rb
@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module Gem::Resolver::Molinillo
+  module Delegates
+    # Delegates all {Gem::Resolver::Molinillo::SpecificationProvider} methods to a
+    # `#specification_provider` property.
+    module SpecificationProvider
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#search_for)
+      def search_for(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.search_for(dependency)
+        end
+      end
+
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#dependencies_for)
+      def dependencies_for(specification)
+        with_no_such_dependency_error_handling do
+          specification_provider.dependencies_for(specification)
+        end
+      end
+
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#requirement_satisfied_by?)
+      def requirement_satisfied_by?(requirement, activated, spec)
+        with_no_such_dependency_error_handling do
+          specification_provider.requirement_satisfied_by?(requirement, activated, spec)
+        end
+      end
+
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#name_for)
+      def name_for(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for(dependency)
+        end
+      end
+
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#name_for_explicit_dependency_source)
+      def name_for_explicit_dependency_source
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for_explicit_dependency_source
+        end
+      end
+
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#name_for_locking_dependency_source)
+      def name_for_locking_dependency_source
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for_locking_dependency_source
+        end
+      end
+
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#sort_dependencies)
+      def sort_dependencies(dependencies, activated, conflicts)
+        with_no_such_dependency_error_handling do
+          specification_provider.sort_dependencies(dependencies, activated, conflicts)
+        end
+      end
+
+      # (see Gem::Resolver::Molinillo::SpecificationProvider#allow_missing?)
+      def allow_missing?(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.allow_missing?(dependency)
+        end
+      end
+
+      private
+
+      # Ensures any raised {NoSuchDependencyError} has its
+      # {NoSuchDependencyError#required_by} set.
+      # @yield
+      def with_no_such_dependency_error_handling
+        yield
+      rescue NoSuchDependencyError => error
+        if state
+          vertex = activated.vertex_named(name_for(error.dependency))
+          error.required_by += vertex.incoming_edges.map { |e| e.origin.name }
+          error.required_by << name_for_explicit_dependency_source unless vertex.explicit_requirements.empty?
+        end
+        raise
+      end
+    end
+  end
+end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph.rb
@@ -2,6 +2,9 @@
 require 'set'
 require 'tsort'
 
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/log'
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/vertex'
+
 module Gem::Resolver::Molinillo
   # A directed acyclic graph that is tuned to hold named dependencies
   class DependencyGraph
@@ -10,15 +13,16 @@ class DependencyGraph
     # Enumerates through the vertices of the graph.
     # @return [Array<Vertex>] The graph's vertices.
     def each
+      return vertices.values.each unless block_given?
       vertices.values.each { |v| yield v }
     end
 
     include TSort
 
-    # @visibility private
-    alias_method :tsort_each_node, :each
+    # @!visibility private
+    alias tsort_each_node each
 
-    # @visibility private
+    # @!visibility private
     def tsort_each_child(vertex, &block)
       vertex.successors.each(&block)
     end
@@ -44,9 +48,27 @@ def self.tsort(vertices)
     #   by {Vertex#name}
     attr_reader :vertices
 
+    # @return [Log] the op log for this graph
+    attr_reader :log
+
     # Initializes an empty dependency graph
     def initialize
       @vertices = {}
+      @log = Log.new
+    end
+
+    # Tags the current state of the dependency as the given tag
+    # @param  [Object] tag an opaque tag for the current state of the graph
+    # @return [Void]
+    def tag(tag)
+      log.tag(self, tag)
+    end
+
+    # Rewinds the graph to the state tagged as `tag`
+    # @param  [Object] tag the tag to rewind to
+    # @return [Void]
+    def rewind_to(tag)
+      log.rewind_to(self, tag)
     end
 
     # Initializes a copy of a {DependencyGraph}, ensuring that all {#vertices}
@@ -55,6 +77,7 @@ def initialize
     def initialize_copy(other)
       super
       @vertices = {}
+      @log = other.log.dup
       traverse = lambda do |new_v, old_v|
         return if new_v.outgoing_edges.size == old_v.outgoing_edges.size
         old_v.outgoing_edges.each do |edge|
@@ -75,6 +98,22 @@ def inspect
       "#{self.class}:#{vertices.values.inspect}"
     end
 
+    # @return [String] Returns a dot format representation of the graph
+    def to_dot
+      dot_vertices = []
+      dot_edges = []
+      vertices.each do |n, v|
+        dot_vertices << "  #{n} [label=\"{#{n}|#{v.payload}}\"]"
+        v.outgoing_edges.each do |e|
+          dot_edges << "  #{e.origin.name} -> #{e.destination.name} [label=\"#{e.requirement}\"]"
+        end
+      end
+      dot_vertices.sort!
+      dot_edges.sort!
+      dot = dot_vertices.unshift('digraph G {').push('') + dot_edges.push('}')
+      dot.join("\n")
+    end
+
     # @return [Boolean] whether the two dependency graphs are equal, determined
     #   by a recursive traversal of each {#root_vertices} and its
     #   {Vertex#successors}
@@ -93,12 +132,9 @@ def ==(other)
     # @param [Object] requirement the requirement that is requiring the child
     # @return [void]
     def add_child_vertex(name, payload, parent_names, requirement)
-      vertex = add_vertex(name, payload)
+      root = !parent_names.delete(nil) { true }
+      vertex = add_vertex(name, payload, root)
       parent_names.each do |parent_name|
-        unless parent_name
-          vertex.root = true
-          next
-        end
         parent_node = vertex_named(parent_name)
         add_edge(parent_node, vertex, requirement)
       end
@@ -110,27 +146,15 @@ def add_child_vertex(name, payload, parent_names, requirement)
     # @param [Object] payload
     # @return [Vertex] the vertex that was added to `self`
     def add_vertex(name, payload, root = false)
-      vertex = vertices[name] ||= Vertex.new(name, payload)
-      vertex.payload ||= payload
-      vertex.root ||= root
-      vertex
+      log.add_vertex(self, name, payload, root)
     end
 
     # Detaches the {#vertex_named} `name` {Vertex} from the graph, recursively
     # removing any non-root vertices that were orphaned in the process
     # @param [String] name
     # @return [void]
     def detach_vertex_named(name)
-      return unless vertex = vertices.delete(name)
-      vertex.outgoing_edges.each do |e|
-        v = e.destination
-        v.incoming_edges.delete(e)
-        detach_vertex_named(v.name) unless v.root? || v.predecessors.any?
-      end
-      vertex.incoming_edges.each do |e|
-        v = e.origin
-        v.outgoing_edges.delete(e)
-      end
+      log.detach_vertex_named(self, name)
     end
 
     # @param [String] name
@@ -158,134 +182,22 @@ def add_edge(origin, destination, requirement)
       add_edge_no_circular(origin, destination, requirement)
     end
 
+    # Sets the payload of the vertex with the given name
+    # @param [String] name the name of the vertex
+    # @param [Object] payload the payload
+    # @return [Void]
+    def set_payload(name, payload)
+      log.set_payload(self, name, payload)
+    end
+
     private
 
     # Adds a new {Edge} to the dependency graph without checking for
     # circularity.
+    # @param (see #add_edge)
+    # @return (see #add_edge)
     def add_edge_no_circular(origin, destination, requirement)
-      edge = Edge.new(origin, destination, requirement)
-      origin.outgoing_edges << edge
-      destination.incoming_edges << edge
-      edge
-    end
-
-    # A vertex in a {DependencyGraph} that encapsulates a {#name} and a
-    # {#payload}
-    class Vertex
-      # @return [String] the name of the vertex
-      attr_accessor :name
-
-      # @return [Object] the payload the vertex holds
-      attr_accessor :payload
-
-      # @return [Arrary<Object>] the explicit requirements that required
-      #   this vertex
-      attr_reader :explicit_requirements
-
-      # @return [Boolean] whether the vertex is considered a root vertex
-      attr_accessor :root
-      alias_method :root?, :root
-
-      # Initializes a vertex with the given name and payload.
-      # @param [String] name see {#name}
-      # @param [Object] payload see {#payload}
-      def initialize(name, payload)
-        @name = name
-        @payload = payload
-        @explicit_requirements = []
-        @outgoing_edges = []
-        @incoming_edges = []
-      end
-
-      # @return [Array<Object>] all of the requirements that required
-      #   this vertex
-      def requirements
-        incoming_edges.map(&:requirement) + explicit_requirements
-      end
-
-      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
-      #   {Edge#origin}
-      attr_accessor :outgoing_edges
-
-      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
-      #   {Edge#destination}
-      attr_accessor :incoming_edges
-
-      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
-      #   `self` as their {Edge#destination}
-      def predecessors
-        incoming_edges.map(&:origin)
-      end
-
-      # @return [Array<Vertex>] the vertices of {#graph} where `self` is a
-      #   {#descendent?}
-      def recursive_predecessors
-        vertices = predecessors
-        vertices += vertices.map(&:recursive_predecessors).flatten(1)
-        vertices.uniq!
-        vertices
-      end
-
-      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
-      #   `self` as their {Edge#origin}
-      def successors
-        outgoing_edges.map(&:destination)
-      end
-
-      # @return [Array<Vertex>] the vertices of {#graph} where `self` is an
-      #   {#ancestor?}
-      def recursive_successors
-        vertices = successors
-        vertices += vertices.map(&:recursive_successors).flatten(1)
-        vertices.uniq!
-        vertices
-      end
-
-      # @return [String] a string suitable for debugging
-      def inspect
-        "#{self.class}:#{name}(#{payload.inspect})"
-      end
-
-      # @return [Boolean] whether the two vertices are equal, determined
-      #   by a recursive traversal of each {Vertex#successors}
-      def ==(other)
-        shallow_eql?(other) &&
-          successors.to_set == other.successors.to_set
-      end
-
-      # @param  [Vertex] other the other vertex to compare to
-      # @return [Boolean] whether the two vertices are equal, determined
-      #   solely by {#name} and {#payload} equality
-      def shallow_eql?(other)
-        other &&
-          name == other.name &&
-          payload == other.payload
-      end
-
-      alias_method :eql?, :==
-
-      # @return [Fixnum] a hash for the vertex based upon its {#name}
-      def hash
-        name.hash
-      end
-
-      # Is there a path from `self` to `other` following edges in the
-      # dependency graph?
-      # @return true iff there is a path following edges within this {#graph}
-      def path_to?(other)
-        equal?(other) || successors.any? { |v| v.path_to?(other) }
-      end
-
-      alias_method :descendent?, :path_to?
-
-      # Is there a path from `other` to `self` following edges in the
-      # dependency graph?
-      # @return true iff there is a path following edges within this {#graph}
-      def ancestor?(other)
-        other.path_to?(self)
-      end
-
-      alias_method :is_reachable_from?, :ancestor?
+      log.add_edge_no_circular(self, origin.name, destination.name, requirement)
     end
   end
 end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # An action that modifies a {DependencyGraph} that is reversible.
+    # @abstract
+    class Action
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      # @return [Symbol] The name of the action.
+      def self.name
+        raise 'Abstract'
+      end
+
+      # Performs the action on the given graph.
+      # @param  [DependencyGraph] graph the graph to perform the action on.
+      # @return [Void]
+      def up(graph)
+        raise 'Abstract'
+      end
+
+      # Reverses the action on the given graph.
+      # @param  [DependencyGraph] graph the graph to reverse the action on.
+      # @return [Void]
+      def down(graph)
+        raise 'Abstract'
+      end
+
+      # @return [Action,Nil] The previous action
+      attr_accessor :previous
+
+      # @return [Action,Nil] The next action
+      attr_accessor :next
+    end
+  end
+end
diff --git a/...stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_edge_no_circular.rb b/...stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_edge_no_circular.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # @!visibility private
+    # (see DependencyGraph#add_edge_no_circular)
+    class AddEdgeNoCircular < Action
+      # @!group Action
+
+      # (see Action.name)
+      def self.name
+        :add_vertex
+      end
+
+      # (see Action#up)
+      def up(graph)
+        edge = make_edge(graph)
+        edge.origin.outgoing_edges << edge
+        edge.destination.incoming_edges << edge
+        edge
+      end
+
+      # (see Action#down)
+      def down(graph)
+        edge = make_edge(graph)
+        edge.origin.outgoing_edges.delete(edge)
+        edge.destination.incoming_edges.delete(edge)
+      end
+
+      # @!group AddEdgeNoCircular
+
+      # @return [String] the name of the origin of the edge
+      attr_reader :origin
+
+      # @return [String] the name of the destination of the edge
+      attr_reader :destination
+
+      # @return [Object] the requirement that the edge represents
+      attr_reader :requirement
+
+      # @param  [DependencyGraph] graph the graph to find vertices from
+      # @return [Edge] The edge this action adds
+      def make_edge(graph)
+        Edge.new(graph.vertex_named(origin), graph.vertex_named(destination), requirement)
+      end
+
+      # Initialize an action to add an edge to a dependency graph
+      # @param [String] origin the name of the origin of the edge
+      # @param [String] destination the name of the destination of the edge
+      # @param [Object] requirement the requirement that the edge represents
+      def initialize(origin, destination, requirement)
+        @origin = origin
+        @destination = destination
+        @requirement = requirement
+      end
+    end
+  end
+end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_vertex.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_vertex.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # @!visibility private
+    # (see DependencyGraph#add_vertex)
+    class AddVertex < Action # :nodoc:
+      # @!group Action
+
+      # (see Action.name)
+      def self.name
+        :add_vertex
+      end
+
+      # (see Action#up)
+      def up(graph)
+        if existing = graph.vertices[name]
+          @existing_payload = existing.payload
+          @existing_root = existing.root
+        end
+        vertex = existing || Vertex.new(name, payload)
+        graph.vertices[vertex.name] = vertex
+        vertex.payload ||= payload
+        vertex.root ||= root
+        vertex
+      end
+
+      # (see Action#down)
+      def down(graph)
+        if defined?(@existing_payload)
+          vertex = graph.vertices[name]
+          vertex.payload = @existing_payload
+          vertex.root = @existing_root
+        else
+          graph.vertices.delete(name)
+        end
+      end
+
+      # @!group AddVertex
+
+      # @return [String] the name of the vertex
+      attr_reader :name
+
+      # @return [Object] the payload for the vertex
+      attr_reader :payload
+
+      # @return [Boolean] whether the vertex is root or not
+      attr_reader :root
+
+      # Initialize an action to add a vertex to a dependency graph
+      # @param [String] name the name of the vertex
+      # @param [Object] payload the payload for the vertex
+      # @param [Boolean] root whether the vertex is root or not
+      def initialize(name, payload, root)
+        @name = name
+        @payload = payload
+        @root = root
+      end
+    end
+  end
+end
diff --git a/.../stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/detach_vertex_named.rb b/.../stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/detach_vertex_named.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # @!visibility private
+    # @see DependencyGraph#detach_vertex_named
+    class DetachVertexNamed < Action
+      # @!group Action
+
+      # (see Action#name)
+      def self.name
+        :add_vertex
+      end
+
+      # (see Action#up)
+      def up(graph)
+        return unless @vertex = graph.vertices.delete(name)
+        @vertex.outgoing_edges.each do |e|
+          v = e.destination
+          v.incoming_edges.delete(e)
+          graph.detach_vertex_named(v.name) unless v.root? || v.predecessors.any?
+        end
+        @vertex.incoming_edges.each do |e|
+          v = e.origin
+          v.outgoing_edges.delete(e)
+        end
+      end
+
+      # (see Action#down)
+      def down(graph)
+        return unless @vertex
+        graph.vertices[@vertex.name] = @vertex
+        @vertex.outgoing_edges.each do |e|
+          e.destination.incoming_edges << e
+        end
+        @vertex.incoming_edges.each do |e|
+          e.origin.outgoing_edges << e
+        end
+      end
+
+      # @!group DetachVertexNamed
+
+      # @return [String] the name of the vertex to detach
+      attr_reader :name
+
+      # Initialize an action to detach a vertex from a dependency graph
+      # @param [String] name the name of the vertex to detach
+      def initialize(name)
+        @name = name
+      end
+    end
+  end
+end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/log.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/log.rb
@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_edge_no_circular'
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_vertex'
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/detach_vertex_named'
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/set_payload'
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/tag'
+
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # A log for dependency graph actions
+    class Log
+      # Initializes an empty log
+      def initialize
+        @current_action = @first_action = nil
+      end
+
+      # @!macro [new] action
+      #   {include:DependencyGraph#$0}
+      #   @param [Graph] graph the graph to perform the action on
+      #   @param (see DependencyGraph#$0)
+      #   @return (see DependencyGraph#$0)
+
+      # @macro action
+      def tag(graph, tag)
+        push_action(graph, Tag.new(tag))
+      end
+
+      # @macro action
+      def add_vertex(graph, name, payload, root)
+        push_action(graph, AddVertex.new(name, payload, root))
+      end
+
+      # @macro action
+      def detach_vertex_named(graph, name)
+        push_action(graph, DetachVertexNamed.new(name))
+      end
+
+      # @macro action
+      def add_edge_no_circular(graph, origin, destination, requirement)
+        push_action(graph, AddEdgeNoCircular.new(origin, destination, requirement))
+      end
+
+      # @macro action
+      def set_payload(graph, name, payload)
+        push_action(graph, SetPayload.new(name, payload))
+      end
+
+      # Pops the most recent action from the log and undoes the action
+      # @param [DependencyGraph] graph
+      # @return [Action] the action that was popped off the log
+      def pop!(graph)
+        return unless action = @current_action
+        unless @current_action = action.previous
+          @first_action = nil
+        end
+        action.down(graph)
+        action
+      end
+
+      extend Enumerable
+
+      # @!visibility private
+      # Enumerates each action in the log
+      # @yield [Action]
+      def each
+        return enum_for unless block_given?
+        action = @first_action
+        loop do
+          break unless action
+          yield action
+          action = action.next
+        end
+        self
+      end
+
+      # @!visibility private
+      # Enumerates each action in the log in reverse order
+      # @yield [Action]
+      def reverse_each
+        return enum_for(:reverse_each) unless block_given?
+        action = @current_action
+        loop do
+          break unless action
+          yield action
+          action = action.previous
+        end
+        self
+      end
+
+      # @macro action
+      def rewind_to(graph, tag)
+        loop do
+          action = pop!(graph)
+          raise "No tag #{tag.inspect} found" unless action
+          break if action.class.name == :tag && action.tag == tag
+        end
+      end
+
+      private
+
+      # Adds the given action to the log, running the action
+      # @param [DependencyGraph] graph
+      # @param [Action] action
+      # @return The value returned by `action.up`
+      def push_action(graph, action)
+        action.previous = @current_action
+        @current_action.next = action if @current_action
+        @current_action = action
+        @first_action ||= action
+        action.up(graph)
+      end
+    end
+  end
+end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/set_payload.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/set_payload.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # @!visibility private
+    # @see DependencyGraph#set_payload
+    class SetPayload < Action # :nodoc:
+      # @!group Action
+
+      # (see Action.name)
+      def self.name
+        :set_payload
+      end
+
+      # (see Action#up)
+      def up(graph)
+        vertex = graph.vertex_named(name)
+        @old_payload = vertex.payload
+        vertex.payload = payload
+      end
+
+      # (see Action#down)
+      def down(graph)
+        graph.vertex_named(name).payload = @old_payload
+      end
+
+      # @!group SetPayload
+
+      # @return [String] the name of the vertex
+      attr_reader :name
+
+      # @return [Object] the payload for the vertex
+      attr_reader :payload
+
+      # Initialize an action to add set the payload for a vertex in a dependency
+      # graph
+      # @param [String] name the name of the vertex
+      # @param [Object] payload the payload for the vertex
+      def initialize(name, payload)
+        @name = name
+        @payload = payload
+      end
+    end
+  end
+end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/tag.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/tag.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # @!visibility private
+    # @see DependencyGraph#tag
+    class Tag < Action
+      # @!group Action
+
+      # (see Action.name)
+      def self.name
+        :tag
+      end
+
+      # (see Action#up)
+      def up(_graph)
+      end
+
+      # (see Action#down)
+      def down(_graph)
+      end
+
+      # @!group Tag
+
+      # @return [Object] An opaque tag
+      attr_reader :tag
+
+      # Initialize an action to tag a state of a dependency graph
+      # @param [Object] tag an opaque tag
+      def initialize(tag)
+        @tag = tag
+      end
+    end
+  end
+end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/vertex.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph/vertex.rb
@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+module Gem::Resolver::Molinillo
+  class DependencyGraph
+    # A vertex in a {DependencyGraph} that encapsulates a {#name} and a
+    # {#payload}
+    class Vertex
+      # @return [String] the name of the vertex
+      attr_accessor :name
+
+      # @return [Object] the payload the vertex holds
+      attr_accessor :payload
+
+      # @return [Arrary<Object>] the explicit requirements that required
+      #   this vertex
+      attr_reader :explicit_requirements
+
+      # @return [Boolean] whether the vertex is considered a root vertex
+      attr_accessor :root
+      alias root? root
+
+      # Initializes a vertex with the given name and payload.
+      # @param [String] name see {#name}
+      # @param [Object] payload see {#payload}
+      def initialize(name, payload)
+        @name = name.frozen? ? name : name.dup.freeze
+        @payload = payload
+        @explicit_requirements = []
+        @outgoing_edges = []
+        @incoming_edges = []
+      end
+
+      # @return [Array<Object>] all of the requirements that required
+      #   this vertex
+      def requirements
+        incoming_edges.map(&:requirement) + explicit_requirements
+      end
+
+      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
+      #   {Edge#origin}
+      attr_accessor :outgoing_edges
+
+      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
+      #   {Edge#destination}
+      attr_accessor :incoming_edges
+
+      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
+      #   `self` as their {Edge#destination}
+      def predecessors
+        incoming_edges.map(&:origin)
+      end
+
+      # @return [Array<Vertex>] the vertices of {#graph} where `self` is a
+      #   {#descendent?}
+      def recursive_predecessors
+        vertices = predecessors
+        vertices += vertices.map(&:recursive_predecessors).flatten(1)
+        vertices.uniq!
+        vertices
+      end
+
+      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
+      #   `self` as their {Edge#origin}
+      def successors
+        outgoing_edges.map(&:destination)
+      end
+
+      # @return [Array<Vertex>] the vertices of {#graph} where `self` is an
+      #   {#ancestor?}
+      def recursive_successors
+        vertices = successors
+        vertices += vertices.map(&:recursive_successors).flatten(1)
+        vertices.uniq!
+        vertices
+      end
+
+      # @return [String] a string suitable for debugging
+      def inspect
+        "#{self.class}:#{name}(#{payload.inspect})"
+      end
+
+      # @return [Boolean] whether the two vertices are equal, determined
+      #   by a recursive traversal of each {Vertex#successors}
+      def ==(other)
+        shallow_eql?(other) &&
+          successors.to_set == other.successors.to_set
+      end
+
+      # @param  [Vertex] other the other vertex to compare to
+      # @return [Boolean] whether the two vertices are equal, determined
+      #   solely by {#name} and {#payload} equality
+      def shallow_eql?(other)
+        other &&
+          name == other.name &&
+          payload == other.payload
+      end
+
+      alias eql? ==
+
+      # @return [Fixnum] a hash for the vertex based upon its {#name}
+      def hash
+        name.hash
+      end
+
+      # Is there a path from `self` to `other` following edges in the
+      # dependency graph?
+      # @return true iff there is a path following edges within this {#graph}
+      def path_to?(other)
+        equal?(other) || successors.any? { |v| v.path_to?(other) }
+      end
+
+      alias descendent? path_to?
+
+      # Is there a path from `other` to `self` following edges in the
+      # dependency graph?
+      # @return true iff there is a path following edges within this {#graph}
+      def ancestor?(other)
+        other.path_to?(self)
+      end
+
+      alias is_reachable_from? ancestor?
+    end
+  end
+end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/errors.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/errors.rb
@@ -26,7 +26,7 @@ def initialize(dependency, required_by = [])
     def message
       sources = required_by.map { |r| "`#{r}`" }.join(' and ')
       message = "Unable to find a specification for `#{dependency}`"
-      message << " depended upon by #{sources}" unless sources.empty?
+      message += " depended upon by #{sources}" unless sources.empty?
       message
     end
   end

diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/gem_metadata.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/gem_metadata.rb
@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Gem::Resolver::Molinillo
   # The version of Gem::Resolver::Molinillo.
-  VERSION = '0.4.3'.freeze
+  VERSION = '0.5.0'.freeze
 end
diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/resolution.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/resolution.rb
@@ -52,6 +52,7 @@ def initialize(specification_provider, resolver_ui, requested, base)
         @base = base
         @states = []
         @iteration_counter = 0
+        @parent_of = {}
       end
 
       # Resolves the {#original_requested} dependencies into a full dependency
@@ -67,7 +68,12 @@ def resolve
           indicate_progress
           if state.respond_to?(:pop_possibility_state) # DependencyState
             debug(depth) { "Creating possibility state for #{requirement} (#{possibilities.count} remaining)" }
-            state.pop_possibility_state.tap { |s| states.push(s) if s }
+            state.pop_possibility_state.tap do |s|
+              if s
+                states.push(s)
+                activated.tag(s)
+              end
+            end
           end
           process_topmost_state
         end
@@ -118,27 +124,11 @@ def end_resolution
       require 'rubygems/resolver/molinillo/lib/molinillo/state'
       require 'rubygems/resolver/molinillo/lib/molinillo/modules/specification_provider'
 
-      ResolutionState.new.members.each do |member|
-        define_method member do |*args, &block|
-          current_state = state || ResolutionState.empty
-          current_state.send(member, *args, &block)
-        end
-      end
+      require 'rubygems/resolver/molinillo/lib/molinillo/delegates/resolution_state'
+      require 'rubygems/resolver/molinillo/lib/molinillo/delegates/specification_provider'
 
-      SpecificationProvider.instance_methods(false).each do |instance_method|
-        define_method instance_method do |*args, &block|
-          begin
-            specification_provider.send(instance_method, *args, &block)
-          rescue NoSuchDependencyError => error
-            if state
-              vertex = activated.vertex_named(name_for error.dependency)
-              error.required_by += vertex.incoming_edges.map { |e| e.origin.name }
-              error.required_by << name_for_explicit_dependency_source unless vertex.explicit_requirements.empty?
-            end
-            raise
-          end
-        end
-      end
+      include Gem::Resolver::Molinillo::Delegates::ResolutionState
+      include Gem::Resolver::Molinillo::Delegates::SpecificationProvider
 
       # Processes the topmost available {RequirementState} on the stack
       # @return [void]
@@ -169,6 +159,7 @@ def state
       def initial_state
         graph = DependencyGraph.new.tap do |dg|
           original_requested.each { |r| dg.add_vertex(name_for(r), nil, true).tap { |v| v.explicit_requirements << r } }
+          dg.tag(:initial_state)
         end
 
         requirements = sort_dependencies(original_requested, graph, {})
@@ -189,8 +180,9 @@ def initial_state
       def unwind_for_conflict
         debug(depth) { "Unwinding for conflict: #{requirement}" }
         conflicts.tap do |c|
-          states.slice!((state_index_for_unwind + 1)..-1)
+          sliced_states = states.slice!((state_index_for_unwind + 1)..-1)
           raise VersionConflict.new(c) unless state
+          activated.rewind_to(sliced_states.first || :initial_state) if sliced_states
           state.conflicts = c
         end
       end
@@ -217,20 +209,14 @@ def state_index_for_unwind
       # @return [Object] the requirement that led to `requirement` being added
       #   to the list of requirements.
       def parent_of(requirement)
-        return nil unless requirement
-        seen = false
-        state = states.reverse_each.find do |s|
-          seen ||= s.requirement == requirement || s.requirements.include?(requirement)
-          seen && s.requirement != requirement && !s.requirements.include?(requirement)
-        end
-        state && state.requirement
+        @parent_of[requirement]
       end
 
       # @return [Object] the requirement that led to a version of a possibility
       #   with the given name being activated.
       def requirement_for_existing_name(name)
         return nil unless activated.vertex_named(name).payload
-        states.reverse_each.find { |s| !s.activated.vertex_named(name).payload }.requirement
+        states.find { |s| s.name == name }.requirement
       end
 
       # @return [ResolutionState] the state whose `requirement` is the given
@@ -250,19 +236,25 @@ def state_any?(state)
       #   the {#possibility} in conjunction with the current {#state}
       def create_conflict
         vertex = activated.vertex_named(name)
-        requirements = {
-          name_for_explicit_dependency_source => vertex.explicit_requirements,
-          name_for_locking_dependency_source => Array(locked_requirement_named(name)),
-        }
+        locked_requirement = locked_requirement_named(name)
+
+        requirements = {}
+        unless vertex.explicit_requirements.empty?
+          requirements[name_for_explicit_dependency_source] = vertex.explicit_requirements
+        end
+        requirements[name_for_locking_dependency_source] = [locked_requirement] if locked_requirement
         vertex.incoming_edges.each { |edge| (requirements[edge.origin.payload] ||= []).unshift(edge.requirement) }
+
+        activated_by_name = {}
+        activated.each { |v| activated_by_name[v.name] = v.payload if v.payload }
         conflicts[name] = Conflict.new(
           requirement,
-          Hash[requirements.select { |_, r| !r.empty? }],
+          requirements,
           vertex.payload,
           possibility,
-          locked_requirement_named(name),
+          locked_requirement,
           requirement_trees,
-          Hash[activated.map { |v| [v.name, v.payload] }.select(&:last)]
+          activated_by_name
         )
       end
 
@@ -341,15 +333,16 @@ def attempt_to_activate_existing_spec(existing_node)
       # spec with the given name
       # @return [Boolean] Whether the possibility was swapped into {#activated}
       def attempt_to_swap_possibility
-        swapped = activated.dup
-        vertex = swapped.vertex_named(name)
-        vertex.payload = possibility
-        return unless vertex.requirements.
-            all? { |r| requirement_satisfied_by?(r, swapped, possibility) }
-        return unless new_spec_satisfied?
-        actual_vertex = activated.vertex_named(name)
-        actual_vertex.payload = possibility
-        fixup_swapped_children(actual_vertex)
+        activated.tag(:swap)
+        vertex = activated.vertex_named(name)
+        activated.set_payload(name, possibility)
+        if !vertex.requirements.
+           all? { |r| requirement_satisfied_by?(r, activated, possibility) } ||
+            !new_spec_satisfied?
+          activated.rewind_to(:swap)
+          return
+        end
+        fixup_swapped_children(vertex)
         activate_spec
       end
 
@@ -363,7 +356,13 @@ def fixup_swapped_children(vertex)
           if !dep_names.include?(succ.name) && !succ.root? && succ.predecessors.to_a == [vertex]
             debug(depth) { "Removing orphaned spec #{succ.name} after swapping #{name}" }
             activated.detach_vertex_named(succ.name)
-            requirements.delete_if { |r| name_for(r) == succ.name }
+
+            all_successor_names = succ.recursive_successors.map(&:name)
+
+            requirements.delete_if do |requirement|
+              requirement_name = name_for(requirement)
+              (requirement_name == succ.name) || all_successor_names.include?(requirement_name)
+            end
           end
         end
       end
@@ -406,8 +405,7 @@ def locked_requirement_named(requirement_name)
       def activate_spec
         conflicts.delete(name)
         debug(depth) { 'Activated ' + name + ' at ' + possibility.to_s }
-        vertex = activated.vertex_named(name)
-        vertex.payload = possibility
+        activated.set_payload(name, possibility)
         require_nested_dependencies_for(possibility)
       end
 
@@ -418,19 +416,22 @@ def activate_spec
       def require_nested_dependencies_for(activated_spec)
         nested_dependencies = dependencies_for(activated_spec)
         debug(depth) { "Requiring nested dependencies (#{nested_dependencies.join(', ')})" }
-        nested_dependencies.each { |d| activated.add_child_vertex(name_for(d), nil, [name_for(activated_spec)], d) }
+        nested_dependencies.each do |d|
+          activated.add_child_vertex(name_for(d), nil, [name_for(activated_spec)], d)
+          @parent_of[d] = requirement
+        end
 
-        push_state_for_requirements(requirements + nested_dependencies, nested_dependencies.size > 0)
+        push_state_for_requirements(requirements + nested_dependencies, !nested_dependencies.empty?)
       end
 
       # Pushes a new {DependencyState} that encapsulates both existing and new
       # requirements
       # @param [Array] new_requirements
       # @return [void]
-      def push_state_for_requirements(new_requirements, requires_sort = true, new_activated = activated.dup)
+      def push_state_for_requirements(new_requirements, requires_sort = true, new_activated = activated)
         new_requirements = sort_dependencies(new_requirements.uniq, new_activated, conflicts) if requires_sort
         new_requirement = new_requirements.shift
-        new_name = new_requirement ? name_for(new_requirement) : ''
+        new_name = new_requirement ? name_for(new_requirement) : ''.freeze
         possibilities = new_requirement ? search_for(new_requirement) : []
         handle_missing_or_push_dependency_state DependencyState.new(
           new_name, new_requirements, new_activated,
@@ -451,7 +452,7 @@ def handle_missing_or_push_dependency_state(state)
           state.activated.detach_vertex_named(state.name)
           push_state_for_requirements(state.requirements.dup, false, state.activated)
         else
-          states.push state
+          states.push(state).tap { activated.tag(state) }
         end
       end
     end

diff --git a/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/state.rb b/lib/ruby/stdlib/rubygems/resolver/molinillo/lib/molinillo/state.rb
@@ -36,12 +36,14 @@ def pop_possibility_state
       PossibilityState.new(
         name,
         requirements.dup,
-        activated.dup,
+        activated,
         requirement,
         [possibilities.pop],
         depth + 1,
         conflicts.dup
-      )
+      ).tap do |state|
+        state.activated.tag(state)
+      end
     end
   end
 

diff --git a/lib/ruby/stdlib/rubygems/security/signer.rb b/lib/ruby/stdlib/rubygems/security/signer.rb
@@ -102,6 +102,8 @@ def load_cert_chain # :nodoc:
   def sign data
     return unless @key
 
+    raise Gem::Security::Exception, 'no certs provided' if @cert_chain.empty?
+
     if @cert_chain.length == 1 and @cert_chain.last.not_after < Time.now then
       re_sign_key
     end

diff --git a/lib/ruby/stdlib/rubygems/specification.rb b/lib/ruby/stdlib/rubygems/specification.rb
@@ -209,9 +209,9 @@ class Gem::Specification < Gem::BasicSpecification
   ##
   # Paths in the gem to add to <code>$LOAD_PATH</code> when this gem is
   # activated.
-  #
+  #--
   # See also #require_paths
-  #
+  #++
   # If you have an extension you do not need to add <code>"ext"</code> to the
   # require path, the extension build process will copy the extension files
   # into "lib" for you.
@@ -2696,9 +2696,9 @@ def validate packaging = true
             "#{full_name} contains itself (#{file_name}), check your files list"
     end
 
-    unless specification_version.is_a?(Fixnum)
+    unless specification_version.is_a?(Integer)
       raise Gem::InvalidSpecificationException,
-            'specification_version must be a Fixnum (did you mean version?)'
+            'specification_version must be a Integer (did you mean version?)'
     end
 
     case platform

diff --git a/lib/ruby/stdlib/rubygems/ssl_certs/index.rubygems.org/GlobalSignRootCA.pem b/lib/ruby/stdlib/rubygems/ssl_certs/index.rubygems.org/GlobalSignRootCA.pem
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
+A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
+b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
+MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
+YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
+aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
+jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
+xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
+1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
+snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
+U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
+9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
+AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
+yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
+38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
+AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
+DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
+HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
+-----END CERTIFICATE-----
diff --git a/lib/ruby/stdlib/rubygems/ssl_certs/rubygems.org/AddTrustExternalCARoot.pem b/lib/ruby/stdlib/rubygems/ssl_certs/rubygems.org/AddTrustExternalCARoot.pem
@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU
+MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs
+IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290
+MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux
+FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h
+bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v
+dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt
+H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9
+uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX
+mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX
+a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN
+E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0
+WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD
+VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0
+Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU
+cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx
+IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN
+AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH
+YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5
+6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC
+Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX
+c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a
+mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ=
+-----END CERTIFICATE-----
diff --git a/spec/ruby/core/array/slice_spec.rb b/spec/ruby/core/array/slice_spec.rb
@@ -42,6 +42,10 @@
     a.slice!(0, 1).should == [1]
     a.should == []
     a[-1].should == nil
+
+    a = [1, 2, 3]
+    a.slice!(0,1).should == [1]
+    a.should == [2, 3]
   end
 
   it "returns nil if length is negative" do

diff --git a/spec/truffle/tags/core/array/collect_tags.txt b/spec/truffle/tags/core/array/collect_tags.txt
diff --git a/spec/truffle/tags/core/array/combination_tags.txt b/spec/truffle/tags/core/array/combination_tags.txt
diff --git a/spec/truffle/tags/core/array/delete_if_tags.txt b/spec/truffle/tags/core/array/delete_if_tags.txt
diff --git a/spec/truffle/tags/core/array/each_tags.txt b/spec/truffle/tags/core/array/each_tags.txt
diff --git a/spec/truffle/tags/core/array/map_tags.txt b/spec/truffle/tags/core/array/map_tags.txt
diff --git a/spec/truffle/tags/core/array/permutation_tags.txt b/spec/truffle/tags/core/array/permutation_tags.txt
diff --git a/spec/truffle/tags/core/array/reject_tags.txt b/spec/truffle/tags/core/array/reject_tags.txt
diff --git a/spec/truffle/tags/core/array/repeated_combination_tags.txt b/spec/truffle/tags/core/array/repeated_combination_tags.txt
diff --git a/spec/truffle/tags/core/array/repeated_permutation_tags.txt b/spec/truffle/tags/core/array/repeated_permutation_tags.txt
diff --git a/spec/truffle/tags/core/array/select_tags.txt b/spec/truffle/tags/core/array/select_tags.txt
diff --git a/spec/truffle/tags/core/hash/each_pair_tags.txt b/spec/truffle/tags/core/hash/each_pair_tags.txt
@@ -1,2 +1 @@
 fails:Hash#each_pair properly expands (or not) child class's 'each'-yielded args
-fails:Hash#each_pair when no block is given returned Enumerator size returns the enumerable size
diff --git a/spec/truffle/tags/core/hash/each_tags.txt b/spec/truffle/tags/core/hash/each_tags.txt
@@ -1,2 +1 @@
 fails:Hash#each properly expands (or not) child class's 'each'-yielded args
-fails:Hash#each when no block is given returned Enumerator size returns the enumerable size
diff --git a/spec/truffle/tags/core/hash/gt_tags.txt b/spec/truffle/tags/core/hash/gt_tags.txt
diff --git a/spec/truffle/tags/core/hash/gte_tags.txt b/spec/truffle/tags/core/hash/gte_tags.txt
diff --git a/spec/truffle/tags/core/hash/lt_tags.txt b/spec/truffle/tags/core/hash/lt_tags.txt
diff --git a/spec/truffle/tags/core/hash/lte_tags.txt b/spec/truffle/tags/core/hash/lte_tags.txt
diff --git a/spec/truffle/tags/core/hash/to_proc_tags.txt b/spec/truffle/tags/core/hash/to_proc_tags.txt
diff --git a/spec/truffle/tags/core/string/each_byte_tags.txt b/spec/truffle/tags/core/string/each_byte_tags.txt
diff --git a/spec/truffle/tags/core/string/each_char_tags.txt b/spec/truffle/tags/core/string/each_char_tags.txt
diff --git a/truffle/src/main/java/org/jruby/truffle/builtins/CoreMethod.java b/truffle/src/main/java/org/jruby/truffle/builtins/CoreMethod.java
@@ -73,4 +73,6 @@
 
     UnsafeGroup[] unsafe() default {};
 
+    String enumeratorSize() default "";
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/builtins/CoreMethodNodeManager.java b/truffle/src/main/java/org/jruby/truffle/builtins/CoreMethodNodeManager.java
@@ -263,7 +263,12 @@ private static CallTarget makeGenericMethod(RubyContext context, MethodDetails m
         } else {
             sequence = Translator.sequence(context, sourceSection, Arrays.asList(checkArity, methodNode));
 
-            if (method.returnsEnumeratorIfNoBlock()) {
+
+            if (!method.enumeratorSize().isEmpty()) {
+                assert !method.returnsEnumeratorIfNoBlock(): "Only one of enumeratorSize or returnsEnumeratorIfNoBlock can be specified";
+                // TODO BF 6-27-2015 Handle multiple method names correctly
+                sequence = new EnumeratorSizeNode(method.enumeratorSize(), method.names()[0], sequence);
+            } else if (method.returnsEnumeratorIfNoBlock()) {
                 // TODO BF 3-18-2015 Handle multiple method names correctly
                 sequence = new ReturnEnumeratorIfNoBlockNode(method.names()[0], sequence);
             }

diff --git a/truffle/src/main/java/org/jruby/truffle/builtins/EnumeratorSizeNode.java b/truffle/src/main/java/org/jruby/truffle/builtins/EnumeratorSizeNode.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.builtins;
+
+import org.jruby.truffle.language.RubyNode;
+import org.jruby.truffle.language.SnippetNode;
+import org.jruby.truffle.language.arguments.RubyArguments;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.profiles.ConditionProfile;
+
+public class EnumeratorSizeNode extends RubyNode {
+
+    @Child private RubyNode method;
+    @Child private SnippetNode snippetNode;
+    private final ConditionProfile noBlockProfile = ConditionProfile.createBinaryProfile();
+    private final String snippet;
+
+    public EnumeratorSizeNode(String enumeratorSize, String methodName, RubyNode method) {
+        super(method.getContext(), method.getEncapsulatingSourceSection());
+        this.method = method;
+        this.snippet = "to_enum(:" + methodName + ") { " + enumeratorSize + " }";
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        final DynamicObject block = RubyArguments.getBlock(frame);
+
+        if (noBlockProfile.profile(block == null)) {
+            if (snippetNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                snippetNode = insert(new SnippetNode());
+            }
+            return snippetNode.execute(frame, snippet);
+        } else {
+            return method.execute(frame);
+        }
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/core/array/ArrayNodes.java b/truffle/src/main/java/org/jruby/truffle/core/array/ArrayNodes.java
@@ -791,7 +791,7 @@ public Object deleteAt(DynamicObject array, int index,
 
     }
 
-    @CoreMethod(names = "each", needsBlock = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = "each", needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
     public abstract static class EachNode extends YieldingCoreMethodNode {
 
@@ -827,7 +827,7 @@ public Object eachOther(VirtualFrame frame, DynamicObject array, DynamicObject b
 
     }
 
-    @CoreMethod(names = "each_with_index", needsBlock = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = "each_with_index", needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
     public abstract static class EachWithIndexNode extends YieldingCoreMethodNode {
 
@@ -1196,7 +1196,7 @@ public Object injectSymbolHelper(VirtualFrame frame, DynamicObject array, Dynami
 
     }
 
-    @CoreMethod(names = { "map", "collect" }, needsBlock = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = { "map", "collect" }, needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
     public abstract static class MapNode extends YieldingCoreMethodNode {
 
@@ -1230,7 +1230,7 @@ public Object map(VirtualFrame frame, DynamicObject array, DynamicObject block,
 
     }
 
-    @CoreMethod(names = { "map!", "collect!" }, needsBlock = true, returnsEnumeratorIfNoBlock = true, raiseIfFrozenSelf = true)
+    @CoreMethod(names = { "map!", "collect!" }, needsBlock = true, enumeratorSize = "size", raiseIfFrozenSelf = true)
     @ImportStatic(ArrayGuards.class)
     public abstract static class MapInPlaceNode extends YieldingCoreMethodNode {
 
@@ -1742,7 +1742,7 @@ public DynamicObject pushMany(VirtualFrame frame, DynamicObject array, Object va
 
     }
 
-    @CoreMethod(names = "reject", needsBlock = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = "reject", needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
     public abstract static class RejectNode extends YieldingCoreMethodNode {
 
@@ -1781,7 +1781,7 @@ public Object rejectOther(VirtualFrame frame, DynamicObject array, DynamicObject
 
     }
 
-    @CoreMethod(names = "delete_if" , needsBlock = true, returnsEnumeratorIfNoBlock = true, raiseIfFrozenSelf = true)
+    @CoreMethod(names = "delete_if" , needsBlock = true, enumeratorSize = "size", raiseIfFrozenSelf = true)
     @ImportStatic(ArrayGuards.class)
     public abstract static class DeleteIfNode extends YieldingCoreMethodNode {
 
@@ -1799,7 +1799,7 @@ protected RejectInPlaceNode createRejectInPlaceNode() {
     }
 
 
-    @CoreMethod(names = "reject!", needsBlock = true, returnsEnumeratorIfNoBlock = true, raiseIfFrozenSelf = true)
+    @CoreMethod(names = "reject!", needsBlock = true, enumeratorSize = "size", raiseIfFrozenSelf = true)
     @ImportStatic(ArrayGuards.class)
     public abstract static class RejectInPlaceNode extends YieldingCoreMethodNode {
 
@@ -1881,7 +1881,7 @@ public DynamicObject replace(DynamicObject array, DynamicObject other,
 
     }
 
-    @CoreMethod(names = "select", needsBlock = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = "select", needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
     public abstract static class SelectNode extends YieldingCoreMethodNode {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/core/hash/HashNodes.java b/truffle/src/main/java/org/jruby/truffle/core/hash/HashNodes.java
@@ -51,6 +51,7 @@
 import java.util.Arrays;
 import java.util.Map;
 
+
 @CoreClass("Hash")
 public abstract class HashNodes {
 
@@ -581,7 +582,7 @@ public Object delete(VirtualFrame frame, DynamicObject hash, Object key, Object
 
     }
 
-    @CoreMethod(names = { "each", "each_pair" }, needsBlock = true)
+    @CoreMethod(names = { "each", "each_pair" }, needsBlock = true, enumeratorSize = "size")
     @ImportStatic(HashGuards.class)
     public abstract static class EachNode extends YieldingCoreMethodNode {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/core/range/RangeNodes.java b/truffle/src/main/java/org/jruby/truffle/core/range/RangeNodes.java
@@ -41,6 +41,7 @@
 import org.jruby.truffle.language.objects.AllocateObjectNode;
 import org.jruby.truffle.language.objects.AllocateObjectNodeGen;
 
+
 @CoreClass("Range")
 public abstract class RangeNodes {
 
@@ -82,7 +83,7 @@ public DynamicObject map(
 
     }
 
-    @CoreMethod(names = "each", needsBlock = true, lowerFixnumSelf = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = "each", needsBlock = true, lowerFixnumSelf = true, enumeratorSize = "size")
     public abstract static class EachNode extends YieldingCoreMethodNode {
 
         @Child private CallDispatchHeadNode eachInternalCall;

diff --git a/truffle/src/main/java/org/jruby/truffle/core/string/StringNodes.java b/truffle/src/main/java/org/jruby/truffle/core/string/StringNodes.java
@@ -1020,7 +1020,7 @@ private boolean multiByteDowncase(Encoding encoding, byte[] bytes, int s, int en
         }
     }
 
-    @CoreMethod(names = "each_byte", needsBlock = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = "each_byte", needsBlock = true, enumeratorSize = "bytesize")
     public abstract static class EachByteNode extends YieldingCoreMethodNode {
 
         @Specialization
@@ -1044,7 +1044,7 @@ public DynamicObject eachByte(VirtualFrame frame, DynamicObject string, DynamicO
 
     }
 
-    @CoreMethod(names = "each_char", needsBlock = true, returnsEnumeratorIfNoBlock = true)
+    @CoreMethod(names = "each_char", needsBlock = true, enumeratorSize = "size")
     @ImportStatic(StringGuards.class)
     public abstract static class EachCharNode extends YieldingCoreMethodNode {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/platform/DefaultRubiniusConfiguration.java b/truffle/src/main/java/org/jruby/truffle/platform/DefaultRubiniusConfiguration.java
@@ -57,8 +57,6 @@ public abstract class DefaultRubiniusConfiguration {
     public static final int SIZE_OF_POINTER = 8;
 
     public static void load(RubiniusConfiguration configuration, RubyContext context) {
-        configuration.config("hash.hamt", false);
-
         configuration.config("rbx.platform.file.S_IRUSR", FileStat.S_IRUSR);
         configuration.config("rbx.platform.file.S_IWUSR", FileStat.S_IWUSR);
         configuration.config("rbx.platform.file.S_IXUSR", FileStat.S_IXUSR);
@@ -81,15 +79,15 @@ public static void load(RubiniusConfiguration configuration, RubyContext context
         configuration.config("rbx.platform.file.S_ISVTX", FileStat.S_ISVTX);
 
         for (Fcntl fcntl : Fcntl.values()) {
-            if (fcntl.defined() && fcntl.name().startsWith("F_")) {
+            if (fcntl.defined()) {
                 configuration.config("rbx.platform.fcntl." + fcntl.name(), fcntl.intValue());
             }
         }
 
         configuration.config("rbx.platform.fcntl.FD_CLOEXEC", 1); // TODO BJF 15-May-2015 Get from JNR constants or stdlib FFI
 
         for (OpenFlags openFlag : OpenFlags.values()) {
-            if (openFlag.defined() && openFlag.name().startsWith("O_")) {
+            if (openFlag.defined()) {
                 configuration.config("rbx.platform.file." + openFlag.name(), openFlag.intValue());
             }
         }

diff --git a/truffle/src/main/ruby/core/array.rb b/truffle/src/main/ruby/core/array.rb
diff --git a/truffle/src/main/ruby/core/hash.rb b/truffle/src/main/ruby/core/hash.rb
@@ -32,10 +32,19 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-unless Rubinius::Config['hash.hamt']
 class Hash
   include Enumerable
 
+  def self.contains_all_internal(one, two)
+    one.all? do |key, value|
+      begin
+        value === two.fetch(key)
+      rescue KeyError
+        false
+      end
+    end
+  end
+
   def self.new_from_associate_array(associate_array)
     hash = new
     associate_array.each do |array|
@@ -95,6 +104,19 @@ def self._constructor_fallback(*args)
   # Used internally to get around subclasses redefining #[]=
   alias_method :__store__, :[]=
 
+  def <(other)
+     other = Rubinius::Type.coerce_to(other, Hash, :to_hash)
+     return false if self.size >= other.size
+     self.class.contains_all_internal(self, other)
+  end
+
+  def <=(other)
+    other = Rubinius::Type.coerce_to(other, Hash, :to_hash)
+    return false if self.size > other.size
+    self.class.contains_all_internal(self, other)
+  end
+
+
   def ==(other)
     return true if self.equal? other
     unless other.kind_of? Hash
@@ -122,6 +144,18 @@ def ==(other)
     true
   end
 
+  def >(other)
+    other = Rubinius::Type.coerce_to(other, Hash, :to_hash)
+    return false if self.size <= other.size
+    self.class.contains_all_internal(other, self)
+  end
+
+  def >=(other)
+    other = Rubinius::Type.coerce_to(other, Hash, :to_hash)
+    return false if self.size < other.size
+    self.class.contains_all_internal(other, self)
+  end
+
   def assoc(key)
     each_item { |e| return e.key, e.value if key == e.key }
   end
@@ -431,6 +465,10 @@ def to_hash
     self
   end
 
+  def to_proc
+    lambda { |key| self[key] }
+  end
+
   # Implementation of a fundamental Rubinius method that allows their Hash
   # implementation to work. We probably want to remove uses of this in the long
   # term, as it creates objects which already exist for them and we have to
@@ -483,4 +521,3 @@ def reject(&block)
   end
 
 end
-end
Original file line number	Diff line number	Diff line change
		@@ -1,2 +1 @@
		fails:Hash#each_pair properly expands (or not) child class's 'each'-yielded args
		fails:Hash#each_pair when no block is given returned Enumerator size returns the enumerable size
Original file line number	Diff line number	Diff line change
		@@ -1,2 +1 @@
		fails:Hash#each properly expands (or not) child class's 'each'-yielded args
		fails:Hash#each when no block is given returned Enumerator size returns the enumerable size
Original file line number	Diff line number	Diff line change
		@@ -73,4 +73,6 @@

		UnsafeGroup[] unsafe() default {};

		String enumeratorSize() default "";

		}