setup to resolve method dynamically

lib/vool/statements/send_statement.rb

@@ -1,10 +1,21 @@
 module Vool
+  # Sending in a dynamic language is off course not as simple as just calling.
+  # The function that needs to be called depends after all on the receiver,
+  # and no guarantees can be made on what that is.
+  #
+  # It helps to know that usually (>99%) the class of the receiver does not change.
+  # Our stategy then is to cache the functions and only dynamically determine it in
+  # case of a miss (the 1%, and first invocation)
+  #
+  # As cache key we must use the type of the object (which is the first word of _every_ object)
+  # as that is constant, and function implementations depend on the type (not class)
   class SendStatement < Statement
     attr_reader :name , :receiver , :arguments
 
     def initialize(name , receiver , arguments )
       @name , @receiver , @arguments = name , receiver , arguments
       @arguments ||= []
+      @dynamic = nil
     end
 
     def collect(arr)
@@ -15,17 +26,6 @@ module Vool
       super
     end
 
-    # Sending in a dynamic language is off course not as simple as just calling.
-    # The function that needs to be called depends after all on the receiver,
-    # and no guarantees can be made on what that is.
-    #
-    # It helps to know that usually (>99%) the class of the receiver does not change.
-    # Our stategy then is to cache the functions and only dynamically determine it in
-    # case of a miss (the 1%, and first invocation)
-    #
-    # As cache key we must use the type of the object (which is the first word of _every_ object)
-    # as that is constant, and function implementations depend on the type (not class)
-    #
     # A Send breaks down to 2 steps:
     # - Setting up the next message, with receiver, arguments, and (importantly) return address
     # - a CachedCall , or a SimpleCall, depending on wether the receiver type can be determined
@@ -63,7 +63,6 @@ module Vool
     # - check the cached type and if neccessary update
     # - call the cached method
     def cached_call(in_method)
-      create_tmps(in_method)
       Mom::Statements.new( cache_check(in_method) + call_cached_method(in_method) )
     end
 
@@ -78,7 +77,7 @@ module Vool
       # if cached_type != current_type
       #   cached_type = current_type
       #   cached_method = current_type.resolve_method(method.name)
-      if_true = [build_type_cache_update , build_method_cache_update]
+      if_true = [*build_type_cache_update , *build_method_cache_update(in_method)]
       #@if_true.to_mom( in_method ) #find and assign
       [Mom::IfStatement.new( build_condition , if_true )]
     end
@@ -86,34 +85,24 @@ module Vool
     # this may look like a simple_call, but the difference is that we don't know
     # the method until run-time. Alas the setup is the same
     def call_cached_method(in_method)
-      message_setup(in_method) << Mom::DynamicCall.new(method_var_name)
-    end
-    private
-    # cached type and method are stored in the frame as local variables.
-    # this creates the varables in the frame. Names are method_var_name and type_var_name
-    def create_tmps(in_method)
-      in_method.create_tmp
+      @dynamic = Mom::DynamicCall.new()
+      message_setup(in_method) << @dynamic
     end
 
-    # we store the (one!) cached mathod in the frame, under the name that this
-    # method returns
-    def method_var_name
-       "cached_method_#{object_id}"
-    end
-    def type_var_name
-       "cached_type_#{object_id}"
-    end
     private
     def build_condition
-      cached_type = Mom::SlotDefinition.new(:message , [:frame , type_var_name])
+      cached_type = Mom::SlotDefinition.new(@dynamic , [:cached_type])
       current_type = Mom::SlotDefinition.new(:message , [:self , :type])
       Mom::NotSameCheck.new(cached_type , current_type)
     end
     def build_type_cache_update
-      1
+      [Mom::SlotMove.new([@dynamic, :cached_type] , [:self , :type])]
     end
-    def build_method_cache_update
-      1
+    def build_method_cache_update(in_method)
+      receiver = StringStatement.new(@name)
+      resolve = SendStatement.new(:resolve_method , receiver , [SelfStatement.new])
+      move_method = Mom::SlotMove.new([@dynamic, :cached_method] , [:self , :return])
+      resolve.to_mom(in_method) << move_method
     end
   end
 end