dtr_to_rust 0.8.1 → 0.12.0

data/lib/instruction/instantiate_object.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the LogString instruction.
     class InstantiateObject < Handler
@@ -11,7 +11,9 @@ module DTRToRust
         when 'UDT'
           handle_udt
         when 'Tuple'
-          form_rust_string("let mut #{@instruction.assign} = (#{normalish_inputs});")
+          "let mut #{@instruction.assign} = (#{normalish_inputs});"
+        when 'Range'
+          "let mut #{@instruction.assign} = #{range_inputs};"
         else
           raise "Unknown object type: #{@instruction.inputs[0]}"
         end
@@ -20,7 +22,13 @@ module DTRToRust
       private
 
       def handle_list
-        form_rust_string("let mut #{@instruction.assign} = vec![#{normalish_inputs}];")
+        "let mut #{@instruction.assign} = vec![#{normalish_inputs}];"
+      end
+
+      def range_inputs
+        @instruction.inputs[1..].map do |x|
+          foobar(x)
+        end.join('..')
       end
 
       def normalish_inputs
@@ -38,13 +46,18 @@ module DTRToRust
       end
 
       def handle_udt
-        udt_found = @user_defined_types.filter { |udt| udt_name_fix(udt) == @instruction.inputs[1] }
+        # udt_found = @user_defined_types.filter { |udt| udt_name_fix(udt) == @instruction.inputs[1] }
 
-        assignment = "let mut #{@instruction.assign} = "
-        udt = "#{@instruction.inputs[1]}{"
-        inputs = inputs_to_rust_string(@instruction.inputs[2..], udt_found[0].attributes.map { |x| x[:name] })
-        end_ = '};'
-        form_rust_string("#{assignment}#{udt}#{inputs}#{end_}")
+        # assignment = "let mut #{@instruction.assign} = "
+        # udt = "#{@instruction.inputs[1]}{"
+        # inputs = inputs_to_rust_string(@instruction.inputs[2..], udt_found[0].attributes.map { |x| x[:name] })
+        # end_ = '};'
+        # form_rust_string("#{assignment}#{udt}#{inputs}#{end_}")
+
+        "let mut #{@instruction.assign} = #{@instruction.inputs[1]}{#{inputs_to_rust_string(@instruction.inputs[2..],
+                                                                                            @instruction.inputs[1])}}"
+
+        # raise 'Not implemented'
       end
 
       def inputs_to_rust_string(inputs, udt_type_names)
@@ -57,15 +70,16 @@ module DTRToRust
       end
 
       def foobar(input)
-        decorated_input = Common::InputInterpreter.interpret(input)
+        input
+        # decorated_input = Common::InputInterpreter.interpret(input)
 
-        if decorated_input[:type] == 'string'
-          "symbol_short!(#{input})"
-        elsif decorated_input[:needs_reference] && input == 'env'
-          "&#{input}"
-        else
-          input
-        end
+        # if decorated_input[:type] == 'string'
+        #   "symbol_short!(#{input})"
+        # elsif decorated_input[:needs_reference] && input == 'env'
+        #   "&#{input}"
+        # else
+        #   input
+        # end
       end
 
       def handle_input(input, udt_type_name)

data/lib/instruction/jump.rb

@@ -1,27 +1,46 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class handles the jump instruction.
     class Jump < Handler
       def handle
+        last_instruction_is_else_if = @instruction.inputs[@instruction.inputs.size - 1] == 'ELSE_IF_BRANCH'
+        last_instruction_is_while_loop = @instruction.inputs[@instruction.inputs.size - 1] == 'WHILE_LOOP'
+
         if @instruction.inputs.size == 1
           handle_unconditional_jump
         elsif @instruction.inputs.size == 2
-          handle_conditional_jump
+          last_instruction_is_else_if ? handle_unconditional_jump : handle_conditional_jump
+        elsif @instruction.inputs.size == 3 && last_instruction_is_else_if
+          handle_conditional_else_if_jump
+        elsif @instruction.inputs.size == 4 && last_instruction_is_while_loop
+          handle_while_loop
         else
-          raise 'Invalid jump instruction'
+          raise 'Invalid jump instruction. Received too many inputs: ' + @instruction.inputs.size.to_s
         end
       end
 
       private
 
       def handle_conditional_jump
-        form_rust_string("if #{@instruction.inputs[0]} {")
+        "if #{@instruction.inputs[0]} {"
+      end
+
+      def handle_while_loop
+        "while let Some(#{@instruction.inputs[0]}) = OPTION_#{@instruction.inputs[0]} {"
+      end
+
+      def handle_conditional_else_if_jump
+        "else if #{@instruction.inputs[0]} {"
       end
 
       def handle_unconditional_jump
-        form_rust_string('else {')
+        if @instruction.scope.to_i < @instruction.inputs[0].to_i
+          'else {'
+        else
+          '}'
+        end
       end
     end
   end

data/lib/instruction/multiply.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.
     class Multiply < Handler
-      def handle
-        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} * #{@instruction.inputs[1]};")
+      def initialize(instruction, metadata)
+        super('&', instruction, metadata)
       end
     end
   end

data/lib/instruction/or.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class handles the or instruction.
     class Or < Handler
@@ -10,9 +10,7 @@ module DTRToRust
 
         assignment_rust = "let #{assignment} = "
         body_rust = "#{inputs[0]} || #{inputs[1]};"
-        rust_string = "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
-
-        form_rust_string(rust_string)
+        "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
       end
     end
   end

data/lib/instruction/print.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the LogString instruction.
     class Print < Handler
       def handle
-        form_rust_string("log!(#{inputs_to_rust_string(@instruction.inputs)});")
+        "log!(#{inputs_to_rust_string(@instruction.inputs)});"
       end
 
       private
@@ -15,13 +15,14 @@ module DTRToRust
       end
 
       def ref_appender(input)
-        decorated_input = Common::InputInterpreter.interpret(input)
+        input
+        # decorated_input = Common::InputInterpreter.interpret(input)
 
-        if decorated_input[:needs_reference] && decorated_input[:value] == 'env'
-          "&#{decorated_input[:value]}"
-        else
-          decorated_input[:value]
-        end
+        # if decorated_input[:needs_reference] && decorated_input[:value] == 'env'
+        #   "&#{decorated_input[:value]}"
+        # else
+        #   decorated_input[:value]
+        # end
       end
     end
   end

data/lib/instruction/return.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the Return instruction.
     class Return < Handler
       def handle
-        form_rust_string(@instruction.inputs[0])
+        "return #{@instruction.inputs[0]};"
       end
     end
   end

data/lib/instruction/subtract.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.
     class Subtract < Handler
-      def handle
-        # TODO: fix this, depends if this is init or not
-        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} - #{@instruction.inputs[1]};")
+      def initialize(instruction, metadata)
+        super('-', instruction, metadata)
       end
     end
   end

data/lib/instruction/{goto.rb → try_assign.rb}

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class handles the goto instruction.
-    class Goto < Handler
+    class TryAssign < Handler
       def handle
-        form_rust_string("goto: #{@instruction.inputs[0]}")
+        "let #{@instruction.inputs[0]} = #{@instruction.inputs[1]}.try_into();"
       end
     end
   end

data/lib/instruction_handler.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   # This class is responsible for generating Rust code for a single instruction.
   class InstructionHandler
-    def initialize(instruction, spacing_scope, function_names, user_defined_types, is_helper)
+    def initialize(instruction, metadata)
       @instruction = instruction
-      @spacing_scope = spacing_scope
-      @function_names = function_names
-      @user_defined_types = user_defined_types
-      @is_helper = is_helper
+      @metadata = metadata
     end
 
     def generate_rust
@@ -16,20 +13,18 @@ module DTRToRust
         raise "Unknown instruction type: #{@instruction.instruction}"
       end
 
-      EXPRESSION_FOOBAR[@instruction.instruction.strip].send(:handle, @instruction, @spacing_scope, @function_names,
-                                                             @user_defined_types, @is_helper)
+      EXPRESSION_FOOBAR[@instruction.instruction.strip].send(:handle, @instruction, @metadata)
     end
 
     private
 
     EXPRESSION_FOOBAR = {
       'assign' => Instruction::Assign,
+      'break' => Instruction::Break,
       'jump' => Instruction::Jump,
-      'goto' => Instruction::Goto,
       'exit_with_message' => Instruction::ExitWithMessage,
       'and' => Instruction::And,
       'or' => Instruction::Or,
-      'label' => Instruction::Label,
       'add' => Instruction::Add,
       'subtract' => Instruction::Subtract,
       'multiply' => Instruction::Multiply,
@@ -40,7 +35,8 @@ module DTRToRust
       'evaluate' => Instruction::Evaluate,
       'field' => Instruction::Field,
       'end_of_iteration_check' => Instruction::EndOfIterationCheck,
-      'increment' => Instruction::Increment
+      'increment' => Instruction::Increment,
+      'try_assign' => Instruction::TryAssign
     }.freeze
 
     def handle_empty_instruction

data/lib/lcpbt_forrest.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module SorobanRustBackend
+  class LCPBT_Forrest
+    attr_accessor :trees
+
+    def initialize
+      @trees = []
+    end
+
+    def add_tree(tree)
+      @trees << tree
+    end
+
+    def traverse
+      @trees.map(&:traverse)
+    end
+
+    def traverse_with_indentation
+      @trees.compact.map(&:traverse_with_indentation)
+    end
+
+    # This represents a traversal through a unique path, covering all trees in the forest
+    # only once. This is useful for code generation.
+    def traverse_to_ids
+      id_map = {}
+      result = []
+
+      traverse
+        .map { |x| x.map(&:id) }
+        .each do |x|
+          sub_result = []
+          x.each do |y|
+            next if id_map[y]
+
+            sub_result << y
+            id_map[y] = true
+          end
+          result << sub_result
+        end
+
+      result
+    end
+
+    def code_generator_traverse(&block)
+      traverse_with_indentation
+        .map { |tree| tree.reverse.uniq.reverse.map(&block) }
+    end
+
+    def size
+      @trees.size
+    end
+
+    def all_paths_to(instruction_id)
+      @trees.map { |x| x.all_paths_to(instruction_id) }.flatten(1).compact
+    end
+
+    def walk_it
+      @trees.each do |x|
+        puts "Walking tree #{x.tree_id}"
+
+        stack = []
+        symbol_table = {}
+
+        stack << x
+
+        while stack.any?
+          current = stack.pop
+
+          if current.value.assign
+            symbol_table[current.value.assign] = {
+              value: current.value.id
+            }
+          end
+
+          stack << current.left_child if current.left_child
+
+          stack << current.right_child if current.right_child
+        end
+      end
+    end
+  end
+end

data/lib/left_child_preferential_binary_tree.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module SorobanRustBackend
+  class LeftChildPreferentialBinaryTree
+    attr_accessor :value, :left_child, :right_child, :tree_id, :metadata
+
+    def initialize(value, metadata:, indentation: 0)
+      @tree_id = SecureRandom.uuid
+      @indentation = indentation
+      @value = value
+      @left_child = nil
+      @right_child = nil
+      @metadata = metadata
+    end
+
+    def set_left_child(node)
+      raise 'Left child already exists' if @left_child
+
+      @left_child = node
+    end
+
+    def set_right_child(node)
+      raise 'Right child already exists' if @right_child
+
+      @right_child = node
+    end
+
+    def traverse
+      result = []
+      result << @value
+      result += @left_child.traverse if @left_child
+      result += @right_child.traverse if @right_child
+      result
+    end
+
+    def traverse_with_indentation
+      result = []
+      result << [@value, @indentation, @metadata]
+      result += @left_child.traverse_with_indentation if @left_child
+      result += @right_child.traverse_with_indentation if @right_child
+      result
+    end
+
+    def all_paths_to(instruction_id, cur_result: [])
+      if value.id == instruction_id
+        return cur_result.empty? ? [[instruction_id]] : cur_result + [instruction_id]
+      end
+
+      result = nil
+
+      if @left_child
+        left_child_traverse = @left_child.all_paths_to(instruction_id, cur_result: cur_result + [value.id])
+        result = left_child_traverse unless left_child_traverse.nil?
+      end
+
+      if @right_child
+        right_child_traverse = @right_child.all_paths_to(instruction_id, cur_result: cur_result + [value.id])
+        result = result.nil? ? right_child_traverse : [result, right_child_traverse]
+      end
+
+      result
+    end
+  end
+end

data/lib/non_translatables/handler.rb

@@ -0,0 +1,23 @@
+module SorobanRustBackend
+  module NonTranslatables
+    class Handler
+      def initialize(non_translatables)
+        @non_translatables = non_translatables
+      end
+
+      def self.generate(non_translatables)
+        new(non_translatables).generate
+      end
+
+      def generate
+        generate_non_translatables
+      end
+
+      private
+
+      def generate_non_translatables
+        @non_translatables
+      end
+    end
+  end
+end

data/lib/silviculturist.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module SorobanRustBackend
+  class Silviculturist
+    attr_accessor :forrest
+
+    def initialize(instructions, base_indentation: 0)
+      @instructions = instructions
+      @forrest = LCPBT_Forrest.new
+      @seen_instructions = {}
+      @base_indentation = base_indentation
+    end
+
+    def make_forrest
+      index = 0
+      while index < @instructions.size
+        instructions = @instructions[index..]
+        scope = 0
+        tree = plant_trees(scope, instructions, metadata: { last_node_was_conditional_jump: false, parent_scope: nil, symbol_table: {} },
+                                                indentation: @base_indentation)
+        @forrest.add_tree(tree)
+
+        seen = true
+        while seen && index < @instructions.size
+          index += 1
+          seen = @instructions[index].nil? || @seen_instructions[@instructions[index].id]
+        end
+      end
+    end
+
+    def plant_trees(scope, instructions, metadata:, from_id: nil, indentation: 0)
+      cur_instruction = instructions[0]
+
+      return nil if cur_instruction.nil?
+
+      if cur_instruction.scope != scope
+        return plant_trees(scope, instructions[1..], from_id: cur_instruction.id,
+                                                     indentation:, metadata:)
+      end
+
+      return @seen_instructions[cur_instruction.id] if @seen_instructions[cur_instruction.id]
+
+      down_jump = cur_instruction.instruction == 'jump' && (
+        (cur_instruction.inputs.size == 1 && cur_instruction.inputs[0].to_i < scope) ||
+        (cur_instruction.inputs.size == 2 && cur_instruction.inputs[1].to_i < scope))
+
+      rest_of_instructions = instructions[1..]
+
+      tree = LeftChildPreferentialBinaryTree.new(cur_instruction,
+                                                 indentation: if down_jump
+                                                                indentation - 1
+                                                              else
+                                                                indentation
+                                                              end, metadata:)
+      @seen_instructions[cur_instruction.id] = tree
+
+      case cur_instruction.instruction
+      when 'jump'
+        case cur_instruction.inputs.filter { |x| x.to_s.strip != 'ELSE_IF_BRANCH' }.size
+        # unconditional jump
+        when 1
+          new_scope = cur_instruction.inputs[0].to_i
+
+          # halt when going back to 0
+          return tree if new_scope.zero?
+
+          tree.set_left_child(plant_trees(new_scope, rest_of_instructions, from_id: cur_instruction.id,
+                                                                           indentation: down_jump ? indentation - 1 : indentation + 1, metadata: { last_node_was_conditional_jump: true, parent_scope: scope, symbol_table: metadata[:symbol_table] }))
+        # conditional jump
+        when 2
+          # detour
+          new_scope = cur_instruction.inputs[1].to_i
+
+          tree.set_left_child(plant_trees(new_scope, rest_of_instructions,
+                                          from_id: cur_instruction.id, indentation: down_jump ? indentation - 1 : indentation + 1, metadata: { last_node_was_conditional_jump: true, parent_scope: scope, symbol_table: metadata[:symbol_table] }))
+          # continue
+          tree.set_right_child(plant_trees(scope, rest_of_instructions, from_id: cur_instruction.id,
+                                                                        indentation:, metadata: { last_node_was_conditional_jump: true, parent_scope: scope, symbol_table: metadata[:symbol_table] }))
+        # if-let
+        when 3
+          raise 'We do not yet support if-let statements'
+        end
+      # the way a goto works is that you want to drop out of the loop back to the scope you were at
+      # when you started the loop
+      when 'goto'
+        goto_target_id = cur_instruction.inputs[0].to_i
+        return_scope = @instructions.find { |x| x.id == goto_target_id }.scope
+
+        tree.metadata[:return_scope] = return_scope
+
+        return tree if return_scope.zero?
+
+        # TODO: fix indentation
+        tree.set_left_child(plant_trees(return_scope.to_i, rest_of_instructions, from_id: cur_instruction.id,
+                                                                                 indentation:, metadata: {
+                                                                                   last_node_was_conditional_jump: false,
+                                                                                   parent_scope: scope,
+                                                                                   symbol_table: metadata[:symbol_table]
+                                                                                 }))
+
+      when 'try_assign'
+        metadata = {
+          last_node_was_conditional_jump: false,
+          parent_scope: scope,
+          try_assign: {
+            lhs: cur_instruction.inputs[1],
+            rhs: cur_instruction.inputs[0],
+            assign: cur_instruction.assign
+          },
+          symbol_table: metadata[:symbol_table]
+        }
+
+        return plant_trees(scope, rest_of_instructions, from_id: cur_instruction.id,
+                                                        indentation:, metadata:)
+      when 'end_of_iteration_check'
+        metadata = {
+          last_node_was_conditional_jump: false,
+          parent_scope: scope,
+          try_assign: nil,
+          end_of_iteration_check: {
+            lhs: cur_instruction.inputs[0],
+            rhs: cur_instruction.inputs[1],
+            assign: cur_instruction.assign
+          },
+          symbol_table: metadata[:symbol_table]
+        }
+
+        return plant_trees(scope, rest_of_instructions, from_id: cur_instruction.id, indentation:, metadata:)
+      else
+        last_symbol_table = metadata[:symbol_table]
+        last_symbol_table[cur_instruction.assign] = {} unless last_symbol_table.include?(cur_instruction.assign)
+        last_symbol_table[cur_instruction.assign][cur_instruction.scope] = cur_instruction
+
+        metadata = {
+          last_node_was_conditional_jump: false,
+          parent_scope: scope,
+          try_assign: nil,
+          symbol_table: last_symbol_table
+        }
+
+        # left_child
+        tree.set_left_child(plant_trees(scope, rest_of_instructions, from_id: cur_instruction.id,
+                                                                     indentation:, metadata:))
+      end
+
+      tree
+    end
+  end
+end

data/lib/soroban_rust_backend.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# This is the main module for the DTR to Rust gem.
+module SorobanRustBackend
+  autoload :LCPBT_Forrest, 'lcpbt_forrest'
+  autoload :LeftChildPreferentialBinaryTree, 'left_child_preferential_binary_tree'
+  autoload :Silviculturist, 'silviculturist'
+  autoload :CodeGenerator, 'code_generator'
+  autoload :Condenser, 'condenser'
+  autoload :InstructionHandler, 'instruction_handler'
+  autoload :UserDefinedTypesHandler, 'user_defined_types_handler'
+  autoload :FunctionHandler, 'function_handler'
+  autoload :ContractHandler, 'contract_handler'
+
+  # This module contains all the classes that handle the different types of instructions.
+  module Instruction
+    autoload :Evaluate, './lib/instruction/evaluate'
+    autoload :Field, './lib/instruction/field'
+    autoload :Handler, './lib/instruction/handler'
+    autoload :Print, './lib/instruction/print'
+    autoload :Return, './lib/instruction/return'
+    autoload :InstantiateObject, './lib/instruction/instantiate_object'
+    autoload :Add, './lib/instruction/add'
+    autoload :Subtract, './lib/instruction/subtract'
+    autoload :Multiply, './lib/instruction/multiply'
+    autoload :Divide, './lib/instruction/divide'
+    autoload :Assign, './lib/instruction/assign'
+    autoload :Jump, './lib/instruction/jump'
+    autoload :Goto, './lib/instruction/goto'
+    autoload :ExitWithMessage, './lib/instruction/exit_with_message'
+    autoload :And, './lib/instruction/and'
+    autoload :Or, './lib/instruction/or'
+    autoload :EndOfIterationCheck, './lib/instruction/end_of_iteration_check'
+    autoload :Increment, './lib/instruction/increment'
+    autoload :TryAssign, './lib/instruction/try_assign'
+    autoload :Break, './lib/instruction/break'
+    autoload :BinaryInstruction, './lib/instruction/binary_instruction'
+  end
+
+  module Common
+    autoload :TypeTranslator, './lib/common/type_translator'
+  end
+
+  module NonTranslatables
+    autoload :Handler, './lib/non_translatables/handler'
+  end
+
+  module ContractState
+    autoload :Handler, './lib/contract_state/handler'
+  end
+end