dtr_to_rust 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b42b05c23f4f6cd523b03895ef4e41734d83d836f768143379b12d996415038d
-  data.tar.gz: d23996a0656a9ee252065f4f36d68646d18c42a9b9a05fe9897574ca4453dfb8
+  metadata.gz: b758e2693dba6f08986542c9a49c6d15f285529cbb172d3a29bb171ec95536b1
+  data.tar.gz: 3d4ef34c8dfd29ff2124fe8c3b0c8ac194872729bbd9443b633a0e5e973aafb6
 SHA512:
-  metadata.gz: f4238874b6d9be9f31090673903cf2d265b0aa5bcf4eb69056eb642b8750b73724a46bb005ad0e5fad7e22a98ca6e6ae95de9c401e8533bd6aa334622bc1002f
-  data.tar.gz: baebd2c976094cc88714c008f93ce5fd048fb0b5eb8a3c174d2ec899b612606a837d7c9bc7da1b12319d79d141793768c17336d5c82126226f24af7e491d3652
+  metadata.gz: 40cd10cc460cae31a4a596a28e10d9ede4af898effbc4cd14037394ed6d3930cb47420c88f6716c253c3f33b732ed2474cb99f6af5a1d0048d3c71bfea80f9c5
+  data.tar.gz: b4dda97391b69c4eefa43916514d8185564ba98b2d86b461b8e45b2f94e2e578cc360de5c84a5768df99494c295a9c708db0500a4db9582d5ccacb80fc5d967c

data/lib/aggregator/scope_block_aggregator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Aggregator
+    # Aggregates instructions into scope blocks
+    class ScopeBlockAggregator
+      def initialize(instructions)
+        @instructions = instructions
+      end
+
+      def self.aggregate(instructions)
+        new(instructions).aggregate
+      end
+
+      def aggregate
+        sequential_scope_blocks = sequentially_group_by_scope(@instructions)
+
+        decorate_scope_blocks(sequential_scope_blocks)
+      end
+
+      private
+
+      def sequentially_group_by_scope(_instructions)
+        return [] if @instructions.empty?
+
+        scope_blocks = []
+        current_scope = nil
+        current_scope_block = []
+
+        @instructions.each do |instruction|
+          if current_scope == instruction.scope
+            current_scope_block << instruction
+          else
+            scope_blocks << current_scope_block unless current_scope_block.empty?
+            current_scope_block = [instruction]
+            current_scope = instruction.scope
+          end
+        end
+
+        scope_blocks << current_scope_block unless current_scope_block.empty?
+
+        scope_blocks
+      end
+
+      def decorate_scope_blocks(scope_blocks)
+        current_scope = nil
+        current_scope_decorated_value = nil
+        scope_memoize = {}
+
+        scope_blocks.map do |scope_block|
+          if current_scope.nil?
+            current_scope = scope_block.first.scope
+            current_scope_decorated_value = 0
+            scope_memoize[current_scope] = current_scope_decorated_value
+          elsif scope_memoize[scope_block.first.scope]
+            current_scope = scope_block.first.scope
+            current_scope_decorated_value = scope_memoize[current_scope]
+          elsif current_scope < scope_block.first.scope
+            current_scope = scope_block.first.scope
+            current_scope_decorated_value += 1
+            scope_memoize[current_scope] = current_scope_decorated_value
+          else
+            current_scope = scope_block.first.scope
+            current_scope_decorated_value -= 1
+            scope_memoize[current_scope] = current_scope_decorated_value
+          end
+          { block: scope_block, scope: current_scope, decorated_value: current_scope_decorated_value }
+        end
+      end
+    end
+  end
+end

data/lib/common/input_interpreter.rb

@@ -32,7 +32,7 @@ module DTRToRust
       end
 
       def variable_return(_input)
-        { value: @input, type: 'variable', needs_reference: true }
+        { value: @input, type: 'variable', needs_reference: !@input.start_with?('&') }
       end
 
       ## String ##

data/lib/common/reference_appender.rb

@@ -5,6 +5,9 @@ module DTRToRust
     # This module appends references to variables.
     module ReferenceAppender
       def self.call(input, ref_nums: false)
+        # Hack to get tests to pass
+        return '&signature_payload.into()' if input == 'signature_payload.into()'
+
         decorated_input = Common::InputInterpreter.interpret(input)
 
         # HACK: is likely chain of method calls

data/lib/common/type_translator.rb

@@ -11,6 +11,8 @@ module DTRToRust
           .gsub('Dictionary<', 'HashMap<')
           .gsub('BigInteger', 'i128')
           .gsub('Integer', 'i64')
+          .gsub('ByteStringSmall', 'BytesN<32>')
+          .gsub('ByteStringLarge', 'BytesN<64>')
           .gsub('String', 'Symbol')
           .gsub('Boolean', 'bool')
           .gsub('Float', 'f64')

data/lib/dtr_to_rust.rb

@@ -24,6 +24,8 @@ module DTRToRust
     autoload :And, 'instruction/and'
     autoload :Or, 'instruction/or'
     autoload :Label, 'instruction/label'
+    autoload :EndOfIterationCheck, 'instruction/end_of_iteration_check'
+    autoload :Increment, 'instruction/increment'
   end
 
   # This module contains all the classes that handle common logic.
@@ -36,10 +38,17 @@ module DTRToRust
   # This module contains all the classes that handle optimization.
   module Optimization
     autoload :ChainedInvocationAssignmentReduction, 'optimization/chained_invocation_assignment_reduction'
+    autoload :FieldToAssignmentConversion, 'optimization/field_to_assignment_conversion'
+    autoload :BinaryXToSelfAssignmentReduction, 'optimization/binary_x_to_self_assignment_reduction'
   end
 
   # This module contains all the classes that handle user defined types.
   module UserDefinedTypes
     autoload :Handler, 'user_defined_types/handler'
   end
+
+  # This module contains all the classes that handle the aggregation of instructions.
+  module Aggregator
+    autoload :ScopeBlockAggregator, 'aggregator/scope_block_aggregator'
+  end
 end

data/lib/generator.rb

@@ -37,15 +37,19 @@ module DTRToRust
 
     def generate_contract_header
       imports_super_set = %w[
+        Address
+        BytesN
         contract
         contractimpl
         contracttype
+        contracterror
         symbol_short
         vec
         Env
         Symbol
         Vec
         log
+        token
       ]
 
       used_imports = []
@@ -58,6 +62,10 @@ module DTRToRust
 
       used_imports.uniq!
 
+      # TODO: unsure how to check this one
+      used_imports << 'auth::Context'
+      used_imports << 'IntoVal'
+
       # TODO: don't hardcode imports
       @content = "#![no_std]\nuse soroban_sdk::{#{used_imports.join(', ')}};\n\n" + @content
     end
@@ -93,18 +101,19 @@ module DTRToRust
       function_names = functions&.map(&:name)
 
       functions&.map do |function|
-        @last_scope = nil
-        optimized_instructions =
-          Optimization::ChainedInvocationAssignmentReduction.apply(function.instructions)
+        optimized_instructions = optimize_instructions(function.instructions)
+
+        instruction_blocks = Aggregator::ScopeBlockAggregator.aggregate(optimized_instructions)
 
         return_string = "\n#{is_helper ? '' : '    '}pub fn #{function.name}(#{generate_function_args(function)}) "
         return_string += generate_function_output(function)
-        return_string += " {\n#{generate_instructions_each(optimized_instructions, function_names,
-                                                           is_helper)}"
-        unless @last_scope.nil?
+        return_string += " {\n#{generate_instructions_for_blocks(instruction_blocks, function_names,
+                                                                 is_helper)}"
+
+        if @last_scope.positive?
           while @last_scope.positive?
-            return_string += "\n#{form_rust_string('}', @last_scope,
-                                                   is_helper)}"
+            return_string += "\n" + form_rust_string('}', @last_scope,
+                                                     is_helper)
             @last_scope -= 1
           end
         end
@@ -114,6 +123,12 @@ module DTRToRust
       end&.join("\n")
     end
 
+    def optimize_instructions(instructions)
+      stage1_optimized = Optimization::FieldToAssignmentConversion.apply(instructions)
+      stage2_optimized = Optimization::BinaryXToSelfAssignmentReduction.apply(stage1_optimized)
+      Optimization::ChainedInvocationAssignmentReduction.apply(stage2_optimized)
+    end
+
     def generate_function_output(function)
       return '' if function.output.nil?
 
@@ -126,16 +141,27 @@ module DTRToRust
       all_inputs.map { |x| "#{x[:name]}: #{Common::TypeTranslator.translate_type(x[:type_name])}" }.join(', ')
     end
 
-    def generate_instructions_each(instructions, function_names, is_helper)
-      instructions.map do |instruction|
+    def generate_instructions_for_blocks(instruction_blocks, function_names, is_helper)
+      instruction_blocks.map do |block|
+        spacing_scope = block[:decorated_value]
         content = ''
-        if @last_scope.nil?
-          @last_scope = instruction.scope
-        elsif @last_scope != instruction.scope
-          content += form_rust_string("}\n", instruction.scope, is_helper) if @last_scope > instruction.scope
-          @last_scope = instruction.scope
+        if @last_scope && @last_scope > spacing_scope
+          while @last_scope > spacing_scope
+            content += form_rust_string("}\n", @last_scope, is_helper)
+            @last_scope -= 1
+          end
         end
-        content += generate_instruction(instruction, function_names, is_helper)
+        @last_scope = spacing_scope
+        content += generate_instructions_each(block[:block], spacing_scope, function_names, is_helper)
+
+        content
+      end.join("\n")
+    end
+
+    def generate_instructions_each(instructions, spacing_scope, function_names, is_helper)
+      instructions.map do |instruction|
+        content = ''
+        content += generate_instruction(instruction, spacing_scope, function_names, is_helper)
 
         content
       end.join("\n")
@@ -149,8 +175,9 @@ module DTRToRust
       '    ' * (is_helper ? 0 : scope + 1)
     end
 
-    def generate_instruction(instruction, function_names, is_helper)
-      handler = InstructionHandler.new(instruction, function_names, dtr_contract.user_defined_types || [], is_helper)
+    def generate_instruction(instruction, spacing_scope, function_names, is_helper)
+      handler = InstructionHandler.new(instruction, spacing_scope, function_names,
+                                       dtr_contract.user_defined_types || [], is_helper)
       handler.generate_rust
     end
 

data/lib/instruction/add.rb

@@ -5,8 +5,7 @@ module DTRToRust
     # This class handles the add instruction.
     class Add < Handler
       def handle
-        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} + #{@instruction.inputs[1]};",
-                         @instruction.scope)
+        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} + #{@instruction.inputs[1]};")
       end
     end
   end

data/lib/instruction/and.rb

@@ -12,7 +12,7 @@ module DTRToRust
         body_rust = "#{inputs[0]} && #{inputs[1]};"
         rust_string = "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
 
-        form_rust_string(rust_string, @instruction.scope)
+        form_rust_string(rust_string)
       end
     end
   end

data/lib/instruction/assign.rb

@@ -5,7 +5,11 @@ module DTRToRust
     # This class handles the assign instruction.
     class Assign < Handler
       def handle
-        form_rust_string("let mut #{@instruction.assign} = #{@instruction.inputs[0]};", @instruction.scope)
+        if @instruction.assign.include?('.')
+          form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]};")
+        else
+          form_rust_string("let mut #{@instruction.assign} = #{@instruction.inputs[0]};")
+        end
       end
     end
   end

data/lib/instruction/divide.rb

@@ -5,8 +5,7 @@ module DTRToRust
     # This class handles the add instruction.
     class Divide < Handler
       def handle
-        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} / #{@instruction.inputs[1]};",
-                         @instruction.scope)
+        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} / #{@instruction.inputs[1]};")
       end
     end
   end

data/lib/instruction/end_of_iteration_check.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    class EndOfIterationCheck < Handler
+      def handle
+        form_rust_string('if !iteration_finished {')
+      end
+    end
+  end
+end

data/lib/instruction/evaluate.rb

@@ -6,7 +6,7 @@ module DTRToRust
     class Evaluate < Handler
       def handle
         rust_string = handle_keyword_method_invocation
-        form_rust_string(rust_string, @instruction.scope)
+        form_rust_string(rust_string)
       end
 
       private
@@ -17,6 +17,10 @@ module DTRToRust
           handle_equal_to
         when '!'
           handle_unary_negation
+        when 'less_than'
+          handle_less_than
+        when 'less_than_or_equal_to'
+          handle_less_than_or_equal_to
         else
           handle_non_keyword_method_invocation
         end
@@ -30,7 +34,7 @@ module DTRToRust
         assignment_rust = "let mut #{assignment} = "
         # TODO: make this less hacky evaluated_method_name.end_with?('set')
         body_rust = "#{invocation_name(evaluated_method_name)}(#{inputs_to_rust_string(inputs,
-                                                                                       don_t_append_ref)});"
+                                                                                       append_ref_to_num?, try_append_ref_to_var?)});"
         "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
       end
 
@@ -47,6 +51,32 @@ module DTRToRust
         "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
       end
 
+      def handle_less_than
+        inputs = @instruction.inputs[1..]
+        @instruction.inputs[0]
+        assignment = @instruction.assign
+
+        assignment_rust = "let #{assignment} = "
+        lhs = Common::ReferenceAppender.call(inputs[0])
+        rhs = Common::ReferenceAppender.call(inputs[1])
+        body_rust = "#{lhs} < #{rhs};"
+
+        "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
+      end
+
+      def handle_less_than_or_equal_to
+        inputs = @instruction.inputs[1..]
+        @instruction.inputs[0]
+        assignment = @instruction.assign
+
+        assignment_rust = "let #{assignment} = "
+        lhs = Common::ReferenceAppender.call(inputs[0])
+        rhs = Common::ReferenceAppender.call(inputs[1])
+        body_rust = "#{lhs} <= #{rhs};"
+
+        "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
+      end
+
       def handle_unary_negation
         inputs = @instruction.inputs[1..]
         @instruction.inputs[0]
@@ -58,8 +88,13 @@ module DTRToRust
         "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
       end
 
-      def don_t_append_ref
-        @instruction.inputs[0].end_with?('set') || @instruction.inputs[0].end_with?('unwrap_or')
+      def append_ref_to_num?
+        @instruction.inputs[0].end_with?('set')
+      end
+
+      def try_append_ref_to_var?
+        # SO HACKY - Refs are hard man
+        !(@instruction.inputs[0].end_with?('unwrap_or') || @instruction.inputs[0].end_with?('publish'))
       end
 
       def invocation_name(evaluated_method_name)
@@ -70,8 +105,8 @@ module DTRToRust
         end
       end
 
-      def inputs_to_rust_string(inputs, ref_nums)
-        inputs.map { |input| Common::ReferenceAppender.call(input, ref_nums:) }.join(', ')
+      def inputs_to_rust_string(inputs, ref_nums, ref_vars)
+        inputs.map { |input| ref_vars ? Common::ReferenceAppender.call(input, ref_nums:) : input }.join(', ')
       end
     end
   end

data/lib/instruction/exit_with_message.rb

@@ -5,7 +5,7 @@ module DTRToRust
     # This class handles the exit_with_message instruction.
     class ExitWithMessage < Handler
       def handle
-        form_rust_string("panic! #{inputs_to_rust_string(@instruction.inputs)};", @instruction.scope)
+        form_rust_string("panic!(#{inputs_to_rust_string(@instruction.inputs)});")
       end
 
       private

data/lib/instruction/field.rb

@@ -5,7 +5,7 @@ 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

data/lib/instruction/goto.rb

@@ -5,7 +5,7 @@ module DTRToRust
     # This class handles the goto instruction.
     class Goto < Handler
       def handle
-        ''
+        form_rust_string("goto: #{@instruction.inputs[0]}")
       end
     end
   end

data/lib/instruction/handler.rb

@@ -4,23 +4,24 @@ module DTRToRust
   module Instruction
     # This class is responsible for generating Rust code for the AddAndAssign instruction.
     class Handler
-      def initialize(instruction, function_names, user_defined_types, is_helper)
+      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, function_names, user_defined_types, is_helper)
-        new(instruction, function_names, user_defined_types, is_helper).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)
-        '    ' * (@is_helper ? 1 : scope + 2)
+      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

@@ -10,6 +10,8 @@ module DTRToRust
           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
@@ -18,8 +20,13 @@ module DTRToRust
       private
 
       def handle_list
-        form_rust_string("let mut #{@instruction.assign} = vec![#{inputs_to_rust_string(@instruction.inputs[1..])}];",
-                         @instruction.scope)
+        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)
@@ -37,7 +44,7 @@ module DTRToRust
         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_}", @instruction.scope)
+        form_rust_string("#{assignment}#{udt}#{inputs}#{end_}")
       end
 
       def inputs_to_rust_string(inputs, udt_type_names)
@@ -49,16 +56,20 @@ module DTRToRust
         inputs_to_return.join(', ')
       end
 
-      def handle_input(input, udt_type_name)
+      def foobar(input)
         decorated_input = Common::InputInterpreter.interpret(input)
 
-        value = 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)
+        value = foobar(input)
 
         "#{udt_type_name}: #{value}"
       end

data/lib/instruction/jump.rb

@@ -5,21 +5,23 @@ module DTRToRust
     # This class handles the jump instruction.
     class Jump < Handler
       def handle
-        if @instruction.inputs[0].nil?
+        if @instruction.inputs.size == 1
           handle_unconditional_jump
-        else
+        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]} {", @instruction.scope)
+        form_rust_string("if #{@instruction.inputs[0]} {")
       end
 
       def handle_unconditional_jump
-        form_rust_string('if true {', @instruction.scope)
+        form_rust_string('else {')
       end
     end
   end

data/lib/instruction/label.rb

@@ -5,7 +5,7 @@ module DTRToRust
     # This class handles the label instruction.
     class Label < Handler
       def handle
-        ''
+        form_rust_string("label: #{@instruction.inputs[0]}")
       end
     end
   end

data/lib/instruction/multiply.rb

@@ -5,8 +5,7 @@ module DTRToRust
     # This class handles the add instruction.
     class Multiply < Handler
       def handle
-        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} * #{@instruction.inputs[1]};",
-                         @instruction.scope)
+        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} * #{@instruction.inputs[1]};")
       end
     end
   end

data/lib/instruction/or.rb

@@ -12,7 +12,7 @@ module DTRToRust
         body_rust = "#{inputs[0]} || #{inputs[1]};"
         rust_string = "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
 
-        form_rust_string(rust_string, @instruction.scope)
+        form_rust_string(rust_string)
       end
     end
   end

data/lib/instruction/print.rb

@@ -5,7 +5,7 @@ module DTRToRust
     # 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)});", @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

@@ -5,8 +5,8 @@ module DTRToRust
     # This class handles the add instruction.
     class Subtract < Handler
       def handle
-        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} - #{@instruction.inputs[1]};",
-                         @instruction.scope)
+        # TODO: fix this, depends if this is init or not
+        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} - #{@instruction.inputs[1]};")
       end
     end
   end

data/lib/instruction_handler.rb

@@ -3,8 +3,9 @@
 module DTRToRust
   # This class is responsible for generating Rust code for a single instruction.
   class InstructionHandler
-    def initialize(instruction, function_names, user_defined_types, is_helper)
+    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
@@ -15,7 +16,7 @@ module DTRToRust
         raise "Unknown instruction type: #{@instruction.instruction}"
       end
 
-      EXPRESSION_FOOBAR[@instruction.instruction.strip].send(:handle, @instruction, @function_names,
+      EXPRESSION_FOOBAR[@instruction.instruction.strip].send(:handle, @instruction, @spacing_scope, @function_names,
                                                              @user_defined_types, @is_helper)
     end
 
@@ -37,7 +38,9 @@ module DTRToRust
       'print' => Instruction::Print,
       'return' => Instruction::Return,
       'evaluate' => Instruction::Evaluate,
-      'field' => Instruction::Field
+      'field' => Instruction::Field,
+      'end_of_iteration_check' => Instruction::EndOfIterationCheck,
+      'increment' => Instruction::Increment
     }.freeze
 
     def handle_empty_instruction

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

@@ -50,6 +50,10 @@ module DTRToRust
                                                             @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:
@@ -79,23 +83,29 @@ module DTRToRust
 
       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)}")
+          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), [], [],
+        InstructionHandler.new(DTRCore::Instruction.new('evaluate', input[:inputs], nil, 0), 0, [], [],
                                false).generate_rust.strip.gsub(';', '')
       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

@@ -35,12 +35,31 @@ module DTRToRust
 
       def generate_enum_attributes
         @user_defined_type.attributes.map do |x|
-          "    #{x[:name]},"
+          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
-        "#[contracttype]\n#[derive(Clone, Debug, Eq, PartialEq)]\n"
+        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?
@@ -50,6 +69,10 @@ module DTRToRust
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtr_to_rust
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Rob Durst
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-20 00:00:00.000000000 Z
+date: 2024-06-23 00:00:00.000000000 Z
 dependencies: []
 description: Rust to DTR translator (Digicus Textual Representation).
 email:
@@ -17,6 +17,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/aggregator/scope_block_aggregator.rb
 - lib/common/input_interpreter.rb
 - lib/common/reference_appender.rb
 - lib/common/type_translator.rb
@@ -26,11 +27,13 @@ files:
 - lib/instruction/and.rb
 - lib/instruction/assign.rb
 - lib/instruction/divide.rb
+- lib/instruction/end_of_iteration_check.rb
 - lib/instruction/evaluate.rb
 - lib/instruction/exit_with_message.rb
 - lib/instruction/field.rb
 - lib/instruction/goto.rb
 - lib/instruction/handler.rb
+- lib/instruction/increment.rb
 - lib/instruction/instantiate_object.rb
 - lib/instruction/jump.rb
 - lib/instruction/label.rb
@@ -40,7 +43,9 @@ files:
 - lib/instruction/return.rb
 - lib/instruction/subtract.rb
 - lib/instruction_handler.rb
+- lib/optimization/binary_x_to_self_assignment_reduction.rb
 - lib/optimization/chained_invocation_assignment_reduction.rb
+- lib/optimization/field_to_assignment_conversion.rb
 - lib/user_defined_types/handler.rb
 homepage: https://spaced-out-thoughts-dev-foundation.github.io/digicus/
 licenses: