class.c: do not freeze meta-meta-class

* class.c (rb_freeze_singleton_class): should not propagate to
  meta-meta-class, and so on, which is shared with the original
  class.  fix occational exceptions.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47633 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

3 files changed, 29 insertions, 6 deletions

diff --git a/class.c b/class.c
index d841328077..45e27d8c12 100644
--- a/class.c
+++ b/class.c
@@ -1578,6 +1578,19 @@ singleton_class_of(VALUE obj)
     return klass;
 }
 
+void
+rb_freeze_singleton_class(VALUE x)
+{
+    /* should not propagate to meta-meta-class, and so on */
+    if (!(RBASIC(x)->flags & FL_SINGLETON)) {
+	VALUE klass = RBASIC_CLASS(x);
+	klass = RCLASS_ORIGIN(klass);
+	if (FL_TEST(klass, (FL_SINGLETON|FL_FREEZE)) == FL_SINGLETON) {
+	    OBJ_FREEZE_RAW(klass);
+	}
+    }
+}
+
 /*!
  * Returns the singleton class of \a obj, or nil if obj is not a
  * singleton object.
diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h
index 4b57e7848b..f6dfd977eb 100644
--- a/include/ruby/ruby.h
+++ b/include/ruby/ruby.h
@@ -1108,14 +1108,15 @@ struct RStruct {
 #define OBJ_FREEZE_RAW(x) (RBASIC(x)->flags |= FL_FREEZE)
 #define OBJ_FREEZE(x) rb_obj_freeze_inline((VALUE)x)
 
+void rb_freeze_singleton_class(VALUE klass);
+
 static inline void
 rb_obj_freeze_inline(VALUE x)
 {
     if (FL_ABLE(x)) {
-	VALUE klass = RBASIC_CLASS(x);
 	OBJ_FREEZE_RAW(x);
-	if (FL_TEST(klass, (FL_SINGLETON|FL_FREEZE)) == FL_SINGLETON) {
-	    OBJ_FREEZE_RAW(klass);
+	if (!(RBASIC(x)->flags & FL_SINGLETON)) {
+	    rb_freeze_singleton_class(x);
 	}
     }
 }
diff --git a/test/ruby/test_module.rb b/test/ruby/test_module.rb
index 95758aa6d4..ce5ab2ff73 100644
--- a/test/ruby/test_module.rb
+++ b/test/ruby/test_module.rb
@@ -914,25 +914,34 @@ class TestModule < Test::Unit::TestCase
     assert_include(c.constants(false), :Foo, bug9413)
   end
 
-  def test_frozen_class
+  def test_frozen_module
     m = Module.new
     m.freeze
     assert_raise(RuntimeError) do
       m.instance_eval { undef_method(:foo) }
     end
+  end
 
+  def test_frozen_class
     c = Class.new
     c.freeze
     assert_raise(RuntimeError) do
       c.instance_eval { undef_method(:foo) }
     end
+  end
 
-    o = Object.new
+  def test_frozen_singleton_class
+    klass = Class.new
+    o = klass.new
     c = class << o; self; end
     c.freeze
-    assert_raise(RuntimeError) do
+    assert_raise_with_message(RuntimeError, /frozen/) do
       c.instance_eval { undef_method(:foo) }
     end
+    klass.class_eval do
+      def self.foo
+      end
+    end
   end
 
   def test_method_defined