improve tests

lib/bosl/compiler/basic_expressions.rb

@@ -11,66 +11,38 @@ module Bosl
     # The current approach moves the constant into a variable before using it
     # But in the future (in the one that holds great things) we optimize those unneccesay moves away
 
-  #    attr_reader :value
-      def on_int expression
-        int = expression.first
-        to =  Virtual::Return.new(Virtual::Integer , int)
-        method.source.add_code Virtual::Set.new( int , to )
-        to
-      end
+    def on_int expression
+      int = expression.first
+      to =  Virtual::Return.new(Virtual::Integer , int)
+      method.source.add_code Virtual::Set.new( int , to )
+      to
+    end
 
-      def on_true expression
-        to = Virtual::Return.new(Virtual::Reference , true )
-        method.source.add_code Virtual::Set.new( true , to )
-        to
-      end
+    def on_true expression
+      to = Virtual::Return.new(Virtual::Reference , true )
+      method.source.add_code Virtual::Set.new( true , to )
+      to
+    end
 
-      def on_false expression
-        to = Virtual::Return.new(Virtual::Reference , false)
-        method.source.add_code Virtual::Set.new( false , to )
-        to
-      end
+    def on_false expression
+      to = Virtual::Return.new(Virtual::Reference , false)
+      method.source.add_code Virtual::Set.new( false , to )
+      to
+    end
 
-      def on_nil expression
-        to = Virtual::Return.new(Virtual::Reference , nil)
-        method.source.add_code Virtual::Set.new( nil , to )
-        to
-      end
-
-      def on_modulename expression
-        clazz = Parfait::Space.object_space.get_class_by_name expression.name
-        raise "compile_modulename #{clazz}.#{name}" unless clazz
-        to = Virtual::Return.new(Virtual::Reference , clazz )
-        method.source.add_code Virtual::Set.new( clazz , to )
-        to
-      end
-
-  #    attr_reader  :string
-      def on_string expression
-        # Clearly a TODO here to implement strings rather than reusing symbols
-        value = expression.first.to_sym
-        to = Virtual::Return.new(Virtual::Reference , value)
-        method.source.constants << value
-        method.source.add_code Virtual::Set.new( value , to )
-        to
-      end
-
-      #attr_reader  :left, :right
-      def on_assignment expression
-        unless expression.left.instance_of? Ast::NameExpression
-          raise "must assign to NameExpression , not #{expression.left}"
-        end
-        r = process(expression.right  )
-        raise "oh noo, nil from where #{expression.right.inspect}" unless r
-        index = method.has_arg(expression.left.name.to_sym)
-        if index
-          method.source.add_code Virtual::Set.new(ArgSlot.new(index , r.type , r ) , Virtual::Return.new)
-        else
-          index = method.ensure_local(expression.left.name.to_sym)
-          method.source.add_code Virtual::Set.new(FrameSlot.new(index , r.type , r ) , Virtual::Return.new)
-        end
-        r
-      end
+    def on_nil expression
+      to = Virtual::Return.new(Virtual::Reference , nil)
+      method.source.add_code Virtual::Set.new( nil , to )
+      to
+    end
 
+    def on_string expression
+      # Clearly a TODO here to implement strings rather than reusing symbols
+      value = expression.first.to_sym
+      to = Virtual::Return.new(Virtual::Reference , value)
+      method.source.constants << value
+      method.source.add_code Virtual::Set.new( value , to )
+      to
+    end
   end
 end

lib/bosl/compiler/compound_expressions.rb

@@ -3,14 +3,11 @@ module Bosl
 
 #    attr_reader :values
     def on_array expession, context
-      raise "not implemented"
     end
 #    attr_reader :key , :value
     def on_association context
-      raise "not implemented"
     end
     def on_hash context
-      raise "not implemented"
     end
   end
 end

lib/bosl/compiler/module_expression.rb

@@ -2,7 +2,8 @@ module Bosl
   Compiler.class_eval do
 #    module attr_reader  :name ,:expressions
     def on_module expression
-      return clazz
+      name , rest = *expression
+      return process_all(rest).last
     end
 
     def on_class expression