renames Typed to Vm

test/vm/method_compiler/helper.rb

@@ -0,0 +1,78 @@
+require_relative '../helper'
+
+module Register
+  module ExpressionHelper
+
+    def check
+      Register.machine.boot unless Register.machine.booted
+      compiler = Vm::MethodCompiler.new Parfait.object_space.get_main
+      code = Vm.ast_to_code @input
+      assert code.to_s , @input
+      produced = compiler.process( code )
+      assert @output , "No output given"
+      assert_equal produced.class , @output , "Wrong class"
+      produced
+    end
+
+    # test hack to in place change object type
+    def add_space_field(name,type)
+      class_type = Parfait.object_space.get_class_by_name(:Space).instance_type
+      class_type.send(:private_add_instance_variable, name , type)
+    end
+  end
+
+  module Statements
+    include AST::Sexp
+    include Compiling
+
+    def setup
+      Register.machine.boot # force boot to reset main
+    end
+
+    def preamble
+      [Label, SlotToReg , LoadConstant, RegToSlot, LoadConstant,RegToSlot, LoadConstant, SlotToReg, SlotToReg ]
+    end
+    def postamble
+      [ Label, FunctionReturn]
+    end
+    def check_nil
+      assert @expect , "No output given"
+      compiler = Vm::MethodCompiler.new
+      code = Vm.ast_to_code( @input )
+      assert code.to_s , @input
+      produced = compiler.process( code )
+      produced = Parfait.object_space.get_main.instructions
+      compare_instructions produced , @expect
+    end
+    def check_return
+      was = check_nil
+      raise was if was
+      Parfait.object_space.get_main.instructions
+    end
+
+    def compare_instructions( instruction , expect )
+      index = 0
+      all = instruction.to_arr
+      full_expect = preamble + expect + postamble
+      full_expect =  expect
+      begin
+        should = full_expect[index]
+        return "No instruction at #{index}" unless should
+        return "Expected at #{index+1}\n#{should(all)}" unless instruction.class == should
+        index += 1
+        instruction = instruction.next
+      end while( instruction )
+      nil
+    end
+    def should( all )
+      #preamble.each {all.shift}
+      #postamble.each {all.pop}
+      str = all.to_s.gsub("Register::","")
+      ret = ""
+      str.split(",").each_slice(6).each do |line|
+        ret += "                " + line.join(",") + " ,\n"
+      end
+      ret
+    end
+  end
+end

test/vm/method_compiler/test_all.rb

@@ -0,0 +1,13 @@
+#statements
+require_relative "test_assignment"
+require_relative "test_call_site"
+require_relative "test_class"
+require_relative "test_fields"
+require_relative "test_if_statement"
+require_relative "test_return_statement"
+require_relative "test_while_statement"
+#expressions
+require_relative "test_basic_values"
+require_relative "test_field_access"
+require_relative "test_operator_expression"
+require_relative "test_name_expression"

test/vm/method_compiler/test_assignment.rb

@@ -0,0 +1,105 @@
+require_relative 'helper'
+
+module Register
+  class TestAssignStatement < MiniTest::Test
+    include Statements
+
+    def test_assign_op
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+
+      @input    = s(:statements, s(:assignment, s(:name, :r), s(:operator_value, :+, s(:int, 10), s(:int, 1))))
+
+      @expect = [Label, LoadConstant, LoadConstant, OperatorInstruction, SlotToReg, RegToSlot ,
+                 LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_assign_local
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input =s(:statements, s(:assignment, s(:name, :r), s(:int, 5)))
+
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_assign_local_assign
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+
+      @input = s(:statements, s(:assignment, s(:name, :r), s(:int, 5)))
+
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+               RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_assign_call
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input = s(:statements, s(:assignment, s(:name, :r), s(:call, s(:name, :main), s(:arguments))))
+      @expect = [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, RegToSlot ,
+               LoadConstant, SlotToReg, RegToSlot, LoadConstant, RegToSlot, RegisterTransfer ,
+               FunctionCall, Label, RegisterTransfer, SlotToReg, SlotToReg, SlotToReg ,
+               RegToSlot, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_named_list_get
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input = s(:statements, s(:assignment, s(:name, :r), s(:int, 5)), s(:return, s(:name, :r)))
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, SlotToReg, SlotToReg ,
+                 RegToSlot, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      was = check_return
+      get = was.next(5)
+      assert_equal SlotToReg , get.class
+      assert_equal 1 + 1, get.index , "Get to named_list index must be offset, not #{get.index}"
+    end
+
+    def test_assign_local_int
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input = s(:statements, s(:assignment, s(:name, :r), s(:int, 5)) )
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      was = check_return
+      set = was.next(3)
+      assert_equal RegToSlot , set.class
+      assert_equal 1 + 1, set.index , "Set to named_list index must be offset, not #{set.index}"
+    end
+
+    def test_misassign_local
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input = s(:statements, s(:assignment, s(:name, :r), s(:string, "5")) )
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_raises {check }
+    end
+
+    def test_assign_arg
+      Parfait.object_space.get_main.add_argument(:blar , :Integer)
+      @input = s(:statements, s(:assignment, s(:name, :blar), s(:int, 5)))
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      was = check_return
+      set = was.next(3)
+      assert_equal RegToSlot , set.class
+      assert_equal 1 + 1, set.index , "Set to args index must be offset, not #{set.index}"
+    end
+
+    def test_misassign_arg
+      Parfait.object_space.get_main.add_argument(:blar , :Integer)
+      @input = s(:statements, s(:assignment, s(:name, :blar), s(:string, "5")))
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_raises {check }
+    end
+
+    def test_arg_get
+      # have to define bar externally, just because redefining main. Otherwise that would be automatic
+      Parfait.object_space.get_main.add_argument(:balr , :Integer)
+      @input = s(:statements, s(:return, s(:name, :balr)))
+      @expect = [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      was = check_return
+      get = was.next(2)
+      assert_equal SlotToReg , get.class
+      assert_equal 1 + 1, get.index , "Get to args index must be offset, not #{get.index}"
+    end
+  end
+end

test/vm/method_compiler/test_basic_values.rb

@@ -0,0 +1,41 @@
+require_relative "helper"
+
+module Register
+
+  class TestBasic < MiniTest::Test
+    include ExpressionHelper
+    include AST::Sexp
+
+    def setup
+      Register.machine.boot
+      @output = Register::RegisterValue
+    end
+
+    def test_number
+      @input    = s(:int , 42)
+      assert_equal 42 , check.value
+    end
+
+    def test_true
+      @input    = s(:true)
+      check
+    end
+    def test_false
+      @input    = s(:false)
+      check
+    end
+    def test_nil
+      @input    = s(:nil)
+      check
+    end
+    def test_self
+      @input    = s(:name, :self)
+      check
+    end
+    def test_string
+      @input    = s(:string , "hello")
+      check
+    end
+
+  end
+end

test/vm/method_compiler/test_call_expression.rb

@@ -0,0 +1,43 @@
+require_relative "helper"
+
+module Register
+  class TestCall < MiniTest::Test
+    include ExpressionHelper
+    include AST::Sexp
+
+    def setup
+      Register.machine.boot
+      @output = Register::RegisterValue
+    end
+
+    def test_call_main_plain
+      @input    = s(:call,s(:name, :main),s(:arguments))
+      check
+    end
+
+    def test_call_main_int
+      Parfait.object_space.get_main.add_argument(:blar , :Integer)
+      @input    =s(:call,s(:name, :main),s(:arguments , s(:int, 1)))
+      check
+    end
+
+    def test_call_main_string
+      Parfait.object_space.get_main.add_argument(:blar , :Word)
+      @input    =s(:call,s(:name, :main),s(:arguments , s(:string, "1") ))
+      check
+    end
+
+    def test_call_main_op
+      Parfait.object_space.get_main.add_local(:bar , :Integer)
+      Parfait.object_space.get_main.add_argument(:blar , :Integer)
+      @input    =s(:call,s(:name, :main),s(:arguments , s(:name, :bar) ))
+      check
+    end
+
+    def test_call_string_put
+      @input    = s(:call,s(:name, :putstring),s(:arguments),s(:receiver,s(:string, "Hello Raisa, I am salama")))
+      check
+    end
+
+  end
+end

test/vm/method_compiler/test_call_site.rb

@@ -0,0 +1,68 @@
+require_relative 'helper'
+require_relative "test_call_expression"
+
+module Register
+  class TestCallStatement < MiniTest::Test
+    include Statements
+
+    def test_call_constant_int
+      clean_compile :Integer, :puti, {}, s(:statements, s(:return, s(:int, 1)))
+      @input = s(:call, s(:name, :puti), s(:arguments), s(:receiver, s(:int, 42)))
+      @expect =  [Label, SlotToReg, LoadConstant, RegToSlot, LoadConstant, RegToSlot, LoadConstant ,
+                 SlotToReg, RegToSlot, LoadConstant, RegToSlot, RegisterTransfer, FunctionCall, Label ,
+                 RegisterTransfer, SlotToReg, SlotToReg, LoadConstant, SlotToReg, RegToSlot, Label ,
+                 FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+
+    def test_call_constant_string
+      clean_compile :Word, :putstr,{}, s(:statements, s(:return, s(:int, 1)))
+
+      @input =s(:call, s(:name, :putstr), s(:arguments), s(:receiver, s(:string, "Hello")))
+      @expect = [Label, SlotToReg, LoadConstant, RegToSlot, LoadConstant, RegToSlot, LoadConstant ,
+                 SlotToReg, RegToSlot, LoadConstant, RegToSlot, RegisterTransfer, FunctionCall, Label ,
+                 RegisterTransfer, SlotToReg, SlotToReg, LoadConstant, SlotToReg, RegToSlot, Label ,
+                 FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_call_local_int
+      Parfait.object_space.get_main.add_local(:testi , :Integer)
+      clean_compile :Integer, :putint, {}, s(:statements, s(:return, s(:int, 1)))
+      @input = s(:statements, s(:assignment, s(:name, :testi), s(:int, 20)), s(:call, s(:name, :putint), s(:arguments), s(:receiver, s(:name, :testi))))
+
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, SlotToReg, SlotToReg, SlotToReg ,
+                 RegToSlot, LoadConstant, RegToSlot, LoadConstant, SlotToReg, RegToSlot, LoadConstant ,
+                 RegToSlot, RegisterTransfer, FunctionCall, Label, RegisterTransfer, SlotToReg, SlotToReg ,
+                 LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_call_local_class
+      Parfait.object_space.get_main.add_local(:test_l , :List)
+      clean_compile :List, :add, {}, s(:statements, s(:return, s(:int, 1)))
+
+      @input =s(:statements, s(:call, s(:name, :add), s(:arguments), s(:receiver, s(:name, :test_l))))
+      @expect =  [Label, SlotToReg, SlotToReg, SlotToReg, RegToSlot, LoadConstant, RegToSlot ,
+                 LoadConstant, SlotToReg, RegToSlot, LoadConstant, RegToSlot, RegisterTransfer, FunctionCall ,
+                 Label, RegisterTransfer, SlotToReg, SlotToReg, LoadConstant, SlotToReg, RegToSlot ,
+                 Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_call_puts
+      clean_compile :Space, :putstr, {str: :Word}, s(:statements, s(:return, s(:name, :str)))
+      @input =s(:call, s(:name, :putstr), s(:arguments, s(:string, "Hello") ) )
+      @expect = [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, RegToSlot ,
+                 LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg, RegToSlot ,
+                 LoadConstant, RegToSlot, RegisterTransfer, FunctionCall, Label, RegisterTransfer ,
+                 SlotToReg, SlotToReg, LoadConstant, SlotToReg, RegToSlot, Label ,
+                 FunctionReturn]
+      was = check_return
+      set = was.next(8)
+      assert_equal RegToSlot , set.class
+      assert_equal 1, set.index , "Set to message must be offset, not #{set.index}"
+    end
+  end
+end

test/vm/method_compiler/test_class.rb

@@ -0,0 +1,31 @@
+require_relative 'helper'
+
+module Register
+  class TestClassStatements < MiniTest::Test
+    include Statements
+
+    def class_def
+      clean_compile :Bar, :buh, {}, s(:statements, s(:return, s(:int, 1)))
+    end
+
+    def test_class_call
+      #FIXME class call
+      # class_def
+      # @input = s(:statements, s(:return, s(:call, s(:name, :buh), s(:arguments), s(:receiver, s(:class_name, :Bar)))))
+      #
+      # @expect = [Label, SlotToReg, LoadConstant, RegToSlot, LoadConstant, RegToSlot, LoadConstant ,
+      #            RegToSlot, LoadConstant, RegToSlot, RegisterTransfer, FunctionCall, Label, RegisterTransfer ,
+      #            SlotToReg, SlotToReg, RegToSlot, Label, FunctionReturn]
+      # check
+    end
+
+    def test_class_field
+      #  clean_compile :Space, s(:class_field, :Integer, :boo2)
+      #FIXME class_field handling unclear at the moment
+      # @input =s(:statements, s(:return, s(:field_access, s(:receiver, s(:name, :self)),
+      #             s(:field,s(:name, :boo2)))))
+      # @expect =  [Label, SlotToReg,SlotToReg,RegToSlot,Label,FunctionReturn]
+      # check
+    end
+  end
+end

test/vm/method_compiler/test_field_access.rb

@@ -0,0 +1,34 @@
+require_relative "helper"
+
+module Register
+  class TestFields < MiniTest::Test
+    include ExpressionHelper
+    include AST::Sexp
+
+    def setup
+      Register.machine.boot
+    end
+
+    def test_field_not_defined
+      @root = :field_access
+      @input = s(:field_access, s(:receiver, s(:name, :self)), s(:field, s(:name, :a)))
+      assert_raises(RuntimeError) { check }
+    end
+
+    def test_field_not_space
+      @root = :field_access
+      @input = s(:field_access, s(:receiver, s(:name, :self)), s(:field, s(:name, :space)))
+
+      assert_raises(RuntimeError) { check }
+    end
+
+    def test_field
+      add_space_field(:bro,:Object)
+      @root = :field_access
+      @input = s(:field_access,s(:receiver, s(:name, :self)),s(:field,s(:name, :bro)))
+      @output = Register::RegisterValue
+      check
+    end
+
+  end
+end

test/vm/method_compiler/test_fields.rb

@@ -0,0 +1,42 @@
+require_relative 'helper'
+
+
+module Register
+  class TestFieldStatement < MiniTest::Test
+    include Statements
+
+    def test_field_named_list
+      Parfait.object_space.get_main.add_local( :m , :Message)
+      @input = s(:statements,  s(:return, s(:field_access,
+                                s(:receiver, s(:name, :m)), s(:field, s(:name, :name)))))
+      @expect = [Label, SlotToReg, SlotToReg, SlotToReg, RegToSlot, LoadConstant ,
+                 SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_field_arg
+      Parfait.object_space.get_main.add_local( :m , :Message)
+      clean_compile :Space, :get_name, { :main => :Message},
+                s(:statements, s(:return, s(:field_access,
+                    s(:receiver, s(:name, :main)), s(:field, s(:name, :name)))))
+      @input =s(:statements, s(:return, s(:call, s(:name, :get_name), s(:arguments, s(:name, :m)))))
+
+      @expect = [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, RegToSlot ,
+                 LoadConstant, SlotToReg, RegToSlot, SlotToReg, SlotToReg, SlotToReg ,
+                 RegToSlot, LoadConstant, RegToSlot, RegisterTransfer, FunctionCall, Label ,
+                 RegisterTransfer, SlotToReg, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_message_field
+      Parfait.object_space.get_main.add_local(:name , :Word)
+      @input = s(:statements, s(:assignment, s(:name, :name), s(:field_access, s(:receiver, s(:name, :message)), s(:field, s(:name, :name)))), s(:return, s(:name, :name)))
+
+      @expect = [Label, RegisterTransfer, SlotToReg, SlotToReg, RegToSlot, SlotToReg ,
+                 SlotToReg, RegToSlot, LoadConstant, SlotToReg, RegToSlot, Label ,
+                 FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+  end
+end

test/vm/method_compiler/test_if_statement.rb

@@ -0,0 +1,36 @@
+require_relative 'helper'
+
+module Register
+  class TestIfStatement < MiniTest::Test
+    include Statements
+
+    def test_if_basicr
+      @input = s(:statements, s(:if_statement, :plus, s(:condition, s(:operator_value, :-, s(:int, 10), s(:int, 12))), s(:true_statements, s(:return, s(:int, 3))), s(:false_statements, s(:return, s(:int, 4)))))
+
+    @expect =  [Label, LoadConstant, LoadConstant, OperatorInstruction, IsPlus, LoadConstant ,
+                 RegToSlot, Branch, Label, LoadConstant, RegToSlot, Label ,
+                 LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+    assert_nil msg = check_nil , msg
+    end
+
+
+    def test_if_small_minus
+      @input = s(:statements, s(:if_statement, :minus, s(:condition, s(:operator_value, :-, s(:int, 10), s(:int, 12))), s(:true_statements, s(:return, s(:int, 3))), s(:false_statements, nil)))
+
+    @expect = [Label, LoadConstant, LoadConstant, OperatorInstruction, IsMinus, Branch ,
+                 Label, LoadConstant, RegToSlot, Label, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+    assert_nil msg = check_nil , msg
+    end
+
+
+    def test_if_small_zero
+      @input = s(:statements, s(:if_statement, :zero, s(:condition, s(:operator_value, :-, s(:int, 10), s(:int, 12))), s(:true_statements, s(:return, s(:int, 3))), s(:false_statements, nil)))
+
+    @expect =  [Label, LoadConstant, LoadConstant, OperatorInstruction, IsZero, Branch ,
+                 Label, LoadConstant, RegToSlot, Label, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+    assert_nil msg = check_nil , msg
+    end
+  end
+end

test/vm/method_compiler/test_name_expression.rb

@@ -0,0 +1,34 @@
+require_relative "helper"
+
+module Register
+  class TestFields < MiniTest::Test
+    include ExpressionHelper
+    include AST::Sexp
+
+    def setup
+      Register.machine.boot
+    end
+
+    def test_local
+      Parfait.object_space.get_main.add_local(:bar , :Integer)
+      @input    = s(:name, :bar)
+      @output = Register::RegisterValue
+      check
+    end
+
+    def test_space
+      @root = :name
+      @input    = s(:name, :space)
+      @output = Register::RegisterValue
+      check
+    end
+
+    def test_args
+      Parfait.object_space.get_main.add_argument(:bar , :Integer)
+      @input    = s(:name, :bar)
+      @output = Register::RegisterValue
+      check
+    end
+
+  end
+end

test/vm/method_compiler/test_operator_expression.rb

@@ -0,0 +1,46 @@
+require_relative "helper"
+
+module Register
+  class TestOps < MiniTest::Test
+    include ExpressionHelper
+    include AST::Sexp
+
+    def setup
+      Register.machine.boot
+      @root = :operator_value
+      @output = Register::RegisterValue
+    end
+
+    def operators
+      [:+ , :- , :* , :/ , :== ]
+    end
+    def test_ints
+      operators.each do |op|
+        @input = s(:operator_value, op , s(:int, 2), s(:int, 3))
+        check
+      end
+    end
+    def test_local_int
+      Parfait.object_space.get_main.add_local(:bar , :Integer)
+      @input    = s(:operator_value, :+, s(:name, :bar), s(:int, 3))
+      check
+    end
+    def test_int_local
+      Parfait.object_space.get_main.add_local(:bar , :Integer)
+      @input    = s(:operator_value, :+, s(:int, 3), s(:name, :bar))
+      check
+    end
+
+    def test_field_int
+      add_space_field(:bro,:Integer)
+      @input = s(:operator_value, :+, s(:field_access,s(:receiver, s(:name, :self)), s(:field, s(:name, :bro))), s(:int, 3))
+      check
+    end
+
+    def test_int_field
+      add_space_field(:bro,:Integer)
+      @input = s(:operator_value, :+, s(:int, 3), s(:field_access, s(:receiver, s(:name, :self)), s(:field,s(:name, :bro))))
+      check
+    end
+  end
+end

test/vm/method_compiler/test_return_statement.rb

@@ -0,0 +1,47 @@
+require_relative 'helper'
+
+module Register
+  class TestReturnStatement < MiniTest::Test
+    include Statements
+
+    def test_return_int
+      @input = s(:statements, s(:return, s(:int, 5)))
+      @expect =   [Label, LoadConstant, RegToSlot, LoadConstant, SlotToReg, RegToSlot ,
+                 Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_return_local
+      Parfait.object_space.get_main.add_local(:runner , :Integer)
+      @input = s(:statements, s(:return, s(:name, :runner)))
+      @expect =  [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_return_local_assign
+      Parfait.object_space.get_main.add_local(:runner , :Integer)
+      @input = s(:statements, s(:assignment, s(:name, :runner), s(:int, 5)), s(:return, s(:name, :runner)))
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, SlotToReg, SlotToReg ,
+                 RegToSlot, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_return_call
+      @input =s(:statements, s(:return, s(:call, s(:name, :main), s(:arguments))))
+      @expect =  [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, RegToSlot ,
+                 LoadConstant, SlotToReg, RegToSlot, LoadConstant, RegToSlot, RegisterTransfer ,
+                 FunctionCall, Label, RegisterTransfer, SlotToReg, SlotToReg, RegToSlot ,
+                 LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def pest_return_space_length # need to add runtime first
+      Parfait.object_space.get_main.add_local(:l , :Type)
+      @input = s(:statements, s(:assignment, s(:name, :l), s(:call, s(:name, :get_type), s(:arguments), s(:receiver, s(:name, :space)))), s(:return, s(:field_access, s(:receiver, s(:name, :self)), s(:field, s(:name, :runner)))))
+      @expect =  [Label, SlotToReg,SlotToReg ,RegToSlot,Label,FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+  end
+end

test/vm/method_compiler/test_while_statement.rb

@@ -0,0 +1,43 @@
+require_relative 'helper'
+
+module Register
+  class TestWhile < MiniTest::Test
+    include Statements
+
+
+    def test_while_mini
+      @input = s(:statements, s(:while_statement, :plus, s(:conditional, s(:int, 1)), s(:statements, s(:return, s(:int, 3)))))
+
+      @expect =  [Label, Branch, Label, LoadConstant, RegToSlot, Label ,
+                 LoadConstant, IsPlus, LoadConstant, SlotToReg, RegToSlot, Label ,
+                 FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def test_while_assign
+      Parfait.object_space.get_main.add_local(:n , :Integer)
+
+      @input    = s(:statements, s(:assignment, s(:name, :n), s(:int, 5)), s(:while_statement, :plus, s(:conditional, s(:name, :n)), s(:statements, s(:assignment, s(:name, :n), s(:operator_value, :-, s(:name, :n), s(:int, 1))))), s(:return, s(:name, :n)))
+
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, Branch, Label ,
+                 SlotToReg, SlotToReg, LoadConstant, OperatorInstruction, SlotToReg, RegToSlot ,
+                 Label, SlotToReg, SlotToReg, IsPlus, SlotToReg, SlotToReg ,
+                 RegToSlot, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+
+    def test_while_return
+      Parfait.object_space.get_main.add_local(:n , :Integer)
+
+      @input    = s(:statements, s(:assignment, s(:name, :n), s(:int, 10)), s(:while_statement, :plus, s(:conditional, s(:operator_value, :-, s(:name, :n), s(:int, 5))), s(:statements, s(:assignment, s(:name, :n), s(:operator_value, :+, s(:name, :n), s(:int, 1))), s(:return, s(:name, :n)))))
+
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, Branch, Label ,
+                 SlotToReg, SlotToReg, LoadConstant, OperatorInstruction, SlotToReg, RegToSlot ,
+                 SlotToReg, SlotToReg, RegToSlot, Label, SlotToReg, SlotToReg ,
+                 LoadConstant, OperatorInstruction, IsPlus, LoadConstant, SlotToReg, RegToSlot ,
+                 Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+  end
+end