ikra 0.0.1 → 0.0.2

data/lib/symbolic/visitor.rb

@@ -1,14 +1,26 @@
 module Ikra
     module Symbolic
-        class ArrayNewCommand
+        class ArrayIndexCommand
             def accept(visitor)
-                visitor.visit_array_new_command(self)
+                visitor.visit_array_index_command(self)
             end
         end
 
-        class ArrayMapCommand
+        class ArrayCombineCommand
             def accept(visitor)
-                visitor.visit_array_map_command(self)
+                visitor.visit_array_combine_command(self)
+            end
+        end
+
+        class ArrayReduceCommand
+            def accept(visitor)
+                visitor.visit_array_reduce_command(self)
+            end
+        end
+
+        class ArrayStencilCommand
+            def accept(visitor)
+                visitor.visit_array_stencil_command(self)
             end
         end
 
@@ -24,28 +36,78 @@ module Ikra
             end
         end
 
+        class ArrayZipCommand
+            def accept(visitor)
+                visitor.visit_array_zip_command(self)
+            end
+        end
+
+        class ArrayHostSectionCommand
+            def accept(visitor)
+                visitor.visit_array_host_section_command(self)
+            end
+        end
+
+        class ArrayInHostSectionCommand
+            def accept(visitor)
+                visitor.visit_array_in_host_section_command(self)
+            end
+        end
+
+        class FixedSizeArrayInHostSectionCommand < ArrayInHostSectionCommand
+            def accept(visitor)
+                visitor.visit_fixed_size_array_in_host_section_command(self)
+            end
+        end
+
         class Visitor
             def visit_array_command(command)
+                for input in command.input
+                    if input.command.is_a?(ArrayCommand)
+                        input.command.accept(self)
+                    end
+                end
+            end
 
+            def visit_array_index_command(command)
+                visit_array_command(command)
             end
 
-            def visit_array_new_command(command)
+            def visit_array_combine_command(command)
                 visit_array_command(command)
             end
 
-            def visit_array_map_command(command)
+            def visit_array_reduce_command(command)
+                visit_array_command(command)
+            end
+
+            def visit_array_stencil_command(command)
                 visit_array_command(command)
-                command.target.accept(self)
             end
 
             def visit_array_select_command(command)
                 visit_array_command(command)
-                command.target.accept(self)
             end
 
             def visit_array_identity_command(command)
                 visit_array_command(command)
             end
+
+            def visit_array_in_host_section_command(command)
+                visit_array_command(command)
+            end
+            
+            def visit_array_zip_command(command)
+                visit_array_command(command)
+            end
+
+            def visit_array_host_section_command(command)
+
+            end
+
+            def visit_fixed_size_array_in_host_section_command(command)
+                visit_array_in_host_section_command(command)
+            end
         end
     end
 end

data/lib/translator/array_command_struct_builder.rb

@@ -0,0 +1,163 @@
+module Ikra
+    module Translator
+        # This class looks for `input_command` in the tree of commands (and inputs) provided
+        # by `relative_command`. It traverses this tree and generates and expression that can
+        # be used to access `input_command` from `relative_command`, which is represented by
+        # an array_command struct in the CUDA code and referenced with `command_expr`.
+        # TODO: This class should be a visitor, but we need to pass additional values (`path`)
+        # along the way.
+        module KernelLaunchArgumentGenerator
+            def self.generate_arg(input_command, relative_command, command_expr)
+                return visit_array_command(input_command, relative_command, command_expr)
+            end
+
+            def self.visit_array_command(input_command, command, path)
+                if command.is_a?(Symbolic::ArrayInHostSectionCommand)
+                    if command.equal?(input_command)
+                        # This should be passed as an argument
+                        return "((#{command.base_type.to_c_type} *) #{path}->input_0.content)"
+                    else
+                        # This is not the one we are looking for
+                        return nil
+                    end
+                else
+                    command.input.each_with_index do |input, index|
+                        if input.command.is_a?(Symbolic::ArrayCommand)
+                            result = visit_array_command(
+                                input_command, input.command, "#{path}->input_#{index}")
+
+                            if result != nil
+                                return "((#{input_command.base_type.to_c_type} *) #{result})"
+                            end
+                        end
+                    end
+
+                    return nil
+                end
+            end
+        end
+
+        class ArrayCommandStructBuilder < Symbolic::Visitor
+            def self.struct_name(command)
+                return "array_command_#{command.unique_id}"
+            end
+
+            # This class determines if a `size` instance method should be generated for an
+            # array_command struct type. This is the case iff struct, or its first input, or
+            # the first input of its first input, etc., is an ArrayInHostSectionCommand.
+            # The size of such arrays is in general not known at compile time.
+            class RequireRuntimeSizeChecker < Symbolic::Visitor
+                def self.require_size_function?(command)
+                    return command.accept(self.new)
+                end
+
+                def visit_array_reduce_command(command)
+                    # Size is always 1
+                    return false
+                end
+
+                def visit_array_identity_command(command)
+                    # Fully fused, size known at compile time
+                    return false
+                end
+
+                def visit_array_in_host_section_command(command)
+                    # Cannot be fused, size unknown at compile time
+                    return true
+                end
+
+                def visit_fixed_size_array_in_host_section_command(command)
+                    # Size is part of the type/command
+                    return false
+                end
+
+                def visit_array_command(command)
+                    if command.input.size == 0
+                        return false
+                    else
+                        return command.input.first.command.accept(self)
+                    end
+                end
+            end
+
+            # This class builds a struct containing references to input (depending) commands for
+            # a certain array command. It is a subclass of [Symbolic::Visitor] but does not 
+            # traverse the tree. We just take advantage of the double dispatch here.
+            class SingleStructBuilder < Symbolic::Visitor
+                def struct_name(command)
+                    return ArrayCommandStructBuilder.struct_name(command)
+                end
+
+                def visit_array_command(command)
+                    this_name = struct_name(command)
+                    struct_def = "struct #{this_name} {\n"
+                    
+                    # Debug information
+                    struct_def = struct_def + "    // #{command.class}\n"
+
+                    # Generate fields
+                    struct_def = struct_def + "    #{command.result_type.to_c_type} *result;\n"
+
+                    all_params = ["#{command.result_type.to_c_type} *result = NULL"]
+                    all_initializers = ["result(result)"]
+
+                    command.input.each_with_index do |input, index|
+                        if input.command.is_a?(Symbolic::ArrayCommand)
+                            struct_def = struct_def + "    #{struct_name(input.command)} *input_#{index};\n"
+                            all_params.push("#{struct_name(input.command)} *input_#{index} = NULL")
+                            all_initializers.push("input_#{index}(input_#{index})")
+                        end
+                    end
+
+                    # Generate constructor
+                    struct_def = struct_def + "    __host__ __device__ #{this_name}(#{all_params.join(', ')}) : #{all_initializers.join(', ')} { }\n"
+
+                    # Add instance methods
+                    if RequireRuntimeSizeChecker.require_size_function?(command)
+                        # ArrayIndexCommand does not have any input, as an example. But in this
+                        # case, we also do not need the `size` function, because it is a root
+                        # command that can be fused.
+                        struct_def = struct_def + "    int size() { return input_0->size(); }\n"
+                    end
+
+                    struct_def = struct_def + "};"
+                end
+
+                def visit_array_in_host_section_command(command)
+                    this_name = struct_name(command)
+                    struct_def = "struct #{this_name} {\n"
+
+                    # Debug information
+                    struct_def = struct_def + "    // #{command.class}\n"
+                    
+                    struct_def = struct_def + "    #{command.result_type.to_c_type} *result;\n"
+                    struct_def = struct_def + "    variable_size_array_t input_0;\n"
+                    struct_def = struct_def + "    __host__ __device__ #{this_name}(#{command.result_type.to_c_type} *result = NULL, variable_size_array_t input_0 = variable_size_array_t::error_return_value) : result(result), input_0(input_0) { }\n"
+
+                    # Add instance methods
+                    struct_def = struct_def + "    int size() { return input_0.size; }\n"
+
+                    return struct_def + "};"
+                end
+            end
+
+            attr_reader :all_structs
+
+            def initialize
+                @all_structs = []
+                @builder = SingleStructBuilder.new
+            end
+
+            def visit_array_command(command)
+                super
+                @all_structs.push(command.accept(@builder))
+            end
+
+            def self.build_all_structs(command)
+                visitor = self.new
+                command.accept(visitor)
+                return visitor.all_structs
+            end
+        end
+    end
+end

data/lib/translator/ast_translator.rb

@@ -0,0 +1,572 @@
+require_relative "../ast/nodes.rb"
+require_relative "../ast/visitor.rb"
+require_relative "../ruby_core/ruby_integration"
+
+# Rule: every statement ends with newline
+# TODO: Add proper exceptions (CompilationError)
+
+module Ikra
+    module Translator
+        class ASTTranslator
+            class ExpressionTranslator
+                # This class should not inherit from [AST::Visitor]. Otherwise, the dispatch
+                # mechanisum to [StatementTranslator] will not work properly anymore.
+
+                attr_reader :translator
+
+                def initialize(translator)
+                    @translator = translator
+                end
+
+                def expression_translator
+                    return self
+                end
+
+                def statement_translator
+                    return translator.statement_translator
+                end
+
+                def method_missing(symbol, *args)
+                    if symbol.to_s.start_with?("visit_")
+                        if statement_translator.respond_to?(symbol)
+                            return statements_as_expression(
+                                statement_translator.send(symbol, *args) + "return NULL;")
+                        else
+                            super
+                        end
+                    else
+                        return translator.send(symbol, *args)
+                    end
+                end
+
+                def visit_behavior_node(node)
+                    raise AssertionError.new(
+                        "Methods/blocks cannot be translated as an expression")
+                end
+
+                def visit_source_code_expr_node(node)
+                    return node.code
+                end
+
+                # TODO: Should never translate a hash node (check `with_index` in host section)
+                def visit_hash_node(node)
+                    return ""
+                end
+
+                def visit_const_node(node)
+                    raise NotImplementedError.new
+                end
+
+                def visit_lvar_read_node(node)
+                    return node.mangled_identifier.to_s
+                end
+
+                def visit_lvar_write_node(node)
+                    if node.value.get_type.is_singleton? and !node.symbol_table[node.identifier].is_singleton?
+                        # The assigned value is singleton, but the variable is not
+                        singleton_assignment = wrap_in_union_type(
+                            node.value.accept(expression_translator), 
+                            node.value.get_type.singleton_type)
+                        return Translator.read_file(file_name: "ast/assignment.cpp",
+                            replacements: { 
+                                "source" => singleton_assignment,
+                                "target" => node.mangled_identifier.to_s})
+                    else
+                        return Translator.read_file(file_name: "ast/assignment.cpp",
+                            replacements: { 
+                                "source" => node.value.accept(expression_translator),
+                                "target" => node.mangled_identifier.to_s})
+                    end
+                end
+
+                def visit_ivar_read_node(node)
+                    array_identifier = node.enclosing_class.ruby_class.to_ikra_type.inst_var_array_name(identifier)
+                    return "#{Constants::ENV_IDENTIFIER}->#{array_identifier}[#{Constants::SELF_IDENTIFIER}]"
+                end
+
+                def visit_array_node(node)
+                    elements = node.values.map do |value|
+                        value.accept(self)
+                    end
+                    
+                    return "(new #{node.get_type.to_c_type[0..-2]} {#{elements.join(', ')}})"
+                end
+
+                def visit_int_node(node)
+                    return node.value.to_s
+                end
+
+                def visit_nil_node(node)
+                    return "0"
+                end
+
+                def visit_float_node(node)
+                    return node.value.to_s
+                end
+
+                def visit_bool_node(node)
+                    return node.value.to_s
+                end
+
+                def visit_if_node(node)
+                    # Make every branch return
+                    node.accept(LastStatementReturnsVisitor.new)
+
+                    # Wrap in StatementExpression
+                    return statements_as_expression(node.accept(statement_translator))
+                end
+
+                def visit_ternary_node(node)
+                    return "((#{node.condition.accept(expression_translator)}) ? (#{node.true_val.accept(expression_translator)}) : (#{node.false_val.accept(expression_translator)}))"
+                end
+
+
+                def visit_begin_node(node)
+                    if node.body_stmts.size == 0
+                        raise AssertionError.new("Empty BeginNode cannot be an expression")
+                    elsif node.body_stmts.size == 1
+                        # Preserve brackets
+                        return "(#{node.body_stmts.first.accept(self)})"
+                    else
+                        # Wrap in lambda
+                        # Do not worry about scope of varibles, they will all be declared at the
+                        # beginning of the function
+                        node.accept(LastStatementReturnsVisitor.new)
+                        return statements_as_expression(node.accept(statement_translator))
+                    end
+                end
+
+                # Builds a synthetic [AST::SourceCodeExprNode] with a type and a translation.
+                def build_synthetic_code_node(code, type)
+                    node = AST::SourceCodeExprNode.new(code: code)
+                    node.merge_union_type(type.to_union_type)
+                    return node
+                end
+
+                def generate_polymorphic_switch(node, &block)
+                    poly_id = temp_identifier_id
+                    node_identifer = "_polytemp_expr_#{poly_id}"
+                    header = "#{define_assign_variable(node_identifer, node)}\nswitch (#{node_identifer}.class_id)\n"
+                    case_statements = []
+
+                    if node.get_type.size == 0
+                        raise AssertionError.new("Cannot generate switch for empty UnionType")
+                    end
+
+                    for type in node.get_type
+                        if type == Types::PrimitiveType::Int
+                            self_node = build_synthetic_code_node(
+                                "#{node_identifer}.value.int_", type)
+                        elsif type == Types::PrimitiveType::Float
+                            self_node = build_synthetic_code_node(
+                                "#{node_identifer}.value.float_", type)
+                        elsif type == Types::PrimitiveType::Bool
+                            self_node = build_synthetic_code_node(
+                                "#{node_identifer}.value.bool_", type)
+                        elsif type == Types::PrimitiveType::Nil
+                            self_node = build_synthetic_code_node(
+                                "#{node_identifer}.value.int_", type)
+                        elsif type.is_a?(Symbolic::ArrayCommand)
+                            self_node = build_synthetic_code_node(
+                                "(#{type.to_c_type}) #{node_identifer}.value.pointer", type)
+                        elsif type.is_a?(Types::LocationAwareArrayType)
+                            # TODO: Should not use variable_size_array for fixed size arrays
+                            self_node = build_synthetic_code_node(
+                                "#{node_identifer}.value.variable_size_array", type)
+                        else
+                            self_node = build_synthetic_code_node(
+                                "#{node_identifer}.value.object_id", type)
+                        end
+
+                        debug_info = "#{type.to_s} (#{type.to_ruby_type.to_s})"
+
+                        case_statements.push("case #{type.class_id}: /* #{debug_info} */ #{yield(self_node)} break;")
+                    end
+
+                    return header + wrap_in_c_block(case_statements.join("\n"))
+                end
+
+                def visit_send_node(node)
+                    if node.receiver.get_type.is_singleton?
+                        return_type = node.return_type_by_recv_type[
+                            node.receiver.get_type.singleton_type]
+
+                        invocation = generate_send_for_singleton(
+                            node, 
+                            node.receiver,
+                            return_type)
+
+                            if return_type.is_singleton? and
+                                !node.get_type.is_singleton?
+
+                                invocation = wrap_in_union_type(
+                                    invocation, 
+                                    return_type.singleton_type)
+                            end
+
+                            return invocation
+                    else
+                        # Polymorphic case
+                        result_identifier = "_polytemp_result_#{temp_identifier_id}"
+                        declare_result_var = "#{node.get_type.to_c_type} #{result_identifier};\n"
+
+                        case_statements = generate_polymorphic_switch(node.receiver) do |self_node|
+                            # The singleton type in the current case
+                            type = self_node.get_type.singleton_type
+
+                            # The return type (result type) in the current case (could be polym.)
+                            return_type = node.return_type_by_recv_type[type]
+
+                            # Generate method invocation
+                            invocation = generate_send_for_singleton(
+                                node, 
+                                self_node,
+                                return_type)
+
+                            if return_type.is_singleton? and
+                                !node.get_type.is_singleton?
+                                # The return value of this particular invocation (singleton type 
+                                # recv) is singleton, but in general this send can return many 
+                                # types
+                                invocation = wrap_in_union_type(
+                                    invocation, 
+                                    return_type.singleton_type)
+                            end
+
+                            "#{result_identifier} = #{invocation};"
+                        end
+
+                        # TODO: compound statements only work with the GNU C++ compiler
+                        return "(" + wrap_in_c_block(
+                            declare_result_var + 
+                            wrap_in_c_block(case_statements) + 
+                                result_identifier + ";")[0..-2] + ")"
+                    end
+                end
+
+                def build_switch_for_args(nodes, accumulator = [], &block)
+                    if nodes.size == 0
+                        # This was the last argument, we are done with nesting switch 
+                        # stmts. The accumulator contains all singleton-typed self_nodes.
+                        return yield(accumulator)
+                    end
+
+                    next_node = nodes.first
+
+                    if next_node.get_type.is_singleton?
+                        # This node has a singleton type. We're done with this one.
+                        return build_switch_for_args(nodes.drop(1), accumulator + [next_node], &block)
+                    elsif next_node.get_type.size == 0
+                        raise "AssertionError: Found empty UnionType"
+                    else
+                        return generate_polymorphic_switch(next_node) do |sing_node|
+                            build_switch_for_args(nodes.drop(1), accumulator + [sing_node], &block)
+                        end
+                    end
+                end
+
+                def generate_send_for_singleton(node, singleton_recv, return_type)
+                    recv_type = singleton_recv.get_type.singleton_type
+
+                    if RubyIntegration.is_interpreter_only?(recv_type)
+                        # No translation necessary
+                        return nil
+                    elsif RubyIntegration.has_implementation?(recv_type, node.selector)
+                        # Some implementations accept only singleton-typed arguments
+                        if RubyIntegration.expect_singleton_args?(recv_type, node.selector)
+                            # Generate additional switch statements (one per non-sing. arg.).
+                            # Go through all possible combinations of types (for arguments).
+                            result_identifier = "_polytemp_result_#{temp_identifier_id}"
+                            declare_result_var = "#{return_type.to_c_type} #{result_identifier};\n"
+
+                            case_stmts = build_switch_for_args(node.arguments) do |all_sing_args|
+                                # TODO: Do we really have to redo type inference here?
+                                all_sing_arg_types = all_sing_args.map do |arg|
+                                    arg.get_type
+                                end
+
+                                this_return_type = RubyIntegration.get_return_type(
+                                    singleton_recv.get_type.singleton_type, 
+                                    node.selector, 
+                                    *all_sing_arg_types, 
+                                    send_node: node)
+
+                                impl = RubyIntegration.get_implementation(
+                                    singleton_recv,
+                                    node.selector, 
+                                    all_sing_args, 
+                                    translator,
+                                    this_return_type)
+
+                                if this_return_type.is_singleton? and
+                                    !return_type.is_singleton?
+
+                                    impl = wrap_in_union_type(
+                                        impl, 
+                                        this_return_type.singleton_type)
+                                end
+
+                                "#{result_identifier} = #{impl};"
+                            end
+
+                            return "(" + wrap_in_c_block(
+                                declare_result_var + 
+                                wrap_in_c_block(case_stmts) + 
+                                    result_identifier + ";")[0..-2] + ")"
+                        else
+                            # The easy case: Anything is fine (but might fail in ruby_integration)
+                            return RubyIntegration.get_implementation(
+                                singleton_recv,
+                                node.selector, 
+                                node.arguments, 
+                                translator,
+                                return_type)
+                        end
+                    elsif recv_type.is_a?(Types::StructType)
+                        first_arg = node.arguments.first
+
+                        if first_arg.is_a?(AST::IntLiteralNode)
+                            # Reading the struct at a constant position
+                            return recv_type.generate_read(
+                                singleton_recv.accept(self), 
+                                node.selector, 
+                                first_arg.accept(self))
+                        else
+                            # Reading the struct at a non-constant position
+                            id = temp_identifier_id
+                            name = "_temp_var_#{id}"
+                            first_arg_eval = first_arg.accept(self)
+
+                            # Store index in local variable, then generate non-constant access
+                            # TODO: Statement expression is potentially inefficient
+                            return "({ int #{name} = #{first_arg_eval};\n" +
+                                recv_type.generate_non_constant_read(
+                                    singleton_recv.accept(self),
+                                    node.selector,
+                                    name) + "; })"
+                        end
+                    else
+                        args = [Constants::ENV_IDENTIFIER]
+
+                        if recv_type.should_generate_self_arg?
+                            args.push(singleton_recv.accept(self))
+                        else
+                            args.push("NULL")
+                        end
+
+                        args.push(*(node.arguments.map do |arg| arg.accept(self) end))
+                        args_string = args.join(", ")
+
+                        return "#{node.receiver.get_type.singleton_type.mangled_method_name(node.selector)}(#{args_string})"
+                    end
+                end
+
+                def visit_return_node(node)
+                    raise AssertionError.new("ReturnNode is never an expression")
+                end
+            end
+
+            class StatementTranslator
+                # This class should not inherit from [AST::Visitor]. Otherwise, the dispatch
+                # mechanisum to [ExpressionTranslator] will not work properly anymore.
+
+                attr_reader :translator
+
+                def initialize(translator)
+                    @translator = translator
+                end
+
+                def expression_translator
+                    return translator.expression_translator
+                end
+
+                def statement_translator
+                    return self
+                end
+
+                def method_missing(symbol, *args)
+                    if symbol.to_s.start_with?("visit_")
+                        if expression_translator.respond_to?(symbol)
+                            return expression_translator.send(symbol, *args) + ";\n"
+                        else
+                            super
+                        end
+                    else
+                        return translator.send(symbol, *args)
+                    end
+                end
+
+                def visit_behavior_node(node)
+                    raise AssertionError.new("Methods/blocks cannot be translated as a statement")
+                end
+
+                def visit_root_node(node)
+                    return node.single_child.accept(self)
+                end
+
+                def visit_for_node(node)
+                    loop_header = "for (#{node.iterator_identifier.to_s} = #{node.range_from.accept(expression_translator)}; #{node.iterator_identifier.to_s} <= #{node.range_to.accept(expression_translator)}; #{node.iterator_identifier.to_s}++)"
+
+                    return loop_header + 
+                        "\n" + 
+                        node.body_stmts.accept(self) + 
+                        "#{node.iterator_identifier.to_s}--;\n"
+                end
+
+                def visit_while_node(node)
+                    return "while (#{node.condition.accept(expression_translator)})\n#{node.body_stmts.accept(self)}"
+                end
+
+                def visit_while_post_node(node)
+                    return "do #{node.body_stmts.accept(self)}while (#{node.condition.accept(expression_translator)});\n"
+                end
+
+                def visit_until_node(node)
+                    return "while (#{node.condition.accept(expression_translator)})\n#{node.body_stmts.accept(self)}"
+                end
+
+                def visit_until_post_node(node)
+                    return "do #{node.body_stmts.accept(self)}while (#{node.condition.accept(expression_translator)});\n"
+                end
+
+                def visit_break_node(node)
+                    return "break;\n"
+                end
+
+                def visit_if_node(node)
+                    return "if (#{node.condition.accept(expression_translator)})\n" +
+                        node.true_body_stmts.accept(self) + 
+                        "else\n" + 
+                        node.false_body_stmts.accept(self)
+                end
+
+                def visit_begin_node(node)
+                    if node.body_stmts.size == 0
+                        return wrap_in_c_block("")
+                    end
+                    
+                    body_translated = node.body_stmts.map do |stmt|
+                        stmt.accept(self)
+                    end.join("")
+
+                    return wrap_in_c_block(body_translated)
+                end
+
+                def visit_return_node(node)
+                    return "return #{node.value.accept(expression_translator)};\n"
+                end
+            end
+
+            attr_reader :expression_translator
+
+            attr_reader :statement_translator
+
+            def initialize
+                @expression_translator = ExpressionTranslator.new(self)
+                @statement_translator = StatementTranslator.new(self)
+            end
+
+            def statements_as_expression(str)
+                return "[&]#{wrap_in_c_block(str, omit_newl: true)}()"
+            end
+            
+            def indent_block(str)
+                return str.split("\n").map do |line| "    " + line end.join("\n")
+            end
+
+            def wrap_in_c_block(str, omit_newl: false)
+                result = "{\n" + indent_block(str) + "\n}"
+
+                if omit_newl
+                    return result
+                else
+                    return result + "\n"
+                end
+            end
+
+            @@next_temp_identifier_id = 0
+            def temp_identifier_id
+                @@next_temp_identifier_id += 1
+                @@next_temp_identifier_id
+            end
+
+            # Generates code that assigns the value of a node to a newly-defined variable.
+            def define_assign_variable(name, node)
+                type = node.get_type.to_c_type
+                return "#{type} #{name} = #{node.accept(expression_translator)};"
+            end
+
+            def wrap_in_union_type(str, type)
+                if type == Types::PrimitiveType::Int
+                    return "union_t(#{type.class_id}, union_v_t::from_int(#{str}))"
+                elsif type == Types::PrimitiveType::Float
+                    return "union_t(#{type.class_id}, union_v_t::from_float(#{str}))"
+                elsif type == Types::PrimitiveType::Bool
+                    return "union_t(#{type.class_id}, union_v_t::from_bool(#{str}))"
+                elsif type == Types::PrimitiveType::Nil
+                    return "union_t(#{type.class_id}, union_v_t::from_int(#{str}))"
+                elsif type.is_a?(Symbolic::ArrayCommand)
+                    return "union_t(#{type.class_id}, union_v_t::from_pointer((void *) #{str}))"
+                elsif type.is_a?(Types::LocationAwareArrayType)
+                    # TODO: Should not use variable_size_array for fixed size arrays
+                    return "union_t(#{type.class_id}, union_v_t::from_variable_size_array_t(#{str}))"
+                elsif !type.is_a?(Types::UnionType)
+                    return "union_t(#{type.class_id}, union_v_t::from_object_id(#{str}))"
+                else
+                    raise AssertionError.new("UnionType found but singleton type expected")
+                end
+            end
+
+            def self.translate_block(block_def_node)
+                return self.new.translate_block(block_def_node)
+            end
+
+            def translate_block(block_def_node)
+                return block_def_node.body.accept(statement_translator)
+            end
+
+            def self.translate_method(method_def_node)
+                return self.new.translate_method(method_def_node)
+            end
+
+            def generate_method_signature(meth_def_node)
+                method_params = ([
+                    "environment_t * #{Constants::ENV_IDENTIFIER}", 
+                    "#{meth_def_node.parent.get_type.to_c_type} #{Constants::SELF_IDENTIFIER}"] + 
+                        meth_def_node.parameters_names_and_types.map do |name, type|
+                            "#{type.singleton_type.to_c_type} #{name}"
+                        end).join(", ")
+
+                signature = "__device__ #{meth_def_node.get_type.singleton_type.to_c_type} #{meth_def_node.parent.get_type.mangled_method_name(meth_def_node.name)}(#{method_params})"
+
+                return signature
+            end
+
+            def translate_method_predecl(meth_def_node)
+                return generate_method_signature(meth_def_node) + ";"
+            end
+
+            def translate_method(meth_def_node)
+                # TODO: merge with BlockTranslator
+                # TODO: load environment variables
+
+                # Declare local variables
+                local_variables_def = ""
+                meth_def_node.local_variables_names_and_types.each do |name, type|
+                    local_variables_def += "#{type.to_c_type} #{name};\n"
+                end
+
+                # TODO: There should be a better way to ensure that we don't generate methods
+                # multiple times.
+                mangled_name = meth_def_node.parent.get_type.mangled_method_name(meth_def_node.name)
+                def_label = "def_label_#{mangled_name}"
+
+                return "#ifndef #{def_label}\n#define #{def_label}\n" +
+                    generate_method_signature(meth_def_node) + 
+                    "\n" + 
+                    wrap_in_c_block(local_variables_def + meth_def_node.body.accept(statement_translator)) +
+                    "#endif"
+            end
+        end
+    end
+end