Freeze singleton class chain

The following code:

```ruby
x = Object.new
sc1 = x.singleton_class
sc2 = sc1.singleton_class
x.freeze
```

Would freeze sc1 but not sc2, even though sc1 would be frozen.

Handle this by walking the class pointer chain for the object.
If the class is a singleton class, and it isn't frozen, and the
attached object for the singleton class is the object, the
singleton class should be frozen, and we move to the next iteration.

Fixes [Bug #20319]

Author: jeremyevans

class.c

@@ -2884,16 +2884,18 @@ singleton_class_of(VALUE obj, bool ensure_eigenclass)
 }
 
 void
-rb_freeze_singleton_class(VALUE x)
-{
-    /* should not propagate to meta-meta-class, and so on */
-    if (!RCLASS_SINGLETON_P(x)) {
-        VALUE klass = RBASIC_CLASS(x);
-        if (klass && // no class when hidden from ObjectSpace
-            FL_TEST_RAW(klass, FL_SINGLETON) &&
-            !OBJ_FROZEN_RAW(klass)) {
-            OBJ_FREEZE(klass);
-        }
+rb_freeze_singleton_class(VALUE attached_object)
+{
+    VALUE klass;
+
+    /* Freeze singleton classes of singleton class, as singleton class is frozen, and so on  */
+    /* In each iteration, check the current object's class pointer is the singleton class of the object. */
+    while ((klass = RBASIC_CLASS(attached_object)) &&
+                FL_TEST_RAW(klass, FL_SINGLETON) &&
+                !OBJ_FROZEN_RAW(klass) &&
+                (RCLASS_ATTACHED_OBJECT(klass) == attached_object)) {
+        attached_object = klass;
+        OBJ_FREEZE(attached_object);
     }
 }
 

test/ruby/test_object.rb

@@ -1025,6 +1025,48 @@ def test_singleton_class_freeze
     assert_predicate(ys, :frozen?, '[Bug #19169]')
   end
 
+  def test_singleton_class_of_singleton_class_freeze
+    x = Object.new
+    xs = x.singleton_class
+    xxs = xs.singleton_class
+    xxxs = xxs.singleton_class
+    x.freeze
+    assert_predicate(xs, :frozen?, '[Bug #20319]')
+    assert_predicate(xxs, :frozen?, '[Bug #20319]')
+    assert_predicate(xxxs, :frozen?, '[Bug #20319]')
+
+    m = Module.new
+    y = Object.new
+    ys = y.singleton_class
+    ys.prepend(Module.new)
+    yys = ys.singleton_class
+    yys.prepend(Module.new)
+    yyys = yys.singleton_class
+    yyys.prepend(Module.new)
+    y.freeze
+    assert_predicate(ys, :frozen?, '[Bug #20319]')
+    assert_predicate(yys, :frozen?, '[Bug #20319]')
+    assert_predicate(yyys, :frozen?, '[Bug #20319]')
+
+    c = Class.new
+    cs = c.singleton_class
+    ccs = cs.singleton_class
+    cccs = ccs.singleton_class
+    d = Class.new(c)
+    ds = d.singleton_class
+    dds = ds.singleton_class
+    ddds = dds.singleton_class
+    d.freeze
+    assert_predicate(d, :frozen?, '[Bug #20319]')
+    assert_predicate(ds, :frozen?, '[Bug #20319]')
+    assert_predicate(dds, :frozen?, '[Bug #20319]')
+    assert_predicate(ddds, :frozen?, '[Bug #20319]')
+    assert_not_predicate(c, :frozen?, '[Bug #20319]')
+    assert_not_predicate(cs, :frozen?, '[Bug #20319]')
+    assert_not_predicate(ccs, :frozen?, '[Bug #20319]')
+    assert_not_predicate(cccs, :frozen?, '[Bug #20319]')
+  end
+
   def test_redef_method_missing
     bug5473 = '[ruby-core:40287]'
     ['ArgumentError.new("bug5473")', 'ArgumentError, "bug5473"', '"bug5473"'].each do |code|