dtr_to_rust 0.2.10 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7572c039db830a1a216b31e01f53a104701d8321d487b47811a7a366ea520e53
-  data.tar.gz: d359cdc39400f9a0bdaf4823cdf77aea9c1aeb6fb7dbee931419e2208d073a51
+  metadata.gz: b42b05c23f4f6cd523b03895ef4e41734d83d836f768143379b12d996415038d
+  data.tar.gz: d23996a0656a9ee252065f4f36d68646d18c42a9b9a05fe9897574ca4453dfb8
 SHA512:
-  metadata.gz: 8c62415d2d4f63cb331cf26bdf73c72e9b230a69c65cf8df5bf0ff83f102f4658641b329e48d3c7f01a2c53501f58be1c5bfd5133ce98b9652674911043a0b60
-  data.tar.gz: 43caee328ae2b7216104600b8a656cb0ab5cc71ceeaae6a75de277516bef5b095ab1ca2f57a495c47dd353b7bd87b3a66ace7d11ebdcd7ecff97ead0521aa381
+  metadata.gz: f4238874b6d9be9f31090673903cf2d265b0aa5bcf4eb69056eb642b8750b73724a46bb005ad0e5fad7e22a98ca6e6ae95de9c401e8533bd6aa334622bc1002f
+  data.tar.gz: baebd2c976094cc88714c008f93ce5fd048fb0b5eb8a3c174d2ec899b612606a837d7c9bc7da1b12319d79d141793768c17336d5c82126226f24af7e491d3652

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
@@ -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,56 @@
+# frozen_string_literal: true
+
+module DTRToRust
+  module Common
+    # This module appends references to variables.
+    module ReferenceAppender
+      def self.call(input, ref_nums: false)
+        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,20 @@
+# 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('String', 'Symbol')
+          .gsub('Boolean', 'bool')
+          .gsub('Float', 'f64')
+      end
+    end
+  end
+end

data/lib/dtr_to_rust.rb

@@ -7,18 +7,39 @@ 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'
   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'
+  end
+
+  # This module contains all the classes that handle user defined types.
+  module UserDefinedTypes
+    autoload :Handler, 'user_defined_types/handler'
   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,30 @@ module DTRToRust
     attr_reader :dtr_contract
 
     def generate_contract_header
+      imports_super_set = %w[
+        contract
+        contractimpl
+        contracttype
+        symbol_short
+        vec
+        Env
+        Symbol
+        Vec
+        log
+      ]
+
+      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: 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,22 +71,44 @@ 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_helpers
+      @content += "#{generate_functions_each(dtr_contract.helpers, true)}\n"
     end
 
-    def generate_functions_each(functions)
+    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)}) "
+        @last_scope = nil
+        optimized_instructions =
+          Optimization::ChainedInvocationAssignmentReduction.apply(function.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_each(optimized_instructions, function_names,
+                                                           is_helper)}"
+        unless @last_scope.nil?
+          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")
@@ -71,49 +117,49 @@ module DTRToRust
     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_each(instructions, function_names, is_helper)
       instructions.map do |instruction|
-        generate_instruction(instruction)
+        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
+        end
+        content += generate_instruction(instruction, 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, function_names, is_helper)
+      handler = InstructionHandler.new(instruction, 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,13 @@
+# 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]};",
+                         @instruction.scope)
+      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, @instruction.scope)
+      end
+    end
+  end
+end

data/lib/instruction/assign.rb

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

data/lib/instruction/divide.rb

@@ -0,0 +1,13 @@
+# 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]};",
+                         @instruction.scope)
+      end
+    end
+  end
+end

data/lib/instruction/evaluate.rb

@@ -5,34 +5,74 @@ 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, @instruction.scope)
+      end
+
+      private
+
+      def handle_keyword_method_invocation
+        case @instruction.inputs[0]
+        when 'equal_to'
+          handle_equal_to
+        when '!'
+          handle_unary_negation
+        else
+          handle_non_keyword_method_invocation
+        end
+      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
+      def handle_non_keyword_method_invocation
+        inputs = @instruction.inputs[1..]
+        evaluated_method_name = @instruction.inputs[0]
+        assignment = @instruction.assign
 
-        form_rust_string(rust_string, @instruction[:scope])
+        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)});"
+        "#{assignment.nil? ? '' : assignment_rust}#{body_rust}"
       end
 
-      private
+      def handle_equal_to
+        inputs = @instruction.inputs[1..]
+        @instruction.inputs[0]
+        assignment = @instruction.assign
 
-      def inputs_to_rust_string(inputs)
-        inputs.map { |input| ref_appender(input) }.join(', ')
+        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 ref_appender(input)
-        decorated_input = Common::InputInterpreter.interpret(input)
+      def don_t_append_ref
+        @instruction.inputs[0].end_with?('set') || @instruction.inputs[0].end_with?('unwrap_or')
+      end
 
-        if decorated_input[:needs_reference]
-          "&#{decorated_input[:value]}"
+      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)
+        inputs.map { |input| Common::ReferenceAppender.call(input, ref_nums:) }.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)};", @instruction.scope)
+      end
+
+      private
+
+      def inputs_to_rust_string(inputs)
+        inputs.map { |input| Common::ReferenceAppender.call(input) }.join(', ')
+      end
+    end
+  end
+end

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}", @instruction.scope)
       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
+        ''
+      end
+    end
+  end
+end

data/lib/instruction/handler.rb

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

data/lib/instruction/instantiate_object.rb

@@ -0,0 +1,67 @@
+# 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
+        else
+          raise "Unknown object type: #{@instruction.inputs[0]}"
+        end
+      end
+
+      private
+
+      def handle_list
+        form_rust_string("let mut #{@instruction.assign} = vec![#{inputs_to_rust_string(@instruction.inputs[1..])}];",
+                         @instruction.scope)
+      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_}", @instruction.scope)
+      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 handle_input(input, udt_type_name)
+        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
+
+        "#{udt_type_name}: #{value}"
+      end
+    end
+  end
+end

data/lib/instruction/jump.rb

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

data/lib/instruction/multiply.rb

@@ -0,0 +1,13 @@
+# 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]};",
+                         @instruction.scope)
+      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, @instruction.scope)
+      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)});", @instruction.scope)
       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], @instruction.scope)
       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
+        form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]} - #{@instruction.inputs[1]};",
+                         @instruction.scope)
+      end
+    end
+  end
+end

data/lib/instruction_handler.rb

@@ -3,33 +3,46 @@
 module DTRToRust
   # This class is responsible for generating Rust code for a single instruction.
   class InstructionHandler
-    def initialize(instruction)
+    def initialize(instruction, function_names, user_defined_types, is_helper)
       @instruction = instruction
+      @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, @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
+    }.freeze
+
+    def handle_empty_instruction
+      ''
+    end
     attr_reader :instruction
   end
 end

data/lib/optimization/chained_invocation_assignment_reduction.rb

@@ -0,0 +1,113 @@
+# 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?
+        @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.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)}")
+          @optimized_inputs << input # evaluate_input(key, value)
+          done_a_thing = true
+          @to_remove[value[:index]] = true
+          next
+        end
+
+        @optimized_inputs << input unless done_a_thing
+      end
+
+      def evaluate_input(_key, input)
+        InstructionHandler.new(DTRCore::Instruction.new('evaluate', input[:inputs], nil, 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/user_defined_types/handler.rb

@@ -0,0 +1,55 @@
+# 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|
+          "    #{x[:name]},"
+        end.join("\n")
+      end
+
+      def derives
+        "#[contracttype]\n#[derive(Clone, Debug, Eq, PartialEq)]\n"
+      end
+
+      def struct?
+        @user_defined_type.name.end_with? '_STRUCT'
+      end
+
+      def enum?
+        @user_defined_type.name.end_with? '_ENUM'
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtr_to_rust
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.3.0
 platform: ruby
 authors:
 - Rob Durst
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-16 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies: []
 description: Rust to DTR translator (Digicus Textual Representation).
 email:
@@ -18,17 +18,30 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/common/input_interpreter.rb
+- lib/common/reference_appender.rb
+- lib/common/type_translator.rb
 - lib/dtr_to_rust.rb
 - lib/generator.rb
-- lib/instruction/add_and_assign.rb
-- lib/instruction/create_list.rb
+- lib/instruction/add.rb
+- lib/instruction/and.rb
+- lib/instruction/assign.rb
+- lib/instruction/divide.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/initialize_udt.rb
-- lib/instruction/log_string.rb
+- lib/instruction/instantiate_object.rb
+- lib/instruction/jump.rb
+- lib/instruction/label.rb
+- lib/instruction/multiply.rb
+- lib/instruction/or.rb
+- lib/instruction/print.rb
 - lib/instruction/return.rb
+- lib/instruction/subtract.rb
 - lib/instruction_handler.rb
+- lib/optimization/chained_invocation_assignment_reduction.rb
+- lib/user_defined_types/handler.rb
 homepage: https://spaced-out-thoughts-dev-foundation.github.io/digicus/
 licenses:
 - MIT
@@ -49,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.13
 signing_key:
 specification_version: 4
 summary: Rust to DTR translator (Digicus Textual Representation).

data/lib/instruction/add_and_assign.rb

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

data/lib/instruction/create_list.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module DTRToRust
-  module Instruction
-    # This class is responsible for generating Rust code for the AddAndAssign instruction.
-    class CreateList < Handler
-      def handle
-        form_rust_string("let #{@instruction[:assign]} = vec![#{handle_inputs}];",
-                         @instruction[:scope])
-      end
-
-      private
-
-      def handle_inputs
-        @instruction[:inputs].map { |input| handle_input(input) }.join(', ')
-      end
-
-      def handle_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
-      end
-    end
-  end
-end

data/lib/instruction/initialize_udt.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module DTRToRust
-  module Instruction
-    # This class is responsible for generating Rust code for the Field instruction.
-    class InitializeUDT < Handler
-      def handle
-        form_rust_string("#{handle_assign}#{handle_udt_part}", @instruction[:scope])
-      end
-
-      private
-
-      def handle_udt_part
-        "#{@instruction[:inputs][0]} { #{@instruction[:inputs][1..].join(' ')} };"
-      end
-
-      def handle_assign
-        "let mut #{@instruction[:assign]} = " if @instruction[:assign]
-      end
-    end
-  end
-end