dtr_to_rust 0.2.10 → 0.5.0

data/lib/instruction/field.rb

@@ -5,17 +5,17 @@ module DTRToRust
     # This class is responsible for generating Rust code for the Field instruction.
     class Field < Handler
       def handle
-        form_rust_string("#{handle_field_assign}#{handle_field_call}", @instruction[:scope])
+        form_rust_string("#{handle_field_assign}#{handle_field_call}")
       end
 
       private
 
       def handle_field_call
-        "#{@instruction[:inputs][0]}.#{@instruction[:inputs][1]};"
+        "#{@instruction.inputs[0]}.#{@instruction.inputs[1]};"
       end
 
       def handle_field_assign
-        "let mut #{@instruction[:assign]} = " if @instruction[:assign]
+        "let mut #{@instruction.assign} = " if @instruction.assign
       end
     end
   end

data/lib/instruction/goto.rb

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

data/lib/instruction/handler.rb

@@ -4,20 +4,24 @@ module DTRToRust
   module Instruction
     # This class is responsible for generating Rust code for the AddAndAssign instruction.
     class Handler
-      def initialize(instruction)
+      def initialize(instruction, spacing_scope, function_names, user_defined_types, is_helper)
         @instruction = instruction
+        @spacing_scope = spacing_scope
+        @function_names = function_names
+        @user_defined_types = user_defined_types
+        @is_helper = is_helper
       end
 
-      def self.handle(instruction)
-        new(instruction).handle
+      def self.handle(instruction, spacing_scope, function_names, user_defined_types, is_helper)
+        new(instruction, spacing_scope, function_names, user_defined_types, is_helper).handle
       end
 
-      def spacing(scope)
-        '        ' * (scope + 1)
+      def spacing
+        '    ' * (@is_helper ? 1 : @spacing_scope + 2)
       end
 
-      def form_rust_string(instruction_string, scope)
-        "#{spacing(scope)}#{instruction_string}"
+      def form_rust_string(instruction_string)
+        "#{spacing}#{instruction_string}"
       end
     end
   end

data/lib/instruction/increment.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    class Increment < Handler
+      def handle
+        form_rust_string("increment: #{@instruction.inputs[0]}")
+      end
+    end
+  end
+end

data/lib/instruction/instantiate_object.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    # This class is responsible for generating Rust code for the LogString instruction.
+    class InstantiateObject < Handler
+      def handle
+        case @instruction.inputs[0]
+        when 'List'
+          handle_list
+        when 'UDT'
+          handle_udt
+        when 'Tuple'
+          form_rust_string("let mut #{@instruction.assign} = (#{normalish_inputs});")
+        else
+          raise "Unknown object type: #{@instruction.inputs[0]}"
+        end
+      end
+
+      private
+
+      def handle_list
+        form_rust_string("let mut #{@instruction.assign} = vec![#{normalish_inputs}];")
+      end
+
+      def normalish_inputs
+        @instruction.inputs[1..].map do |x|
+          foobar(x)
+        end.join(', ')
+      end
+
+      def udt_name_fix(udt)
+        if udt.name.end_with?('_STRUCT') || udt.name.end_with?('_ENUM')
+          udt.name.split('_')[0..-2].join('_')
+        else
+          udt.name
+        end
+      end
+
+      def handle_udt
+        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_}")
+      end
+
+      def inputs_to_rust_string(inputs, udt_type_names)
+        inputs_to_return = []
+        inputs.each_with_index do |input, index|
+          inputs_to_return << handle_input(input, udt_type_names[index])
+        end
+
+        inputs_to_return.join(', ')
+      end
+
+      def foobar(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
+      end
+
+      def handle_input(input, udt_type_name)
+        value = foobar(input)
+
+        "#{udt_type_name}: #{value}"
+      end
+    end
+  end
+end

data/lib/instruction/jump.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    # This class handles the jump instruction.
+    class Jump < Handler
+      def handle
+        if @instruction.inputs.size == 1
+          handle_unconditional_jump
+        elsif @instruction.inputs.size == 2
+          handle_conditional_jump
+        else
+          raise 'Invalid jump instruction'
+        end
+      end
+
+      private
+
+      def handle_conditional_jump
+        form_rust_string("if #{@instruction.inputs[0]} {")
+      end
+
+      def handle_unconditional_jump
+        form_rust_string('else {')
+      end
+    end
+  end
+end

data/lib/instruction/label.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    # This class handles the label instruction.
+    class Label < Handler
+      def handle
+        form_rust_string("label: #{@instruction.inputs[0]}")
+      end
+    end
+  end
+end

data/lib/instruction/multiply.rb

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

data/lib/instruction/or.rb

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

data/lib/instruction/{log_string.rb → print.rb}

@@ -3,9 +3,9 @@
 module DTRToRust
   module Instruction
     # This class is responsible for generating Rust code for the LogString instruction.
-    class LogString < Handler
+    class Print < Handler
       def handle
-        form_rust_string("log!(#{inputs_to_rust_string(@instruction[:inputs])});", @instruction[:scope])
+        form_rust_string("log!(#{inputs_to_rust_string(@instruction.inputs)});")
       end
 
       private

data/lib/instruction/return.rb

@@ -5,7 +5,7 @@ module DTRToRust
     # This class is responsible for generating Rust code for the Return instruction.
     class Return < Handler
       def handle
-        form_rust_string(@instruction[:inputs][0], @instruction[:scope])
+        form_rust_string(@instruction.inputs[0])
       end
     end
   end

data/lib/instruction/subtract.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  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]};")
+      end
+    end
+  end
+end

data/lib/instruction_handler.rb

@@ -3,33 +3,49 @@
 module DTRToRust
   # This class is responsible for generating Rust code for a single instruction.
   class InstructionHandler
-    def initialize(instruction)
+    def initialize(instruction, spacing_scope, function_names, user_defined_types, is_helper)
       @instruction = instruction
+      @spacing_scope = spacing_scope
+      @function_names = function_names
+      @user_defined_types = user_defined_types
+      @is_helper = is_helper
     end
 
     def generate_rust
-      case @instruction[:instruction]
-      when 'Return'
-        Instruction::Return.handle(@instruction)
-      when 'log_string'
-        Instruction::LogString.handle(@instruction)
-      when 'add_and_assign'
-        Instruction::AddAndAssign.handle(@instruction)
-      when 'evaluate'
-        Instruction::Evaluate.handle(@instruction)
-      when 'create_list'
-        Instruction::CreateList.handle(@instruction)
-      when 'field'
-        Instruction::Field.handle(@instruction)
-      when 'initialize_udt'
-        Instruction::InitializeUDT.handle(@instruction)
-      else
-        raise "Unknown instruction type: #{@instruction[:instruction]}"
+      unless EXPRESSION_FOOBAR.key?(@instruction.instruction.strip)
+        raise "Unknown instruction type: #{@instruction.instruction}"
       end
+
+      EXPRESSION_FOOBAR[@instruction.instruction.strip].send(:handle, @instruction, @spacing_scope, @function_names,
+                                                             @user_defined_types, @is_helper)
     end
 
     private
 
+    EXPRESSION_FOOBAR = {
+      'assign' => Instruction::Assign,
+      '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,
+      'divide' => Instruction::Divide,
+      'instantiate_object' => Instruction::InstantiateObject,
+      'print' => Instruction::Print,
+      'return' => Instruction::Return,
+      'evaluate' => Instruction::Evaluate,
+      'field' => Instruction::Field,
+      'end_of_iteration_check' => Instruction::EndOfIterationCheck,
+      'increment' => Instruction::Increment
+    }.freeze
+
+    def handle_empty_instruction
+      ''
+    end
     attr_reader :instruction
   end
 end

data/lib/optimization/binary_x_to_self_assignment_reduction.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Optimization
+    # This class is responsible for reducing binary operations that assign the result to the same variable
+    class BinaryXToSelfAssignmentReduction
+      def initialize(instructions)
+        @instructions = instructions
+        @cur_instruction = nil
+        @optimized_instructions = []
+        @memoize_assigns = {}
+        @to_remove = {}
+        @last_was_eavluate = nil
+      end
+
+      def self.apply(instructions)
+        new(instructions).apply
+      end
+
+      def apply
+        @instructions.each_with_index do |instruction, index|
+          @cur_instruction = instruction
+
+          if skip_instruction?
+            @optimized_instructions << @cur_instruction
+            next unless @cur_instruction.assign && @cur_instruction.assign == @cur_instruction.assign.upcase
+
+            @memoize_assigns[@cur_instruction.assign] = {
+              inputs: @cur_instruction.inputs,
+              index:
+            }
+            next
+          end
+
+          apply_to_instruction(index)
+        end
+        actually_optimized_instructions = []
+        @optimized_instructions.each_with_index do |instruction, index|
+          actually_optimized_instructions << instruction unless @to_remove[index]
+        end
+
+        actually_optimized_instructions
+      end
+
+      private
+
+      def skip_instruction?
+        !%w[add subtract divide multiply].include?(@cur_instruction.instruction)
+      end
+
+      def apply_to_instruction(index)
+        match_on0 = @cur_instruction.inputs[0] == @cur_instruction.assign
+        match_on1 = @cur_instruction.inputs[1] == @cur_instruction.assign
+
+        unless @cur_instruction.inputs.length == 2 &&
+               (match_on1 || match_on0)
+
+          @optimized_instructions << @cur_instruction
+          return
+        end
+
+        optimized_inputs = []
+
+        if @memoize_assigns[@cur_instruction.inputs[0]]
+          optimized_inputs << @memoize_assigns[@cur_instruction.inputs[0]][:inputs]
+          @to_remove[@memoize_assigns[@cur_instruction.inputs[0]][:index]] = true
+        else
+          optimized_inputs << @cur_instruction.inputs[0]
+        end
+
+        if @memoize_assigns[@cur_instruction.inputs[1]]
+          optimized_inputs << @memoize_assigns[@cur_instruction.inputs[1]][:inputs]
+          @to_remove[@memoize_assigns[@cur_instruction.inputs[1]][:index]] = true
+        else
+          optimized_inputs << @cur_instruction.inputs[1]
+        end
+
+        optimized_inputs.flatten!
+        assignment = match_on0 ? optimized_inputs[0] : optimized_inputsinputs[1]
+
+        @optimized_instructions << DTRCore::Instruction.new(@cur_instruction.instruction, optimized_inputs, assignment,
+                                                            @cur_instruction.scope)
+
+        return unless @cur_instruction.assign && @cur_instruction.assign == @cur_instruction.assign.upcase
+
+        @memoize_assigns[@cur_instruction.assign] = {
+          inputs: optimized_inputs,
+          index:
+        }
+      end
+    end
+  end
+end

data/lib/optimization/chained_invocation_assignment_reduction.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Optimization
+    # Optimizes the instructions by reducing chained invocation assignments
+    class ChainedInvocationAssignmentReduction
+      def initialize(instructions)
+        @instructions = instructions
+        @cur_instruction = nil
+        @optimized_instructions = []
+        @memoize_assigns = {}
+        @to_remove = {}
+        @last_was_eavluate = nil
+      end
+
+      def apply
+        @instructions.each_with_index do |instruction, index|
+          @cur_instruction = instruction
+
+          if skip_instruction?
+            @optimized_instructions << @cur_instruction
+            next
+          end
+
+          apply_to_instruction(index)
+        end
+        actually_optimized_instructions = []
+        @optimized_instructions.each_with_index do |instruction, index|
+          actually_optimized_instructions << instruction unless @to_remove[index]
+        end
+
+        actually_optimized_instructions
+      end
+
+      def skip_instruction?
+        @cur_instruction.instruction == 'instantiate_object'
+      end
+
+      def self.apply(instructions)
+        new(instructions).apply
+      end
+
+      def apply_to_instruction(index)
+        @optimized_inputs = []
+
+        @cur_instruction&.inputs&.each do |input|
+          apply_to_instruction_input(@cur_instruction, input)
+        end
+        @optimized_instructions << DTRCore::Instruction.new(@cur_instruction.instruction, @optimized_inputs,
+                                                            @cur_instruction&.assign, @cur_instruction.scope)
+
+        @memoize_assigns = {} unless clear_memoize?
+        return unless @cur_instruction.assign && @cur_instruction.assign == @cur_instruction.assign.upcase && !%w[
+          add subtract multiply divide
+        ].include?(@cur_instruction.instruction)
+
+        @memoize_assigns[@cur_instruction.assign] = {
+          inputs: @optimized_inputs,
+          index:
+        }
+      end
+
+      def clear_memoize?
+        if @last_was_eavluate.nil?
+          @last_was_eavluate = @cur_instruction.instruction == 'evaluate'
+          return false
+        end
+
+        if @cur_instruction.instruction == 'evaluate'
+          if @last_was_eavluate
+            false
+          else
+            @last_was_eavluate = true
+            true
+          end
+        elsif @last_was_eavluate
+          @last_was_eavluate = false
+          true
+        else
+          false
+        end
+      end
+
+      def apply_to_instruction_input(_instruction, input)
+        done_a_thing = false
+        memoize_assigns_to_clear = []
+        @memoize_assigns.each do |key, value|
+          next unless do_a_thing?(input, key, input.split('.')[0])
+
+          # input = input.gsub(key, "#{value[:inputs][0]}(#{value[:inputs][1..].join(', ')})")
+
+          input = input.gsub(key, evaluate_input(key, value).to_s)
+          @optimized_inputs << input # evaluate_input(key, value)
+          done_a_thing = true
+          @to_remove[value[:index]] = true
+          memoize_assigns_to_clear << key
+          next
+        end
+
+        @optimized_inputs << input unless done_a_thing
+
+        memoize_assigns_to_clear.each do |key|
+          @memoize_assigns.delete(key)
+        end
+      end
+
+      def evaluate_input(_key, input)
+        InstructionHandler.new(DTRCore::Instruction.new('evaluate', input[:inputs], nil, 0), 0, [], [],
+                               false).generate_rust.strip.gsub(';', '')
+      end
+
+      def do_a_thing?(input, key, input_beginning)
+        input &&
+          key &&
+          input_beginning == key &&
+          !(input.start_with?('"') &&
+          input.end_with?('"')) &&
+          @cur_instruction.instruction == 'evaluate' &&
+          !['equal_to', '!'].include?(@cur_instruction)
+      end
+    end
+  end
+end

data/lib/optimization/field_to_assignment_conversion.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Optimization
+    # This class is responsible for converting field instructions to assignment instructions
+    class FieldToAssignmentConversion
+      def initialize(instructions)
+        @instructions = instructions
+      end
+
+      def self.apply(instructions)
+        new(instructions).apply
+      end
+
+      def apply
+        @instructions.map do |instruction|
+          next instruction if skip_instruction?(instruction)
+
+          apply_to_instruction(instruction)
+        end
+      end
+
+      private
+
+      def skip_instruction?(instruction)
+        instruction.instruction != 'field'
+      end
+
+      def apply_to_instruction(instruction)
+        return instruction unless instruction.inputs.length == 2
+
+        DTRCore::Instruction.new('assign', ["#{instruction.inputs[0]}.#{instruction.inputs[1]}"], instruction.assign,
+                                 instruction.scope)
+      end
+    end
+  end
+end

data/lib/user_defined_types/handler.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module UserDefinedTypes
+    class Handler
+      def initialize(user_defined_type)
+        @user_defined_type = user_defined_type
+      end
+
+      def self.generate(user_defined_type)
+        new(user_defined_type).generate
+      end
+
+      def generate
+        if struct?
+          generate_struct
+        elsif enum?
+          generate_enum
+        end
+      end
+
+      def generate_struct
+        "#{derives}pub struct #{@user_defined_type.name.gsub('_STRUCT', '')} {\n#{generate_struct_attributes}\n}\n\n"
+      end
+
+      def generate_struct_attributes
+        @user_defined_type.attributes.map do |x|
+          "    pub #{x[:name]}: #{Common::TypeTranslator.translate_type(x[:type])},"
+        end.join("\n")
+      end
+
+      def generate_enum
+        "#{derives}pub enum #{@user_defined_type.name.gsub('_ENUM', '')} {\n#{generate_enum_attributes}\n}\n\n"
+      end
+
+      def generate_enum_attributes
+        @user_defined_type.attributes.map do |x|
+          if x[:value]
+            "    #{x[:name]} = #{x[:value]},"
+          elsif x[:type] && x[:type] != '()'
+            "    #{x[:name]}(#{Common::TypeTranslator.translate_type(x[:type])}),"
+          else
+            "    #{x[:name]},"
+          end
+        end.join("\n")
+      end
+
+      def derives
+        base = if error? && enum?
+                 "#[contracterror]\n#[derive(Clone, Debug, Eq, PartialEq)]\n"
+               else
+                 "#[contracttype]\n#[derive(Clone, Debug, Eq, PartialEq)]\n"
+               end
+
+        base += "#[repr(u32)]\n" if numbered_enum?
+
+        base
+      end
+
+      # TODO: fix this terrible hack
+      def error?
+        @user_defined_type.name.start_with? 'Error'
+      end
+
+      def struct?
+        @user_defined_type.name.end_with? '_STRUCT'
+      end
+
+      def enum?
+        @user_defined_type.name.end_with? '_ENUM'
+      end
+
+      def numbered_enum?
+        enum? && @user_defined_type.attributes.all? { |x| x[:value] }
+      end
+    end
+  end
+end