the superclass of a singleton class is the singleton class of the superclass

And i have tests to prove it!
That just rolls of the tongue, it had to be the commit message

lib/parfait/behaviour.rb

@@ -80,6 +80,7 @@ module Parfait
         tm = @instance_type.method_names
         raise "resolve_method #{name}.#{m_name} has #{tm}:#{method_names}"
       end
+      #puts "resolve #{m_name}:#{super_class}:"
       return nil unless( s_class = super_class )
       s_class.resolve_method(m_name)
     end

lib/parfait/singleton_class.rb

@@ -54,14 +54,17 @@ module Parfait
       @clazz.set_type(@instance_type)
     end
 
-    # Nil name means no superclass, and so nil returned
+    # the super class of a singleton classs is  the singleton class of the super class.
+    # In effect the single classes shadow the class tree, leading to the fact that
+    # a class method defined in a super_class is accessible to a derived class in
+    # much the same way as normal methods are accessible in (normal) derived classes.
     def super_class
-      return nil
+      @clazz.super_class.single_class if @clazz.super_class
     end
 
-    # no superclass, return nil to signal
+    # return the name of the superclass (see there)
     def super_class_name
-      nil
+      super_class.name if @clazz.super_class
     end
 
   end

lib/vool/send_statement.rb

@@ -44,6 +44,7 @@ module Vool
       @receiver = SelfExpression.new(compiler.receiver_type) if @receiver.is_a?(SelfExpression)
       if(@receiver.ct_type)
         method = @receiver.ct_type.get_method(@name)
+        #puts "Known #{@receiver.ct_type}: method #{method}"
         method = create_method_from_source(compiler) unless( method )
         return simple_call(compiler, method) if method
       end