ikra 0.0.1 → 0.0.2

data/lib/ast/printer.rb

@@ -2,81 +2,179 @@ module Ikra
     module AST
         class Node
             def to_s
-                "[Node]"
+                return "[Node]"
+            end
+        end
+
+        class ProgramNode
+            def to_s
+                return "[ProgramNode: #{blocks.to_s}; #{classes.to_s}]"
+            end
+        end
+
+        class ClassDefNode
+            def to_s
+                return "[ClassDefNode: #{name}; #{instance_variables.to_s}; #{instance_methods.to_s}]"
+            end
+        end
+
+        class VarDefNode
+            def to_s
+                return "[VarDefNode: #{name}, read = #{read}, written = #{written}]"
+            end
+        end
+
+        class MethDefNode
+            def to_s
+                return "[MethDefNode: #{name} #{body.to_s}]"
+            end
+        end
+
+        class BlockDefNode
+            def to_s
+                return "[BlockDefNode: #{body.to_s}]"
             end
         end
 
         class RootNode
             def to_s
-                "[RootNode: #{child.to_s}]"
+                return "[RootNode: #{single_child.to_s}]"
+            end
+        end
+
+        class ArrayNode
+            def to_s
+                return "[ArrayNode: [#{(values.map do |v| v.to_s end).join(', ')}]]"
+            end
+        end
+
+        class SourceCodeExprNode
+            def to_s
+                return "[SourceCodeExprNode: #{code}]"
+            end
+        end
+        
+        class HashNode
+            def to_s
+                return "[HashNode: {" + hash.map do |key, value|
+                    "#{key.to_s} => #{value.to_s}"
+                end.join(", ") + "}]"
             end
         end
 
         class ConstNode
             def to_s
-                "[ConstNode: #{identifier.to_s}]"
+                return "[ConstNode: #{identifier.to_s}]"
             end
         end
 
         class LVarReadNode
             def to_s
-                "[LVarReadNode: #{identifier.to_s}]"
+                return "[LVarReadNode: #{identifier.to_s}]"
             end
         end
 
         class LVarWriteNode
             def to_s
-                "[LVarWriteNode: #{identifier.to_s} := #{value.to_s}]"
+                return "[LVarWriteNode: #{identifier.to_s} := #{value.to_s}]"
             end
         end
 
-        class IntNode
+        class IntLiteralNode
             def to_s
-                "<#{value.to_s}>"
+                return "<#{value.to_s}>"
             end
         end
 
-        class FloatNode
+        class FloatLiteralNode
             def to_s
-                "<#{value.to_s}>"
+                return "<#{value.to_s}>"
             end
         end
 
-        class BoolNode
+        class BoolLiteralNode
             def to_s
-                "<#{value.to_s}>"
+                return "<#{value.to_s}>"
+            end
+        end
+
+        class NilLiteralNode
+            def to_s
+                return "<nil>"
+            end
+        end
+
+        class SymbolLiteralNode
+            def to_s
+                return "<:#{value.to_s}>"
+            end
+        end
+
+        class StringLiteralNode
+            def to_s
+                return "<#{value.to_s}>"
             end
         end
 
         class ForNode
             def to_s
-                "[ForNode: #{iterator_identifier.to_s} := #{range_from.to_s}...#{range_to.to_s}, #{body_stmts.to_s}]"
+                return "[ForNode: #{iterator_identifier.to_s} := #{range_from.to_s}...#{range_to.to_s}, #{body_stmts.to_s}]"
+            end
+        end
+
+        class WhileNode
+            def to_s
+                return "[WhileNode: #{condition.to_s}, #{body_stmts.to_s}]"
+            end
+        end
+
+        class WhilePostNode
+            def to_s
+                return "[WhilePostNode: #{condition.to_s}, #{body_stmts.to_s}]"
+            end
+        end
+
+        class UntilNode
+            def to_s
+                return "[UntilNode: #{condition.to_s}, #{body_stmts.to_s}]"
+            end
+        end
+
+        class UntilPostNode
+            def to_s
+                return "[UntilPostNode: #{condition.to_s}, #{body_stmts.to_s}]"
             end
         end
 
         class BreakNode
             def to_s
-                "[BreakNode]"
+                return "[BreakNode]"
             end
         end
 
         class IfNode
             def to_s
                 if false_body_stmts != nil
-                    "[IfNode: #{condition.to_s}, #{true_body_stmts.to_s}, #{false_body_stmts.to_s}]"
+                    return "[IfNode: #{condition.to_s}, #{true_body_stmts.to_s}, #{false_body_stmts.to_s}]"
                 else
-                    "[IfNode: #{condition.to_s}, #{true_body_stmts.to_s}]"
+                    return "[IfNode: #{condition.to_s}, #{true_body_stmts.to_s}]"
                 end
             end
         end
 
+        class TernaryNode
+            def to_s
+                return "[TernaryNode: #{condition.to_s}, #{true_val.to_s}, #{false_val.to_s}]"
+            end
+        end
+
         class BeginNode
             def to_s
                 stmts = body_stmts.map do |stmt|
                     stmt.to_s
                 end.join(";\n")
 
-                "[BeginNode: {#{stmts}}]"
+                return "[BeginNode: {#{stmts}}]"
             end
         end
 
@@ -86,13 +184,13 @@ module Ikra
                     arg.to_s
                 end.join("; ")
 
-                "[SendNode: #{receiver.to_s}.#{selector.to_s}(#{args})]"
+                return "[SendNode: #{receiver.to_s}.#{selector.to_s}(#{args})]"
             end
         end
 
         class ReturnNode
             def to_s
-                "[ReturnNode: #{value.to_s}]"
+                return "[ReturnNode: #{value.to_s}]"
             end
         end
     end

data/lib/ast/ssa_generator.rb

@@ -0,0 +1,192 @@
+require "set"
+
+module Ikra
+    module AST
+        # Converts an AST to single static assignment form (SSA). 
+        # TODO: Make SSA form minimal, i.e., remove unnecessary assignments (Phi node artifacts).
+        class SSAGenerator < Visitor
+            def self.transform_to_ssa!(node)
+                node.accept(self.new)
+            end
+
+            def initialize
+                @aliases = {}
+                @ssa_id = 0
+            end
+
+            def new_ssa_var_name(old_name = nil)
+                @ssa_id = @ssa_id + 1
+
+                if old_name == nil
+                    return "_ssa_var_#{@ssa_id}"
+                else
+                    return "_ssa_var_#{old_name}_#{@ssa_id}"
+                end
+            end
+
+            def visit_lvar_read_node(node)
+                super
+
+                if @aliases.include?(node.identifier)
+                    # This variable was renamed
+                    node.replace(LVarReadNode.new(identifier: @aliases[node.identifier]))
+                end
+            end
+
+            def visit_lvar_write_node(node)
+                super
+
+                # Give the variable a new name
+                new_name = new_ssa_var_name(node.identifier)
+                @aliases[node.identifier] = new_name
+
+                node.replace(LVarWriteNode.new(
+                    identifier: new_name,
+                    value: node.value))
+            end
+
+            # Merges all "alias" hash maps given by `branch_aliases`. If a conflict is detected,
+            # i.e., a variable is renamed to different names in at least to branches, `block` is
+            # executed with the original variable name as argument. The block should return the
+            # new resolved variable name.
+            def merge_aliases(*branch_aliases, &block)
+                result = {}
+
+                orig_names = Set.new(branch_aliases.map do |aliases|
+                    aliases.keys
+                end.flatten)
+
+                for orig_name in orig_names
+                    new_names = Set.new(branch_aliases.map do |aliases|
+                        aliases[orig_name]
+                    end)
+
+                    if new_names.size > 1
+                        # Renamed to different values
+                        result[orig_name] = yield(orig_name)
+                    else
+                        result[orig_name] = new_names.first
+                    end
+                end
+
+                return result
+            end
+
+            def visit_if_node(node)
+                node.condition.accept(self)
+
+                branch1_aliases = @aliases.dup
+                branch2_aliases = @aliases.dup
+
+                @aliases = branch1_aliases
+                node.true_body_stmts.accept(self)
+                branch1_aliases = @aliases
+
+                @aliases = branch2_aliases
+                node.false_body_stmts.accept(self)
+                branch2_aliases = @aliases
+
+                @aliases = merge_aliases(branch1_aliases, branch2_aliases) do |orig_var|
+                    # Conflict found: `orig_var` renamed in both branches
+                    name1 = branch1_aliases[orig_var]
+                    name2 = branch2_aliases[orig_var]
+
+                    resolved_name = new_ssa_var_name(orig_var)
+
+                    if not node.true_body_stmts.is_a?(BeginNode)
+                        raise AssertionError.new("Expected a BeginNode")
+                    end
+
+                    if not node.false_body_stmts.is_a?(BeginNode)
+                        raise AssertionError.new("Expected a BeginNode")
+                    end
+
+                    # TODO: Should check liveness of variables
+                    node.true_body_stmts.add_statement(LVarWriteNode.new(
+                        identifier: resolved_name, value: LVarReadNode.new(identifier: name1)))
+                    node.false_body_stmts.add_statement(LVarWriteNode.new(
+                        identifier: resolved_name, value: LVarReadNode.new(identifier: name2)))
+
+                    resolved_name
+                end
+            end
+
+            # TODO: Handle `TernaryNode`
+
+            def visit_for_node(node)
+                node.range_from.accept(self)
+                node.range_to.accept(self)
+
+                before_loop_aliases = @aliases.dup
+
+                node.body_stmts.accept(self)
+                loop_body_aliases = @aliases.dup
+
+                # Insert merge statements at the end of the loop body
+                @aliases = merge_aliases(before_loop_aliases, loop_body_aliases) do |orig_var|
+                    # Conflict found
+                    name_before = before_loop_aliases[orig_var]
+                    name_inside = loop_body_aliases[orig_var]
+
+                    if name_before != nil
+                        resolved_name = name_before
+
+                        node.body_stmts.add_statement(LVarWriteNode.new(
+                            identifier: name_before, 
+                            value: LVarReadNode.new(identifier: name_inside)))
+                    else
+                        resolved_name = name_inside
+                    end
+
+                    # Resolved name is `name_before`
+                    resolved_name
+                end
+            end
+
+            def process_while_until_node(node)
+                node.condition.accept(self)
+
+                before_loop_aliases = @aliases.dup
+
+                node.body_stmts.accept(self)
+                loop_body_aliases = @aliases.dup
+
+                # Insert merge statements at the end of the loop body
+                @aliases = merge_aliases(before_loop_aliases, loop_body_aliases) do |orig_var|
+                    # Conflict found
+                    name_before = before_loop_aliases[orig_var]
+                    name_inside = loop_body_aliases[orig_var]
+
+                    if name_before != nil
+                        resolved_name = name_before
+
+                        node.body_stmts.add_statement(LVarWriteNode.new(
+                            identifier: name_before, 
+                            value: LVarReadNode.new(identifier: name_inside)))
+                    else
+                        resolved_name = name_inside
+                    end
+
+                    # Resolved name is `name_before`
+                    resolved_name
+                end
+            end
+
+            def visit_while_node(node)
+                process_while_until_node(node)
+            end
+
+            def visit_until_node(node)
+                process_while_until_node(node)
+            end
+
+            def visit_while_post_node(node)
+                process_while_until_node(node)
+            end
+
+            def visit_until_post_node(node)
+                process_while_until_node(node)
+            end
+        end
+    end
+end

data/lib/ast/visitor.rb

@@ -4,13 +4,39 @@ module Ikra
     module AST
         class Node
             def accept(visitor)
-                visitor.visit_node(self)
+                return visitor.visit_node(self)
             end
         end
         
-        class ConstNode
+        class ProgramNode
             def accept(visitor)
-                visitor.visit_const_node(self)
+                def accept(visitor)
+                    return visitor.visit_program_node(self)
+                end
+            end
+        end
+
+        class ClassDefNode
+            def accept(visitor)
+                return visitor.visit_class_def_node(self)
+            end
+        end
+
+        class VarDefNode
+            def accept(visitor)
+                return visitor.visit_var_def_node(self)
+            end
+        end
+
+        class MethDefNode
+            def accept(visitor)
+                return visitor.visit_meth_def_node(self)
+            end
+        end
+
+        class BlockDefNode
+            def accept(visitor)
+                return visitor.visit_block_def_node(self)
             end
         end
 
@@ -20,6 +46,30 @@ module Ikra
             end
         end
 
+        class ArrayNode
+            def accept(visitor)
+                visitor.visit_array_node(self)
+            end
+        end
+
+        class SourceCodeExprNode
+            def accept(visitor)
+                visitor.visit_source_code_expr_node(self)
+            end
+        end
+
+        class HashNode
+            def accept(visitor)
+                visitor.visit_hash_node(self)
+            end
+        end
+
+        class ConstNode
+            def accept(visitor)
+                visitor.visit_const_node(self)
+            end
+        end
+
         class LVarReadNode
             def accept(visitor)
                 visitor.visit_lvar_read_node(self)
@@ -38,57 +88,105 @@ module Ikra
             end
         end
 
-        class IntNode
+        class IntLiteralNode
             def accept(visitor)
                 visitor.visit_int_node(self)
             end
         end
         
-        class FloatNode
+        class FloatLiteralNode
             def accept(visitor)
                 visitor.visit_float_node(self)
             end
         end
         
-        class BoolNode
+        class BoolLiteralNode
             def accept(visitor)
                 visitor.visit_bool_node(self)
             end
         end
         
+        class NilLiteralNode
+            def accept(visitor)
+                visitor.visit_nil_node(self)
+            end
+        end
+
+        class SymbolLiteralNode
+            def accept(visitor)
+                visitor.visit_symbol_node(self)
+            end
+        end
+
+        class StringLiteralNode
+            def accept(visitor)
+                visitor.visit_string_node(self)
+            end
+        end
+        
         class ForNode
             def accept(visitor)
                 visitor.visit_for_node(self)
             end
         end
         
+        class WhileNode
+            def accept(visitor)
+                return visitor.visit_while_node(self)
+            end
+        end
+        
+        class WhilePostNode
+            def accept(visitor)
+                return visitor.visit_while_post_node(self)
+            end
+        end
+        
+        class UntilNode
+            def accept(visitor)
+                return visitor.visit_until_node(self)
+            end
+        end
+        
+        class UntilPostNode
+            def accept(visitor)
+                return visitor.visit_until_post_node(self)
+            end
+        end
+
         class BreakNode
             def accept(visitor)
-             visitor.visit_break_node(self)
+             return visitor.visit_break_node(self)
             end
         end
         
         class IfNode
             def accept(visitor)
-                visitor.visit_if_node(self)
+                return visitor.visit_if_node(self)
+            end
+        end
+        
+        class TernaryNode
+            def accept(visitor)
+                return visitor.visit_ternary_node(self)
             end
         end
         
         class BeginNode
             def accept(visitor)
-                visitor.visit_begin_node(self)
+                return visitor.visit_begin_node(self)
             end
         end
         
         class SendNode
             def accept(visitor)
-                visitor.visit_send_node(self)
+                return visitor.visit_send_node(self)
             end
         end
         
         class ReturnNode
             def accept(visitor)
-                visitor.visit_return_node(self)
+                return visitor.visit_return_node(self)
             end
         end
 
@@ -97,64 +195,179 @@ module Ikra
             
             end
 
-            def visit_const_node(node)
+            def visit_program_node(node)
+                visit_node(node)
+
+                node.classes.each do |c|
+                    c.accept(self)
+                end
 
+                node.blocks.each do |b|
+                    b.accept(self)
+                end
             end
-            
+
+            def visit_class_def_node(node)
+                visit_node(node)
+
+                node.instance_variables.each do |iv|
+                    iv.accept(self)
+                end
+
+                node.instance_methods.each do |im|
+                    im.accept(self)
+                end
+            end
+
             def visit_root_node(node)
-                node.child.accept(self)
+                visit_node(node)
+                node.single_child.accept(self)
+            end
+
+            def visit_array_node(node)
+                visit_node(node)
+
+                for value in node.values
+                    value.accept(self)
+                end
+            end
+
+            def visit_source_code_expr_node(node)
+                visit_node(node)
+            end
+
+            def visit_hash_node(node)
+                visit_node(node)
+
+                node.hash.each do |key, value|
+                    key.accept(self)
+                    value.accept(self)
+                end
+            end
+
+            def visit_var_def_node(node)
+                visit_node(node)
+            end
+
+            def visit_meth_def_node(node)
+                visit_node(node)
+                node.body.accept(self)
+            end
+
+            def visit_block_def_node(node)
+                visit_node(node)
+                node.body.accept(self)
+            end
+
+            def visit_const_node(node)
+                visit_node(node)
             end
             
             def visit_lvar_read_node(node)
-            
+                visit_node(node)
             end
             
             def visit_lvar_write_node(node)
+                visit_node(node)
                 node.value.accept(self)
             end
             
             def visit_ivar_read_node(node)
-
+                visit_node(node)
             end
             
             def visit_int_node(node)
-            
+                visit_node(node)
             end
             
             def visit_float_node(node)
+                visit_node(node)
             
             end
             
             def visit_bool_node(node)
+                visit_node(node)
+            end
             
+            def visit_nil_node(node)
+                visit_node(node)
             end
             
+            def visit_symbol_node(node)
+                visit_node(node)
+            end
+
+            def visit_string_node(node)
+                visit_node(node)
+            end
+
             def visit_for_node(node)
+                visit_node(node)
+
                 node.range_from.accept(self)
                 node.range_to.accept(self)
                 node.body_stmts.accept(self)
             end
             
-            def visit_break_node(node)
+            def visit_while_node(node)
+                visit_node(node)
+
+                node.condition.accept(self)
+                node.body_stmts.accept(self)
+            end
+            
+            def visit_while_post_node(node)
+                visit_node(node)
+
+                node.condition.accept(self)
+                node.body_stmts.accept(self)
+            end
+            
+            def visit_until_node(node)
+                visit_node(node)
+
+                node.condition.accept(self)
+                node.body_stmts.accept(self)
+            end
             
+            def visit_until_post_node(node)
+                visit_node(node)
+
+                node.condition.accept(self)
+                node.body_stmts.accept(self)
+            end
+
+            def visit_break_node(node)
+                visit_node(node)
             end
             
             def visit_if_node(node)
+                visit_node(node)
+
                 node.condition.accept(self)
                 node.true_body_stmts.accept(self)
+                node.false_body_stmts.accept(self)
+            end
+            
+            def visit_ternary_node(node)
+                visit_node(node)
 
-                if node.false_body_stmts != nil
-                    node.false_body_stmts.accept(self)
-                end
+                node.condition.accept(self)
+                node.true_val.accept(self)
+                node.false_val.accept(self)
             end
             
             def visit_begin_node(node)
+                visit_node(node)
+
                 node.body_stmts.each do |stmt|
                     stmt.accept(self)
                 end
             end
             
             def visit_send_node(node)
+                visit_node(node)
+
                 # Receiver might be nil for self sends
                 if node.receiver != nil
                     node.receiver.accept(self)
@@ -166,6 +379,7 @@ module Ikra
             end
 
             def visit_return_node(node)
+                visit_node(node)
                 node.value.accept(self)
             end
         end