def __init__(self, space, name, superclass, is_singleton=False):
        W_ModuleObject.__init__(self, space, name)
        self.superclass = superclass
        self.is_singleton = is_singleton

        if self.superclass is not None:
            self.superclass.inherited(space, self)
            # During bootstrap, we cannot create singleton classes, yet
            if not self.is_singleton and not space.bootstrap:
                self.getsingletonclass(space)

 def ancestors(self, include_singleton=True, include_self=True):
     assert include_self
     ary = W_ModuleObject.ancestors(self,
         include_singleton, not (self.is_singleton and not include_singleton)
     )
     if self.superclass is not None:
         ary += self.superclass.ancestors(include_singleton)
     return ary

 def methods(self, space, inherit=True):
     methods = {}
     for name in W_ModuleObject.methods(self, space, inherit):
         methods[name] = None
     if inherit and self.superclass is not None:
         for name in self.superclass.methods(space, inherit):
             method = self._find_method_pure(space, name, self.version)
             if method is None or not isinstance(method, UndefMethod):
                 methods[name] = None
     return methods.keys()

    def inherited_constants(self, space):
        consts = {}
        for const in W_ModuleObject.local_constants(self, space):
            consts[const] = None
        w_cls = self.superclass
        while w_cls is not None:
            for const in w_cls.local_constants(space):
                consts[const] = None
            w_cls = w_cls.superclass

        return consts.keys()

 def find_method_super(self, space, name):
     method = W_ModuleObject.find_method_super(self, space, name)
     if method is None and self.superclass is not None:
         method = self.superclass.find_method(space, name)
     return method

 def find_const(self, space, name):
     w_res = W_ModuleObject.find_included_const(self, space, name)
     if w_res is None and self.superclass is not None:
         w_res = self.superclass.find_const(space, name)
     return w_res

 def method_undefined(self, space, w_name):
     if self.is_singleton:
         space.send(self.attached, "singleton_method_undefined", [w_name])
     else:
         W_ModuleObject.method_undefined(self, space, w_name)