dtr_to_rust 0.8.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 002e00efbc75ccf74ff3383c9027901e390186aaa8c40d1c415f0c88610972c6
-  data.tar.gz: 24a42f407043cd7273d651626f6e7d9f0cac095b0023a37459198dc775b5481e
+  metadata.gz: 395b86bb45dc20bc681eaf200679c503120b2f88a22711ddbf504cd34cc581e3
+  data.tar.gz: 31770e47b89d3470604e6ce81119337db2f97654ee5cabec4c0c986b715ecd72
 SHA512:
-  metadata.gz: c752d59d3a79a59ee1e0e46858cdf46539e0db4ecc1c4cfef6de53b368a5f493e4be37d0febf0f553d64393fd831226c926e415f5adeee2d217372d1c439ac1c
-  data.tar.gz: d52b67210ae2d46ed11f3b21d9873687f08251f15879343742f2fc2d8a066f0869e845970fc0b60f015f9f230ad794ed0595f47aab33f3497f898ca7df5f5dbc
+  metadata.gz: e218d9931087b5c4f5a5569d58dd0f6a36b130f10d58f032cdd603b9ea11caea0c9d7ad8562d5c685b8d319f944cff4df77333995ef9572508598324827ff8bd
+  data.tar.gz: 386e31210d3c385fa0147615f112f43f2a7f3d0cefd8b8859c737dcce2d0211257bc7d4eba57c3cc2aca4e4beacbbe6f7fbbe6f318bf7c0ea79b3fbd8648b823

data/lib/code_generator.rb

@@ -0,0 +1,90 @@
+module SorobanRustBackend
+  class CodeGenerator
+    def initialize(instructions, base_indentation: 0)
+      @instructions = instructions
+      @base_indentation = base_indentation
+
+      silviculturist = SorobanRustBackend::Silviculturist.new(instructions, base_indentation:)
+      silviculturist.make_forrest
+
+      @forrest = silviculturist.forrest
+    end
+
+    def generate
+      return_string = ''
+
+      @forrest
+        .code_generator_traverse do |y|
+        y = y.compact
+
+        og_instruction = y[0]
+        instruction = handle_metadata(y[0], y[2])
+        indentation = og_instruction.instruction == 'goto' ? y[2][:return_scope] + @base_indentation : y[1]
+
+        return_string << "#{'    ' * indentation}#{InstructionHandler.new(instruction, y[2]).generate_rust}\n"
+      end
+
+      return_string
+    end
+
+    def handle_metadata(instruction, metadata)
+      if instruction.instruction == 'goto'
+        DTRCore::Instruction.new(
+          'jump',
+          [metadata[:return_scope]],
+          instruction.assign,
+          instruction.scope,
+          instruction.id
+        )
+      elsif match_statement?(instruction, metadata)
+        DTRCore::Instruction.new(
+          'jump',
+          instruction.inputs + ['ELSE_IF_BRANCH'],
+          instruction.assign,
+          instruction.scope,
+          instruction.id
+        )
+      elsif if_let?(instruction, metadata)
+        let_statement = "let #{metadata[:try_assign][:lhs]} = #{metadata[:try_assign][:rhs]}"
+        DTRCore::Instruction.new(
+          'jump',
+          [let_statement, instruction.inputs[1]],
+          instruction.assign,
+          instruction.scope,
+          instruction.id
+        )
+      elsif while_loop?(instruction, metadata)
+        operator_variable = "#{metadata[:end_of_iteration_check][:lhs]}"
+        iterator_variable = "#{metadata[:end_of_iteration_check][:rhs]}"
+
+        DTRCore::Instruction.new(
+          'jump',
+          [operator_variable, iterator_variable, instruction.inputs[1], 'WHILE_LOOP'],
+          instruction.assign,
+          instruction.scope,
+          instruction.id
+        )
+      else
+        instruction
+      end
+    end
+
+    def match_statement?(instruction, metadata)
+      metadata[:last_node_was_conditional_jump] && instruction.instruction == 'jump' && metadata[:parent_scope] && metadata[:parent_scope] == instruction.scope
+    end
+
+    def if_let?(instruction, metadata)
+      instruction.instruction == 'jump' &&
+        metadata[:try_assign] &&
+        metadata[:try_assign][:assign] == instruction.inputs[0] &&
+        metadata[:parent_scope] == instruction.scope
+    end
+
+    def while_loop?(instruction, metadata)
+      instruction.instruction == 'jump' &&
+        metadata[:end_of_iteration_check] &&
+        metadata[:end_of_iteration_check][:assign] == instruction.inputs[0] &&
+        metadata[:parent_scope] == instruction.scope
+    end
+  end
+end

data/lib/common/type_translator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Common
     # TypeTranslator translates DTR types to Rust types
     module TypeTranslator
@@ -10,10 +10,10 @@ module DTRToRust
           .gsub('List<', 'Vec<')
           .gsub('Dictionary<', 'HashMap<')
           .gsub('BigInteger', 'i128')
-          .gsub('Integer', 'i64')
+          .gsub('Integer', 'i128')
           .gsub('ByteStringSmall', 'BytesN<32>')
           .gsub('ByteStringLarge', 'BytesN<64>')
-          .gsub('String', 'Symbol')
+          # .gsub('String', 'Symbol')
           .gsub('Boolean', 'bool')
           .gsub('Float', 'f64')
       end

data/lib/contract_handler.rb

@@ -0,0 +1,98 @@
+module SorobanRustBackend
+  class ContractHandler
+    def initialize(contract)
+      @dtr_contract = contract
+    end
+
+    def self.generate(contract)
+      new(contract).generate
+    end
+
+    def generate
+      generate_contract
+    end
+
+    private
+
+    attr_reader :dtr_contract
+
+    def generate_contract
+      @content = ''
+
+      @content += NonTranslatables::Handler.generate(dtr_contract.non_translatables) if dtr_contract.non_translatables
+
+      if dtr_contract.user_defined_types
+        dtr_contract.user_defined_types.each do |user_defined_type|
+          @content += SorobanRustBackend::UserDefinedTypesHandler.generate(user_defined_type)
+        end
+      end
+      @content += ContractState::Handler.generate(dtr_contract.state) if dtr_contract.state
+      generate_contract_name
+      generate_interface if dtr_contract.interface
+      generate_helpers if dtr_contract.helpers
+
+      generate_contract_header
+
+      @content
+    end
+
+    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, is_helper)
+      # function_names = functions&.map(&:name)
+
+      functions&.map do |function|
+        FunctionHandler.generate(function, is_helper)
+      end&.join("\n")
+    end
+
+    def generate_contract_header
+      imports_super_set = %w[
+        Address
+        BytesN
+        contract
+        contractimpl
+        contracttype
+        contracterror
+        symbol_short
+        vec
+        Env
+        String
+        Symbol
+        Vec
+        Val
+        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'
+      used_imports << 'unwrap::UnwrapOptimized'
+
+      # TODO: don't hardcode imports
+      @content = "#![no_std]\nuse soroban_sdk::{#{used_imports.join(', ')}};\n\n" + @content
+    end
+
+    def generate_contract_name
+      @content += "#[contract]\npub struct #{dtr_contract.name};\n\n"
+    end
+  end
+end

data/lib/contract_state/handler.rb

@@ -0,0 +1,35 @@
+module SorobanRustBackend
+  module ContractState
+    class Handler
+      def initialize(state)
+        @state = state
+      end
+
+      def self.generate(state)
+        new(state).generate
+      end
+
+      def generate
+        generate_state
+      end
+
+      private
+
+      def generate_state
+        content = ''
+
+        @state.each do |state_value|
+          if state_value.type == 'Symbol'
+            content += "const #{state_value.name}: Symbol = symbol_short!(#{state_value.initial_value});\n"
+          elsif state_value.type == 'String'
+            content += "const #{state_value.name}: String = String::from_str(#{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
+      end
+    end
+  end
+end

data/lib/function_handler.rb

@@ -0,0 +1,47 @@
+module SorobanRustBackend
+  class FunctionHandler
+    def initialize(function, is_helper)
+      @function = function
+      @is_helper = is_helper
+    end
+
+    def self.generate(function, is_helper)
+      new(function, is_helper).generate
+    end
+
+    def generate
+      content = ''
+
+      content = "\n#{@is_helper ? '' : '    '}pub fn #{@function.name}(#{generate_function_args}) "
+      content += generate_function_output
+
+      content += " {\n"
+      if @function.output
+        content += "#{@is_helper ? '    ' : '        '}let Thing_to_return: #{Common::TypeTranslator.translate_type(@function.output)};\n"
+      end
+      content += generate_instructions_for_blocks(@function.instructions)
+
+      content += "\n#{@is_helper ? '' : '    '}}\n"
+
+      content
+    end
+
+    private
+
+    def generate_function_output
+      return '' if @function.output.nil?
+
+      "-> #{Common::TypeTranslator.translate_type(@function.output)}"
+    end
+
+    def generate_function_args
+      all_inputs = [] + @function.inputs
+
+      all_inputs.map { |x| "#{x[:name]}: #{Common::TypeTranslator.translate_type(x[:type_name])}" }.join(', ')
+    end
+
+    def generate_instructions_for_blocks(instructions)
+      CodeGenerator.new(instructions, base_indentation: @is_helper ? 1 : 2).generate
+    end
+  end
+end

data/lib/instruction/add.rb

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

data/lib/instruction/and.rb

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

data/lib/instruction/assign.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class handles the assign instruction.
     class Assign < Handler
       def handle
         if @instruction.assign.include?('.') || @instruction.assign == 'Thing_to_return'
-          form_rust_string("#{@instruction.assign} = #{@instruction.inputs[0]};")
+          "#{@instruction.assign} = #{@instruction.inputs[0]};"
         else
-          form_rust_string("let mut #{@instruction.assign} = #{@instruction.inputs[0]};")
+          "let mut #{@instruction.assign} = #{@instruction.inputs[0]};"
         end
       end
     end

data/lib/instruction/binary_instruction.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SorobanRustBackend
+  module Instruction
+    # This class handles the add instruction.
+    class BinaryInstruction < Handler
+      def initialize(operation, instruction, metadata)
+        @operation = operation
+
+        super(instruction, metadata)
+      end
+
+      def handle
+        if @metadata[:symbol_table].include?(@instruction.assign) || @instruction.assign.include?('.')
+          "#{@instruction.assign} = #{@instruction.inputs[0]} #{@operation} #{@instruction.inputs[1]};"
+        else
+          "let mut #{@instruction.assign} = #{@instruction.inputs[0]} #{@operation} #{@instruction.inputs[1]};"
+        end
+      end
+    end
+  end
+end

data/lib/instruction/break.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SorobanRustBackend
+  module Instruction
+    # This class handles the add instruction.
+    class Break < Handler
+      def handle
+        'break;'
+      end
+    end
+  end
+end

data/lib/instruction/divide.rb

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

data/lib/instruction/end_of_iteration_check.rb

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

data/lib/instruction/evaluate.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the Evaluate instruction.
     class Evaluate < Handler
       def handle
-        rust_string = handle_keyword_method_invocation
-        form_rust_string(rust_string)
+        handle_keyword_method_invocation
       end
 
       private
@@ -27,11 +26,17 @@ module DTRToRust
           handle_binary('>=')
         when 'not_equal_to'
           handle_binary('!=')
+        when 'start'
+          handle_start
         else
           handle_non_keyword_method_invocation
         end
       end
 
+      def handle_start
+        "let mut OPTION_#{@instruction.assign} = #{@instruction.inputs[1]}.next();"
+      end
+
       def handle_non_keyword_method_invocation
         inputs = @instruction.inputs[1..]
         evaluated_method_name = @instruction.inputs[0]
@@ -44,7 +49,7 @@ module DTRToRust
         "#{if assignment.nil?
              ''
            else
-             assignment == 'Thing_to_return' ? assignment + ' = ' : assignment_rust
+             assignment == 'Thing_to_return' ? "#{assignment} = " : assignment_rust
            end}#{body_rust}"
       end
 
@@ -81,20 +86,29 @@ module DTRToRust
         !(@instruction.inputs[0].end_with?('unwrap_or') ||
         @instruction.inputs[0].end_with?('publish') ||
         @instruction.inputs[0].end_with?('Err') ||
-        @instruction.inputs[0].end_with?('Ok')
+        @instruction.inputs[0].end_with?('Ok') ||
+        @instruction.inputs[0].end_with?('checked_mul') ||
+        @instruction.inputs[0].end_with?('checked_add') ||
+        @instruction.inputs[0].end_with?('update_current_contract_wasm') ||
+        @instruction.inputs[0].end_with?('with_address') ||
+        @instruction.inputs[0].end_with?('deploy')
          )
       end
 
       def invocation_name(evaluated_method_name)
-        if @function_names.include?(evaluated_method_name)
-          "Self::#{evaluated_method_name}"
-        else
-          evaluated_method_name
-        end
+        # if @function_names.include?(evaluated_method_name)
+        # "Self::#{evaluated_method_name}"
+        # else
+        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(', ')
+      def inputs_to_rust_string(inputs, _ref_nums, _ref_vars)
+        # inputs.map do |input|
+        #   ref_vars ? Common::ReferenceAppender.call(input, ref_nums:, function_inputs: @function_inputs) : input
+        # end.join(', ')
+
+        inputs.join(', ')
       end
     end
   end

data/lib/instruction/exit_with_message.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   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)});")
+        "panic!(#{inputs_to_rust_string(@instruction.inputs)});"
       end
 
       private
 
       def inputs_to_rust_string(inputs)
-        inputs.map { |input| Common::ReferenceAppender.call(input) }.join(', ')
+        # inputs.map { |input| Common::ReferenceAppender.call(input, function_inputs: @function_inputs) }.join(', ')
+        inputs.map { |input| input }.join(', ')
       end
     end
   end

data/lib/instruction/field.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the Field instruction.
     class Field < Handler
       def handle
-        form_rust_string("#{handle_field_assign}#{handle_field_call}")
+        "#{handle_field_assign}#{handle_field_call}"
       end
 
       private

data/lib/instruction/handler.rb

@@ -1,27 +1,32 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the AddAndAssign instruction.
     class Handler
-      def initialize(instruction, spacing_scope, function_names, user_defined_types, is_helper)
+      def initialize(instruction, metadata)
         @instruction = instruction
-        @spacing_scope = spacing_scope
-        @function_names = function_names
-        @user_defined_types = user_defined_types
-        @is_helper = is_helper
-      end
+        @metadata = metadata
 
-      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
+        format_assign
       end
 
-      def spacing
-        '    ' * (@is_helper ? 1 : @spacing_scope + 2)
+      def format_assign
+        return unless @instruction.assign&.include?('|||') && @instruction.assign.split('|||').size == 2
+
+        var_name, type_name = @instruction.assign.split('|||')
+
+        @instruction = DTRCore::Instruction.new(
+          @instruction.instruction,
+          @instruction.inputs,
+          "#{var_name}: #{Common::TypeTranslator.translate_type(type_name)}",
+          @instruction.scope,
+          @instruction.id
+        )
       end
 
-      def form_rust_string(instruction_string)
-        "#{spacing}#{instruction_string}"
+      def self.handle(instruction, metadata)
+        new(instruction, metadata).handle
       end
     end
   end

data/lib/instruction/increment.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-module DTRToRust
+module SorobanRustBackend
   module Instruction
     class Increment < Handler
       def handle
-        form_rust_string("increment: #{@instruction.inputs[0]}")
+        # assumes non-range iterator
+        "OPTION_#{@instruction.inputs[0]} = #{@instruction.inputs[1]}.next();"
       end
     end
   end