Copy risc compiler stuff to mom

Start to separate the layers. 
wip, just checkin in to see the following changes better

lib/mom/callable_compiler.rb

@@ -1,8 +1,10 @@
 module Mom
 
-  # CallableCompiler is used to generate Mom instructions.
+  # CallableCompiler is used to generate mom instructions. It is an abstact base
+  # class shared by BlockCompiler and MethodCompiler
 
-  # - mom_instructions: The sequence of mom level instructions that vool was compiled to
+  # - mom_instructions: The sequence of mom level instructions that mom was compiled to
+  #                 Instructions derive from class Instruction and form a linked list
 
   class CallableCompiler
 
@@ -10,11 +12,11 @@ module Mom
       @callable = callable
       @constants = []
       @block_compilers = []
-      @mom_instructions = Risc.label(source_name, source_name)
+      @mom_instructions = Label.new(source_name, source_name)
       @current = start = @risc_instructions
-      add_code Risc.label( source_name, "return_label")
-      Mom::ReturnSequence.new.to_risc(self)
-      add_code Risc.label( source_name, "unreachable")
+      add_code Label.new( source_name, "return_label")
+      add_code Mom::ReturnSequence.new
+      add_code Label.new( source_name, "unreachable")
       @current = start
     end
     attr_reader :risc_instructions , :constants , :block_compilers , :callable , :current
@@ -26,20 +28,6 @@ module Mom
       end
     end
 
-    # convert the given mom instruction to_risc and then add it (see add_code)
-    # continue down the instruction chain unti depleted
-    # (adding moves the insertion point so the whole mom chain is added as a risc chain)
-    def add_mom( instruction )
-      while( instruction )
-        raise "whats this a #{instruction}" unless instruction.is_a?(Mom::Instruction)
-        #puts "adding mom #{instruction.to_s}:#{instruction.next.to_s}"
-        instruction.to_risc( self )
-        reset_regs
-        #puts "adding risc #{risc.to_s}:#{risc.next.to_s}"
-        instruction = instruction.next
-      end
-    end
-
     # add a constant (which get created during compilation and need to be linked)
     def add_constant(const)
       raise "Must be Parfait #{const}" unless const.is_a?(Parfait::Object)
@@ -49,18 +37,38 @@ module Mom
     # add a risc instruction after the current (insertion point)
     # the added instruction will become the new insertion point
     def add_code( instruction )
-      raise "Not an instruction:#{instruction.to_s}:#{instruction.class.name}" unless  instruction.is_a?(Risc::Instruction)
-      raise instruction.to_s if( instruction.class.name.split("::").first == "Arm")
+      raise "Not an instruction:#{instruction.to_s}:#{instruction.class.name}" unless  instruction.is_a?(Mom::Instruction)
       new_current = instruction.last #after insertion this point is lost
       @current.insert(instruction) #insert after current
       @current = new_current
       self
     end
 
+    # resolve the type of the slot, by inferring from it's name, using the type
+    # scope related slots are resolved by the compiler by method/block
+    def slot_type( slot , type)
+      case slot
+      when :frame
+        new_type = self.frame_type
+      when :arguments
+        new_type = self.arg_type
+      when :receiver
+        new_type = self.receiver_type
+      when Symbol
+        new_type = type.type_for(slot)
+        raise "Not found object #{slot}: in #{type}" unless new_type
+      else
+        raise "Not implemented object #{slot}:#{slot.class}"
+      end
+      #puts "RESOLVE in #{@type.class_name} #{slot}->#{type}"
+      return new_type
+    end
+
     # return the frame type, ie the blocks frame type
     def frame_type
       @callable.frame_type
     end
+
     # return the frame type, ie the blocks arguments type
     def arg_type
       @callable.arguments_type