Ticket #142: 142.patch

vm_insnhelper.c

@@ -1470 +1470 @@
     static ID idNew = 0, idNew2 = 0, idNew3 = 0;
     CFMutableDictionaryRef iv_dict;
     VALUE ary, k;
+    int looked_up = 0;
   
     if (idNew == 0) {
         idNew = rb_intern("new");
@@ -1512 +1513 @@
                                          (const void **)&k)) {
         CFDictionaryRemoveValue(iv_dict, (const void *)idPreviousKlass);
         klass = k;
+    } else if(RCLASS_MODULE(klass)) {
+        /* If klass is a module, and it has not previously had the idPreviousKlass
+         * variable set in it, then we're in a module that is itself calling super,
+         * and which was not reached via super. E.g.:
+         *
+         *   module A
+         *      def initialize
+         *        super # <--- RIGHT HERE
+         *      end
+         *   end
+         *
+         *   class B
+         *     include A
+         *   end
+         *
+         *   B.new
+         *
+         * In this case, look at the ancestors of the receiver's class, find which
+         * ancestor we're looking at, and then find the *next* ancestor in the list
+         * as the superclass. If that next ancestor is also a module, duplicate the
+         * behavior above and set idPreviousKlass. (This should be refactored out
+         * to avoid duplication.)
+         */
+        k = CLASS_OF(recv);
+        ary = rb_funcall(k, rb_intern("ancestors"), 0);
+        int i, count = RARRAY_LEN(ary);
+        for (i = 0; !looked_up && i < count-1; i++) {
+            VALUE ancestor = RARRAY_AT(ary, i);
+
+            if(ancestor == klass) {
+                int j;
+                for (j = i+1; !looked_up && j < count; j++) {
+                    k = RARRAY_AT(ary, j);
+                    if(!RCLASS_MODULE(k)) {
+                        looked_up = 1;
+                    } else {
+                        VALUE saved_imod_super;
+                        NODE *mn;
+                        IMP imp;
+                        SEL sel;
+
+                        saved_imod_super = RCLASS_SUPER(k);
+                        RCLASS_SUPER(k) = 0;
+                        mn = rb_objc_method_node(k, mid, &imp, &sel);
+                        RCLASS_SUPER(k) = saved_imod_super;
+                        if (imp != NULL) {
+                            rb_ivar_set(k, idPreviousKlass, klass);
+                            *mnp = mn;
+                            *impp = imp;
+                            *selp = sel;
+                            return k;
+                        }
+                    }
+                }
+            }
+        }
     }
 
-    k = vm_search_normal_superclass(klass, recv);
+    if(!looked_up)
+        k = vm_search_normal_superclass(klass, recv);
    
     /* because #new is added on every new NSObject subclasses, and if overriden
        we should still call our implementation with super */