src/chalk/builder.cr

@@ -2,7 +2,7 @@ require "./lexer.cr"
 require "./parsers.cr"
 
 module Chalk
-  module ParserBuilder
+  module Builder
     def type(type) : BasicParser(Token)
       return TypeParser.new(type).as(BasicParser(Token))
     end

src/chalk/builtin.cr

@@ -5,7 +5,7 @@ module Chalk
     def initialize(@param_count)
     end
 
-    def generate!(codegen)
+    def generate!(into)
     end
   end
 

src/chalk/codegen.cr

@@ -22,6 +22,7 @@ module Chalk
     end
 
     def generate!(tree, function : InlineFunction, table, target, free)
+      start = free
       function.generate!(self, tree.params, table, target, free)
     end
 

src/chalk/compiler.cr

@@ -54,9 +54,8 @@ module Chalk
 
     private def create_code(tree : TreeFunction, table)
       generator = CodeGenerator.new table, tree
-      optimizer = Optimizer.new
       @logger.debug("Generating code for #{tree.name}")
-      return optimizer.optimize generator.generate!
+      return generator.generate!
     end
 
     private def create_code(tree : BuiltinFunction, table)

src/chalk/optimizer.cr

@@ -1,27 +1,30 @@
 module Chalk
   class Optimizer
-     private def check_dead(inst)
+    def initialize(instructions : Array(Instruction))
+      @instructions = instructions.dup
+    end
+
+    private def check_dead(inst)
       if inst.is_a?(LoadRegInstruction)
         return inst.from == inst.into
       end
       return false
     end
 
-    private def optimize!(instructions, range)
+    private def optimize!(range)
       offset = 0
       range.each do |index|
-        if check_dead(instructions[index + offset])
-          instructions.delete_at(index + offset)
+        if check_dead(@instructions[index + offset])
+          @instructions.delete_at(index + offset)
           offset -= 1
         end
       end
       return offset
     end
 
-    def optimize(instructions)
-      instructions = instructions.dup
-      block_boundaries = [instructions.size]
-      instructions.each_with_index do |inst, i|
+    private def optimize!
+      block_boundaries = [@instructions.size]
+      @instructions.each_with_index do |inst, i|
         if inst.is_a?(JumpRelativeInstruction)
           block_boundaries << (inst.offset + i)
         end
@@ -32,10 +35,9 @@ module Chalk
       offset = 0
       block_boundaries.each do |boundary|
         range = (previous + offset)...(boundary + offset)
-        offset += optimize!(instructions, range)
+        offset += optimize!(range)
         previous = boundary
       end
-      return instructions
     end
   end
 end

src/chalk/parser.cr

@@ -1,8 +1,8 @@
-require "./parser_builder.cr"
+require "./builder.cr"
 
 module Chalk
   class Parser
-    include ParserBuilder
+    include Builder
 
     private def create_type
       either(type(TokenType::KwU0), type(TokenType::KwU8), type(TokenType::KwU12))

src/chalk/parsers.cr

@@ -1,3 +1,5 @@
+require "./builder.cr"
+
 module Chalk
   abstract class BasicParser(T)
     abstract def parse?(tokens : Array(Token),