Clean up some code.

src/chalk/builtin.cr

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

src/chalk/codegen.cr

@@ -22,7 +22,6 @@ 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,8 +54,9 @@ 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 generator.generate!
+      return optimizer.optimize generator.generate!
     end
 
     private def create_code(tree : BuiltinFunction, table)

src/chalk/optimizer.cr

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

src/chalk/parser.cr

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

src/chalk/parser_builder.cr

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

src/chalk/parsers.cr

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