first tests comping through after ast/compile change

lib/compiler/basic_expressions.rb

@@ -11,28 +11,28 @@ module Compiler
   # But in the future (in the one that holds great things) we optimize those unneccesay moves away
 
 #    attr_reader :value
-    def compile_integer expession , method , message
+    def self.compile_integer expession , method , message
       int = Virtual::IntegerConstant.new(value)
       to = Virtual::NewReturn.new(Virtual::Integer , int)
       method.add_code Virtual::Set.new( to , int)
       to
     end
 
-    def compile_true expession , method , message
+    def self.compile_true expession , method , message
       value = Virtual::TrueConstant.new
       to = Virtual::Return.new(Virtual::Reference , value)
       method.add_code Virtual::Set.new( to , value )
       to
     end
 
-    def compile_false expession , method , message
+    def self.compile_false expession , method , message
       value = Virtual::FalseConstant.new
       to = Virtual::Return.new(Virtual::Reference , value)
       method.add_code Virtual::Set.new( to , value )
       to
     end
 
-    def compile_nil expession , method , message
+    def self.compile_nil expession , method , message
       value = Virtual::NilConstant.new
       to = Virtual::Return.new(Virtual::Reference , value)
       method.add_code Virtual::Set.new( to , value )
@@ -43,7 +43,7 @@ module Compiler
     # compiling name needs to check if it's a variable and if so resolve it
     # otherwise it's a method without args and a send is ussued.
     # this makes the namespace static, ie when eval and co are implemented method needs recompilation
-    def compile_name expession , method , message
+    def self.compile_name expession , method , message
       return Virtual::Self.new( Virtual::Mystery ) if expession.name == :self
       if method.has_var(expession.name)
         message.compile_get(method , expession.name )
@@ -54,7 +54,7 @@ module Compiler
     end
 
 
-    def compile_module expession , method , message
+    def self.compile_module expession , method , message
       clazz = Virtual::BootSpace.space.get_or_create_class name
       raise "uups #{clazz}.#{name}" unless clazz
       to = Virtual::Return.new(Virtual::Reference , clazz )
@@ -63,7 +63,7 @@ module Compiler
     end
 
 #    attr_reader  :string
-    def compile_string expession , method , message
+    def self.compile_string expession , method , message
       value = Virtual::StringConstant.new(expession.string)
       to = Virtual::Return.new(Virtual::Reference , value)
       Virtual::BootSpace.space.add_object value
@@ -72,14 +72,14 @@ module Compiler
     end
 
     #attr_reader  :left, :right
-    def compile_assignment expession , method , message
+    def self.compile_assignment expession , method , message
       raise "must assign to NameExpression , not #{expession.left}" unless expession.left.instance_of? NameExpression
       r = right.compile(method,message)
       raise "oh noo, nil from where #{expession.right.inspect}" unless r
       message.compile_set( method , expession.left.name , r )
     end
 
-    def compile_variable expession, method , message
+    def self.compile_variable expession, method , message
       method.add_code Virtual::InstanceGet.new(expession.name)
       Virtual::NewReturn.new( Virtual::Mystery )
     end

lib/compiler/call_site_expression.rb

@@ -3,7 +3,7 @@ module Compiler
 
 #    call_site - attr_reader  :name, :args , :receiver
 
-    def compile_call_site expession , method , message
+    def self.compile_call_site expession , method , message
       me = expession.receiver.compile( method, message )
       method.add_code Virtual::NewMessage.new
       method.add_code Virtual::Set.new(Virtual::NewSelf.new(me.type), me)

lib/compiler/compound_expressions.rb

@@ -1,14 +1,14 @@
 module Compiler
 
 #    attr_reader :values
-    def compile_array expession, context
+    def self.compile_array expession, context
       to.do
     end
 #    attr_reader :key , :value
-    def compile_association context
+    def self.compile_association context
       to.do
     end
-    def compile_hash context
+    def self.compile_hash context
       to.do
     end
 end

lib/compiler/expression_list.rb

@@ -1,6 +1,8 @@
 module Compiler
 #    list - attr_reader  :expressions
-    def compile_list expession , method , message
-      expession.expressions.collect { |part|  part.compile( method, message ) }
+    def self.compile_list expession , method , message
+      expession.expressions.collect do |part|
+        Compiler.compile(  part , method, message )
+      end
     end
 end

lib/compiler/function_expression.rb

@@ -1,6 +1,6 @@
 module Compiler
 #    function attr_reader  :name, :params, :body , :receiver
-    def compile_function  expression, method , message
+    def self.compile_function  expression, method , message
       args = expession.params.collect do |p|
         raise "error, argument must be a identifier, not #{p}" unless p.is_a? NameExpression
         p.name

lib/compiler/if_expression.rb

@@ -1,7 +1,7 @@
 module Compiler
 #    if - attr_reader  :cond, :if_true, :if_false
 
-    def compile_if expression , method , message
+    def self.compile_if expression , method , message
       # to execute the logic as the if states it, the blocks are the other way around
       # so we can the jump over the else if true ,and the else joins unconditionally after the true_block
       merge_block = method.new_block "if_merge"    # last one, created first

lib/compiler/module_expression.rb

@@ -1,10 +1,10 @@
 module Compiler
 #    module attr_reader  :name ,:expressions
-    def compile_module expression , context
+    def self.compile_module expression , context
       return clazz
     end
 
-    def compile_class expression , method , message
+    def self.compile_class expression , method , message
       clazz = ::Virtual::BootSpace.space.get_or_create_class name
       puts "Created class #{clazz.name.inspect}"
       expression.expressions.each do |expr|

lib/compiler/operator_expressions.rb

@@ -1,6 +1,6 @@
 module Compiler
 #    operator attr_reader  :operator, :left, :right
-    def compile_operator expression, method , message
+    def self.compile_operator expression, method , message
       call = CallSiteExpression.new( operator , [right] , left )
       call.compile(method,message)
     end

lib/compiler/return_expression.rb

@@ -1,7 +1,7 @@
 module Compiler
 
 #    return attr_reader  :expression
-    def compile_return expression, scope ,method
+    def self.compile_return expression, scope ,method
       Virtual::Reference.new
     end
     def old

lib/compiler/while_expression.rb

@@ -1,7 +1,7 @@
 module Compiler
 
 #    while- attr_reader  :condition, :body
-    def compile_while expression, method , message
+    def self.compile_while expression, method , message
       start = Virtual::Label.new("while_start")
       method.add_code start
       is = expression.condition.compile(method,message)