dtr_to_rust 0.2.10 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7572c039db830a1a216b31e01f53a104701d8321d487b47811a7a366ea520e53
-  data.tar.gz: d359cdc39400f9a0bdaf4823cdf77aea9c1aeb6fb7dbee931419e2208d073a51
+  metadata.gz: b758e2693dba6f08986542c9a49c6d15f285529cbb172d3a29bb171ec95536b1
+  data.tar.gz: 3d4ef34c8dfd29ff2124fe8c3b0c8ac194872729bbd9443b633a0e5e973aafb6
 SHA512:
-  metadata.gz: 8c62415d2d4f63cb331cf26bdf73c72e9b230a69c65cf8df5bf0ff83f102f4658641b329e48d3c7f01a2c53501f58be1c5bfd5133ce98b9652674911043a0b60
-  data.tar.gz: 43caee328ae2b7216104600b8a656cb0ab5cc71ceeaae6a75de277516bef5b095ab1ca2f57a495c47dd353b7bd87b3a66ace7d11ebdcd7ecff97ead0521aa381
+  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

@@ -17,6 +17,8 @@ module DTRToRust
           number_return(@input)
         elsif string?(@input)
           string_return(@input)
+        elsif boolean?(@input)
+          boolean_return(@input)
         else
           variable_return(@input)
         end
@@ -30,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 ##
@@ -58,6 +60,15 @@ module DTRToRust
         # Check if the string matches the pattern
         !!(str =~ decimal_pattern)
       end
+
+      ## Boolean ##
+      def boolean?(input)
+        input.is_a?(TrueClass) || input.is_a?(FalseClass) || input&.match?(/true|false/)
+      end
+
+      def boolean_return(_input)
+        { value: @input, type: 'boolean', needs_reference: false }
+      end
     end
   end
 end

data/lib/common/reference_appender.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Common
+    # 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
+        # ex:  env.storage().instance().get(COUNTER).unwrap_or(0);
+        #      --> env.storage().instance().get(&COUNTER).unwrap_or(0);
+        if decorated_input[:type] != 'number' &&
+           decorated_input[:value].include?('.') &&
+           decorated_input[:value].include?('(') && decorated_input[:value].include?(')')
+          more_complex_ref_appender(input, decorated_input)
+        elsif decorated_input[:needs_reference]
+          "&#{decorated_input[:value]}"
+        elsif decorated_input[:type] == 'number'
+          ref_nums ? "&#{decorated_input[:value]}" : decorated_input[:value]
+        else
+          decorated_input[:value]
+        end
+      end
+
+      def self.more_complex_ref_appender(_input, decorated_input)
+        decorated_input[:value].split('.').map do |x|
+          x = x.strip
+          if call_with_input?(x)
+            matches = x.scan(/\((.*?)\)/)
+            things = matches
+                     .flatten
+                     .filter(&method(:not_empty_string?))
+                     .map(&method(:wild_stuff))
+                     .join(', ')
+            "#{x.split('(')[0]}(#{things})"
+          else
+            x
+          end
+        end.join('.')
+      end
+
+      def self.not_empty_string?(input)
+        input != ''
+      end
+
+      def self.wild_stuff(input)
+        input.split(',').map { |x| ReferenceAppender.call(x.strip) }.join(', ')
+      end
+
+      def self.call_with_input?(input)
+        input.include?('(') && input.end_with?(')') && !input.end_with?('()')
+      end
+    end
+  end
+end

data/lib/common/type_translator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Common
+    # TypeTranslator translates DTR types to Rust types
+    module TypeTranslator
+      def self.translate_type(type)
+        # TODO: fix this, it is incorrect
+        type
+          .gsub('List<', 'Vec<')
+          .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')
+      end
+    end
+  end
+end

data/lib/dtr_to_rust.rb

@@ -7,18 +7,48 @@ module DTRToRust
 
   # This module contains all the classes that handle the different types of instructions.
   module Instruction
-    autoload :AddAndAssign, 'instruction/add_and_assign'
-    autoload :CreateList, 'instruction/create_list'
     autoload :Evaluate, 'instruction/evaluate'
     autoload :Field, 'instruction/field'
     autoload :Handler, 'instruction/handler'
-    autoload :InitializeUDT, 'instruction/initialize_udt'
-    autoload :LogString, 'instruction/log_string'
+    autoload :Print, 'instruction/print'
     autoload :Return, 'instruction/return'
+    autoload :InstantiateObject, 'instruction/instantiate_object'
+    autoload :Add, 'instruction/add'
+    autoload :Subtract, 'instruction/subtract'
+    autoload :Multiply, 'instruction/multiply'
+    autoload :Divide, 'instruction/divide'
+    autoload :Assign, 'instruction/assign'
+    autoload :Jump, 'instruction/jump'
+    autoload :Goto, 'instruction/goto'
+    autoload :ExitWithMessage, 'instruction/exit_with_message'
+    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.
   module Common
     autoload :InputInterpreter, 'common/input_interpreter'
+    autoload :ReferenceAppender, 'common/reference_appender'
+    autoload :TypeTranslator, 'common/type_translator'
+  end
+
+  # 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

@@ -12,11 +12,13 @@ module DTRToRust
     def generate
       @content = ''
 
-      generate_contract_header
       generate_user_defined_types
       generate_state
       generate_contract_name
-      generate_functions
+      generate_interface
+      generate_helpers
+
+      generate_contract_header
 
       @content
     end
@@ -34,8 +36,38 @@ module DTRToRust
     attr_reader :dtr_contract
 
     def generate_contract_header
+      imports_super_set = %w[
+        Address
+        BytesN
+        contract
+        contractimpl
+        contracttype
+        contracterror
+        symbol_short
+        vec
+        Env
+        Symbol
+        Vec
+        log
+        token
+      ]
+
+      used_imports = []
+
+      @content.split.each do |word|
+        imports_super_set.each do |import|
+          used_imports << import if word.include?(import)
+        end
+      end
+
+      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::{contract, contractimpl, symbol_short, vec, Env, Symbol, Vec, log};\n\n"
+      @content = "#![no_std]\nuse soroban_sdk::{#{used_imports.join(', ')}};\n\n" + @content
     end
 
     def generate_contract_name
@@ -47,73 +79,114 @@ module DTRToRust
 
       dtr_contract.state.each do |state_value|
         if state_value.type == 'String'
-          @content += "const #{state_value.name}: Symbol = symbol_short!(\"#{state_value.initial_value}\");\n"
+          @content += "const #{state_value.name}: Symbol = symbol_short!(#{state_value.initial_value});\n"
+        else
+          @content += "const #{state_value.name}: #{Common::TypeTranslator.translate_type(state_value.type)} = #{state_value.initial_value};\n"
         end
       end
 
       @content += "\n"
     end
 
-    def generate_functions
-      @content += "#[contractimpl]\nimpl #{dtr_contract.name} {#{generate_functions_each(dtr_contract.functions)}}\n"
+    def generate_interface
+      @content += "#[contractimpl]\nimpl #{dtr_contract.name} {#{generate_functions_each(dtr_contract.interface,
+                                                                                         false)}}\n"
     end
 
-    def generate_functions_each(functions)
+    def generate_helpers
+      @content += "#{generate_functions_each(dtr_contract.helpers, true)}\n"
+    end
+
+    def generate_functions_each(functions, is_helper)
+      function_names = functions&.map(&:name)
+
       functions&.map do |function|
-        return_string = "\n    pub fn #{function.name}(#{generate_function_args(function)}) "
+        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(function.instructions)}\n    }\n"
+        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)
+            @last_scope -= 1
+          end
+        end
+        return_string += "\n#{is_helper ? '' : '    '}}\n"
 
         return_string
       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?
 
-      "-> #{translate_type(function.output)}"
+      "-> #{Common::TypeTranslator.translate_type(function.output)}"
     end
 
     def generate_function_args(function)
       all_inputs = [] + function.inputs
 
-      all_inputs.map { |x| "#{x[:name]}: #{translate_type(x[:type_name])}" }.join(', ')
+      all_inputs.map { |x| "#{x[:name]}: #{Common::TypeTranslator.translate_type(x[:type_name])}" }.join(', ')
     end
 
-    def generate_instructions_each(instructions)
+    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 && @last_scope > spacing_scope
+          while @last_scope > spacing_scope
+            content += form_rust_string("}\n", @last_scope, is_helper)
+            @last_scope -= 1
+          end
+        end
+        @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|
-        generate_instruction(instruction)
+        content = ''
+        content += generate_instruction(instruction, spacing_scope, function_names, is_helper)
+
+        content
       end.join("\n")
     end
 
-    def generate_instruction(instruction)
-      handler = InstructionHandler.new(instruction)
-      handler.generate_rust
+    def form_rust_string(instruction_string, scope, is_helper)
+      "#{spacing(scope, is_helper)}#{instruction_string}"
     end
 
-    def translate_type(type)
-      case type
-      when 'String'
-        'Symbol'
-      when 'Vec<String>'
-        'Vec<Symbol>'
-      when 'List<String>'
-        'Vec<Symbol>'
-      else
-        type
-      end
+    def spacing(scope, is_helper)
+      '    ' * (is_helper ? 0 : scope + 1)
+    end
+
+    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
 
     def generate_user_defined_types
       return if dtr_contract.user_defined_types.nil?
 
       dtr_contract.user_defined_types.each do |udt|
-        @content += "#{derives}pub struct #{udt.name} {#{udt.attributes.map { |x| "#{x[:name]}: #{x[:type]}" }.join(', ')}}\n\n"
+        @content += DTRToRust::UserDefinedTypes::Handler.generate(udt)
       end
     end
-
-    def derives
-      "#[contracttype]\n#[derive(Clone, Debug, Eq, PartialEq)]\n"
-    end
   end
 end

data/lib/instruction/add.rb

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

data/lib/instruction/and.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    # This class handles the and instruction.
+    class And < 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/assign.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    # This class handles the assign instruction.
+    class Assign < Handler
+      def handle
+        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
+end

data/lib/instruction/divide.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    # This class handles the add instruction.
+    class Divide < Handler
+      def handle
+        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} / #{@instruction.inputs[1]};")
+      end
+    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

@@ -5,34 +5,109 @@ module DTRToRust
     # This class is responsible for generating Rust code for the Evaluate instruction.
     class Evaluate < Handler
       def handle
-        inputs = @instruction[:inputs][1..]
-        evaluated_method_name = @instruction[:inputs][0]
-        assignment = @instruction[:assign]
+        rust_string = handle_keyword_method_invocation
+        form_rust_string(rust_string)
+      end
 
-        rust_string = if assignment.nil?
-                        "#{evaluated_method_name}(#{inputs_to_rust_string(inputs)});"
-                      else
-                        "let mut #{assignment} = #{evaluated_method_name}(#{inputs_to_rust_string(inputs)});"
-                      end
+      private
 
-        form_rust_string(rust_string, @instruction[:scope])
+      def handle_keyword_method_invocation
+        case @instruction.inputs[0]
+        when 'equal_to'
+          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
       end
 
-      private
+      def handle_non_keyword_method_invocation
+        inputs = @instruction.inputs[1..]
+        evaluated_method_name = @instruction.inputs[0]
+        assignment = @instruction.assign
+
+        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,
+                                                                                       append_ref_to_num?, try_append_ref_to_var?)});"
+        "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
+      end
+
+      def handle_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_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};"
 
-      def inputs_to_rust_string(inputs)
-        inputs.map { |input| ref_appender(input) }.join(', ')
+        "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
       end
 
-      def ref_appender(input)
-        decorated_input = Common::InputInterpreter.interpret(input)
+      def handle_less_than_or_equal_to
+        inputs = @instruction.inputs[1..]
+        @instruction.inputs[0]
+        assignment = @instruction.assign
 
-        if decorated_input[:needs_reference]
-          "&#{decorated_input[:value]}"
+        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]
+        assignment = @instruction.assign
+
+        assignment_rust = "let #{assignment} = "
+        body_rust = "!(#{inputs[0]});"
+
+        "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
+      end
+
+      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)
+        if @function_names.include?(evaluated_method_name)
+          "Self::#{evaluated_method_name}"
         else
-          decorated_input[:value]
+          evaluated_method_name
         end
       end
+
+      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
 end

data/lib/instruction/exit_with_message.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Instruction
+    # This class handles the exit_with_message instruction.
+    class ExitWithMessage < Handler
+      def handle
+        form_rust_string("panic!(#{inputs_to_rust_string(@instruction.inputs)});")
+      end
+
+      private
+
+      def inputs_to_rust_string(inputs)
+        inputs.map { |input| Common::ReferenceAppender.call(input) }.join(', ')
+      end
+    end
+  end
+end