dtr_to_rust 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0c45750a14c1fb946e49b0c0e5b084db7ed6189db1f93e7268ebc5100927831
-  data.tar.gz: 1ad7efddb1fbc6002cd24e67d73b8653512515e31f78b88b8492d5aa7e1b109c
+  metadata.gz: 159dd48a238334709063b4cf8412eb41ac4d2365b1ba19a1e44a769db1105852
+  data.tar.gz: ebea69c27f3325cbe6886fbe9f03e3926ef89f3c4a79b796dc78e3e1b6f54fc8
 SHA512:
-  metadata.gz: cceae4b47a0a759fe9ab25b820f8e77bd687550a9c0e0ab6259c251f5484069f9804c12f25cc654c6048498f502a317e3835f20a912f5deba1d9f9f09d86bd15
-  data.tar.gz: ccc003beca43b656890b4360da90eee866b87aa3711448a9f20b3613c2f86df6e179eb4ec9364645bcfaf82fcba61da2b8fa8d1da70d24868c70d9f849f23254
+  metadata.gz: 80b1596a4070c89e64b3f52f95557cb7cd41b5d75e999b83952ee30bb35c439fe216e90742f1ac31604252453f0e051ba66a747d5cafc4974bee39f061c7a980
+  data.tar.gz: e00c32786d303609e6846b0314557f3fefc55bf149ea52830908649135ed10da88051798b62b8f0d6ede80c7d69a1ee59ee27435898d17ae47d8deabf8358f22

data/lib/code_generator.rb

@@ -1,8 +1,10 @@
 module SorobanRustBackend
   class CodeGenerator
-    def initialize(instructions, base_indentation: 0)
+    def initialize(instructions, base_indentation: 0, user_defined_types: [], function_names: [])
       @instructions = instructions
       @base_indentation = base_indentation
+      @user_defined_types = user_defined_types
+      @function_names = function_names
 
       silviculturist = SorobanRustBackend::Silviculturist.new(instructions, base_indentation:)
       silviculturist.make_forrest
@@ -22,6 +24,11 @@ module SorobanRustBackend
         indentation = og_instruction.instruction == 'goto' ? y[2][:return_scope] + @base_indentation : y[1]
 
         return_string << "#{'    ' * indentation}#{InstructionHandler.new(instruction, y[2]).generate_rust}\n"
+
+        if instruction.instruction == 'exit_with_message' && instruction.scope != 0
+          jump_back_indent = indentation - 1
+          return_string << "#{'    ' * jump_back_indent}}\n"
+        end
       end
 
       return_string
@@ -54,8 +61,8 @@ module SorobanRustBackend
           instruction.id
         )
       elsif while_loop?(instruction, metadata)
-        operator_variable = "#{metadata[:end_of_iteration_check][:lhs]}"
-        iterator_variable = "#{metadata[:end_of_iteration_check][:rhs]}"
+        operator_variable = (metadata[:end_of_iteration_check][:lhs]).to_s
+        iterator_variable = (metadata[:end_of_iteration_check][:rhs]).to_s
 
         DTRCore::Instruction.new(
           'jump',
@@ -64,11 +71,58 @@ module SorobanRustBackend
           instruction.scope,
           instruction.id
         )
+      elsif udt?(instruction)
+        inputs = instruction.inputs
+        udt_found = nil
+
+        @user_defined_types.each do |udt|
+          fixed_udt_name = udt_name_fix(udt)
+
+          next unless fixed_udt_name == inputs[1] || (fixed_udt_name == inputs[2] && inputs[0] == '&')
+
+          udt_found = if inputs.last.instance_of?(DTRCore::UserDefinedType)
+                        inputs.last
+                      else
+
+                        inputs.push(udt)
+                      end
+          break
+        end
+
+        raise "Unable to instantiate unrecognized UDT: #{inputs[1]}" if udt_found.nil?
+
+        DTRCore::Instruction.new(
+          'instantiate_object',
+          inputs,
+          instruction.assign,
+          instruction.scope,
+          instruction.id
+        )
+      elsif instruction.instruction == 'evaluate'
+        method_name = instruction.inputs[0]
+
+        method_name = "Self::#{method_name}" if @function_names.include?(method_name)
+
+        DTRCore::Instruction.new(
+          'evaluate',
+          [method_name] + instruction.inputs[1..],
+          instruction.assign,
+          instruction.scope,
+          instruction.id
+        )
       else
         instruction
       end
     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 match_statement?(instruction, metadata)
       metadata[:last_node_was_conditional_jump] && instruction.instruction == 'jump' && metadata[:parent_scope] && metadata[:parent_scope] == instruction.scope
     end
@@ -86,5 +140,9 @@ module SorobanRustBackend
         metadata[:end_of_iteration_check][:assign] == instruction.inputs[0] &&
         metadata[:parent_scope] == instruction.scope
     end
+
+    def udt?(instruction)
+      instruction.instruction == 'instantiate_object' && (instruction.inputs[0] == 'UDT' || (instruction.inputs[0] == '&' && instruction.inputs[1] == 'UDT'))
+    end
   end
 end

data/lib/common/input_interpreter.rb

@@ -0,0 +1,72 @@
+module SorobanRustBackend
+  module Common
+    # This class is responsible for interpreting the input string.
+    class InputInterpreter
+      def initialize(input)
+        @input = input
+      end
+
+      def self.interpret(input)
+        new(input).interpret
+      end
+
+      def interpret
+        if number?(@input)
+          number_return(@input)
+        elsif string?(@input)
+          string_return(@input)
+        elsif boolean?(@input)
+          boolean_return(@input)
+        else
+          variable_return(@input)
+        end
+      end
+
+      private
+
+      ## Variable ##
+      def variable?(input)
+        !string?(input) && !number?(input)
+      end
+
+      def variable_return(_input)
+        { value: @input, type: 'variable', needs_reference: !@input.start_with?('&') }
+      end
+
+      ## String ##
+      def string?(input)
+        input.is_a?(String) && (input.match?(/".*"/) || input.match?(/'.*'/))
+      end
+
+      def string_return(_input)
+        { value: @input, type: 'string', needs_reference: false }
+      end
+
+      ## Number ##
+      def number?(input)
+        input.is_a?(Numeric) || input&.match?(/^\s*\d+\.?\d*\s*$/)
+      end
+
+      def number_return(_input)
+        { value: contains_decimal?(@input.to_s) ? @input.to_f : @input.to_i, type: 'number', needs_reference: false }
+      end
+
+      def contains_decimal?(str)
+        # Define a regular expression pattern for a decimal number
+        decimal_pattern = /\d+\.\d+/
+
+        # 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/type_translator.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Common
     # TypeTranslator translates DTR types to Rust types

data/lib/contract_handler.rb

@@ -21,10 +21,8 @@ module SorobanRustBackend
 
       @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
+      dtr_contract.user_defined_types&.each do |user_defined_type|
+        @content += SorobanRustBackend::UserDefinedTypesHandler.generate(user_defined_type)
       end
       @content += ContractState::Handler.generate(dtr_contract.state) if dtr_contract.state
       generate_contract_name
@@ -46,10 +44,9 @@ module SorobanRustBackend
     end
 
     def generate_functions_each(functions, is_helper)
-      # function_names = functions&.map(&:name)
-
+      function_names = functions.map(&:name)
       functions&.map do |function|
-        FunctionHandler.generate(function, is_helper)
+        FunctionHandler.generate(function, is_helper, dtr_contract.user_defined_types, function_names)
       end&.join("\n")
     end
 

data/lib/contract_state/handler.rb

@@ -21,8 +21,9 @@ module SorobanRustBackend
         @state.each do |state_value|
           if state_value.type == 'Symbol'
             content += "const #{state_value.name}: Symbol = symbol_short!(#{state_value.initial_value});\n"
+          # TODO: This is a hack. We need to find a better way to handle this and prove its correctness.
           elsif state_value.type == 'String'
-            content += "const #{state_value.name}: String = String::from_str(#{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

data/lib/function_handler.rb

@@ -1,27 +1,27 @@
 module SorobanRustBackend
   class FunctionHandler
-    def initialize(function, is_helper)
+    def initialize(function, is_helper, user_defined_types, function_names)
       @function = function
       @is_helper = is_helper
+      @user_defined_types = user_defined_types
+      @function_names = function_names
     end
 
-    def self.generate(function, is_helper)
-      new(function, is_helper).generate
+    def self.generate(function, is_helper, user_defined_types, function_names)
+      new(function, is_helper, user_defined_types, function_names).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"
+        content += "#{@is_helper ? '    ' : '        '}let mut Thing_to_return: #{Common::TypeTranslator.translate_type(@function.output)};\n"
       end
       content += generate_instructions_for_blocks(@function.instructions)
 
-      content += "\n#{@is_helper ? '' : '    '}}\n"
+      content += "#{@is_helper ? '' : '    '}}\n"
 
       content
     end
@@ -41,7 +41,8 @@ module SorobanRustBackend
     end
 
     def generate_instructions_for_blocks(instructions)
-      CodeGenerator.new(instructions, base_indentation: @is_helper ? 1 : 2).generate
+      CodeGenerator.new(instructions, base_indentation: @is_helper ? 1 : 2,
+                                      user_defined_types: @user_defined_types, function_names: @function_names).generate
     end
   end
 end

data/lib/instruction/add.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.

data/lib/instruction/and.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the and instruction.

data/lib/instruction/assign.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the assign instruction.

data/lib/instruction/binary_instruction.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.
@@ -11,7 +9,7 @@ module SorobanRustBackend
       end
 
       def handle
-        if @metadata[:symbol_table].include?(@instruction.assign) || @instruction.assign.include?('.')
+        if @metadata[:symbol_table].include?(@instruction.assign) || @instruction.assign.include?('.') || @instruction.assign == 'Thing_to_return'
           "#{@instruction.assign} = #{@instruction.inputs[0]} #{@operation} #{@instruction.inputs[1]};"
         else
           "let mut #{@instruction.assign} = #{@instruction.inputs[0]} #{@operation} #{@instruction.inputs[1]};"

data/lib/instruction/break.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.

data/lib/instruction/divide.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.
-    class Divide < Handler
+    class Divide < BinaryInstruction
       def initialize(instruction, metadata)
         super('/', instruction, metadata)
       end

data/lib/instruction/end_of_iteration_check.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     class EndOfIterationCheck < Handler

data/lib/instruction/evaluate.rb

@@ -1,10 +1,34 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the Evaluate instruction.
     class Evaluate < Handler
       def handle
+        @ref_preface = false
+
+        if @instruction.inputs[0] == '&'
+          @ref_preface = true
+          @instruction.inputs.shift
+        end
+
+        adjusted_inputs = []
+        last_was_ref = false
+        @instruction.inputs.each do |input|
+          if input == '&'
+            last_was_ref = true
+          else
+            adjusted_inputs << (last_was_ref ? "&#{input}" : input)
+            last_was_ref = false
+          end
+        end
+
+        @instruction = DTRCore::Instruction.new(
+          @instruction.instruction,
+          adjusted_inputs,
+          @instruction.assign,
+          @instruction.scope,
+          @instruction.id
+        )
+
         handle_keyword_method_invocation
       end
 
@@ -44,8 +68,8 @@ module SorobanRustBackend
 
         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?)});"
+        body_rust = "#{@ref_preface ? '&' : ''}#{invocation_name(evaluated_method_name)}(#{inputs_to_rust_string(inputs,
+                                                                                                                 append_ref_to_num?, try_append_ref_to_var?)});"
         "#{if assignment.nil?
              ''
            else

data/lib/instruction/exit_with_message.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the exit_with_message instruction.

data/lib/instruction/field.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the Field instruction.

data/lib/instruction/handler.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the AddAndAssign instruction.

data/lib/instruction/increment.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     class Increment < Handler

data/lib/instruction/instantiate_object.rb

@@ -1,19 +1,32 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the LogString instruction.
     class InstantiateObject < Handler
       def handle
+        @ref_preface = false
+        if @instruction.inputs[0] == '&'
+          @ref_preface = true
+          @instruction.inputs.shift
+        end
+
         case @instruction.inputs[0]
         when 'List'
           handle_list
         when 'UDT'
           handle_udt
+
         when 'Tuple'
-          "let mut #{@instruction.assign} = (#{normalish_inputs});"
+          if @instruction.assign.include?('.') || @instruction.assign == 'Thing_to_return'
+            "#{@instruction.assign} = #{@ref_preface ? '&' : ''}(#{normalish_inputs});"
+          else
+            "let mut #{@instruction.assign} = #{@ref_preface ? '&' : ''}(#{normalish_inputs});"
+          end
         when 'Range'
-          "let mut #{@instruction.assign} = #{range_inputs};"
+          if @instruction.assign.include?('.') || @instruction.assign == 'Thing_to_return'
+            "#{@instruction.assign} = #{@ref_preface ? '&' : ''}#{range_inputs};"
+          else
+            "let mut #{@instruction.assign} = #{@ref_preface ? '&' : ''}#{range_inputs};"
+          end
         else
           raise "Unknown object type: #{@instruction.inputs[0]}"
         end
@@ -22,7 +35,11 @@ module SorobanRustBackend
       private
 
       def handle_list
-        "let mut #{@instruction.assign} = vec![#{normalish_inputs}];"
+        if @instruction.assign.include?('.') || @instruction.assign == 'Thing_to_return'
+          "#{@instruction.assign} = #{@ref_preface ? '&' : ''}vec![#{normalish_inputs}];"
+        else
+          "let mut #{@instruction.assign} = #{@ref_preface ? '&' : ''}vec![#{normalish_inputs}];"
+        end
       end
 
       def range_inputs
@@ -46,18 +63,16 @@ module SorobanRustBackend
       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_}")
-
-        "let mut #{@instruction.assign} = #{@instruction.inputs[1]}{#{inputs_to_rust_string(@instruction.inputs[2..],
-                                                                                            @instruction.inputs[1])}}"
-
-        # raise 'Not implemented'
+        udt_found = @instruction.inputs[@instruction.inputs.size - 1]
+
+        inputs_sans_udt = @instruction.inputs[..-2][2..]
+        assignment = "let mut #{@instruction.assign} = "
+        udt = "#{@ref_preface ? '&' : ''}#{@instruction.inputs[1]}{"
+        inputs = inputs_to_rust_string(inputs_sans_udt, udt_found.attributes.map do |x|
+                                                          x[:name]
+                                                        end)
+        end_ = '};'
+        "#{assignment}#{udt}#{inputs}#{end_}"
       end
 
       def inputs_to_rust_string(inputs, udt_type_names)
@@ -70,16 +85,15 @@ module SorobanRustBackend
       end
 
       def foobar(input)
-        input
-        # decorated_input = Common::InputInterpreter.interpret(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
+        if decorated_input[:type] == 'string'
+          "String::from_str(&env, #{input})"
+        elsif decorated_input[:needs_reference] && input == 'env'
+          "&#{input}"
+        else
+          input
+        end
       end
 
       def handle_input(input, udt_type_name)

data/lib/instruction/jump.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the jump instruction.
@@ -17,7 +15,7 @@ module SorobanRustBackend
         elsif @instruction.inputs.size == 4 && last_instruction_is_while_loop
           handle_while_loop
         else
-          raise 'Invalid jump instruction. Received too many inputs: ' + @instruction.inputs.size.to_s
+          raise "Invalid jump instruction. Received too many inputs: #{@instruction.inputs.size}"
         end
       end
 

data/lib/instruction/multiply.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.
-    class Multiply < Handler
+    class Multiply < BinaryInstruction
       def initialize(instruction, metadata)
         super('&', instruction, metadata)
       end

data/lib/instruction/or.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the or instruction.

data/lib/instruction/print.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the LogString instruction.

data/lib/instruction/return.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class is responsible for generating Rust code for the Return instruction.

data/lib/instruction/subtract.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the add instruction.
-    class Subtract < Handler
+    class Subtract < BinaryInstruction
       def initialize(instruction, metadata)
         super('-', instruction, metadata)
       end

data/lib/instruction/try_assign.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   module Instruction
     # This class handles the goto instruction.

data/lib/instruction_handler.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   # This class is responsible for generating Rust code for a single instruction.
   class InstructionHandler

data/lib/lcpbt_forrest.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   class LCPBT_Forrest
     attr_accessor :trees
@@ -54,30 +52,5 @@ module SorobanRustBackend
     def all_paths_to(instruction_id)
       @trees.map { |x| x.all_paths_to(instruction_id) }.flatten(1).compact
     end
-
-    def walk_it
-      @trees.each do |x|
-        puts "Walking tree #{x.tree_id}"
-
-        stack = []
-        symbol_table = {}
-
-        stack << x
-
-        while stack.any?
-          current = stack.pop
-
-          if current.value.assign
-            symbol_table[current.value.assign] = {
-              value: current.value.id
-            }
-          end
-
-          stack << current.left_child if current.left_child
-
-          stack << current.right_child if current.right_child
-        end
-      end
-    end
   end
 end

data/lib/left_child_preferential_binary_tree.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'securerandom'
 
 module SorobanRustBackend

data/lib/silviculturist.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   class Silviculturist
     attr_accessor :forrest
@@ -127,9 +125,14 @@ module SorobanRustBackend
 
         return plant_trees(scope, rest_of_instructions, from_id: cur_instruction.id, indentation:, metadata:)
       else
-        last_symbol_table = metadata[:symbol_table]
-        last_symbol_table[cur_instruction.assign] = {} unless last_symbol_table.include?(cur_instruction.assign)
-        last_symbol_table[cur_instruction.assign][cur_instruction.scope] = cur_instruction
+        last_symbol_table = metadata[:symbol_table].clone
+
+        if cur_instruction.assign
+          assignment = cur_instruction.assign
+          assignment = assignment.split('|||').first if assignment.include?('|||')
+          last_symbol_table[assignment] = {} unless last_symbol_table.include?(assignment)
+          last_symbol_table[assignment][cur_instruction.scope] = cur_instruction
+        end
 
         metadata = {
           last_node_was_conditional_jump: false,

data/lib/soroban_rust_backend.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # This is the main module for the DTR to Rust gem.
 module SorobanRustBackend
   autoload :LCPBT_Forrest, 'lcpbt_forrest'
@@ -39,6 +37,7 @@ module SorobanRustBackend
 
   module Common
     autoload :TypeTranslator, './lib/common/type_translator'
+    autoload :InputInterpreter, './lib/common/input_interpreter'
   end
 
   module NonTranslatables

data/lib/user_defined_types_handler.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module SorobanRustBackend
   class UserDefinedTypesHandler
     def initialize(user_defined_type)
@@ -41,16 +39,16 @@ module SorobanRustBackend
             Common::TypeTranslator.translate_type(x)
           end
           if inner_types.empty? || x[:type] == '()'
-            "    #{x[:name]}: (),"
+            "    #{x[:name]},"
           else
-            "    #{x[:name]}: (#{inner_types.join(', ')}),"
+            "    #{x[:name]}(#{inner_types.join(', ')}),"
           end
         elsif x[:type]&.match(/\d+/)
           "    #{x[:name]} = #{x[:type]},"
         elsif x[:type] && x[:type] != '()'
-          "    #{x[:name]}: (#{Common::TypeTranslator.translate_type(x[:type])}),"
+          "    #{x[:name]}(#{Common::TypeTranslator.translate_type(x[:type])}),"
         else
-          "    #{x[:name]}: (),"
+          "    #{x[:name]},"
         end
       end.join("\n")
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtr_to_rust
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Rob Durst
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-15 00:00:00.000000000 Z
+date: 2024-07-16 00:00:00.000000000 Z
 dependencies: []
 description: Rust to DTR translator (Digicus Textual Representation).
 email:
@@ -18,6 +18,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/code_generator.rb
+- lib/common/input_interpreter.rb
 - lib/common/type_translator.rb
 - lib/contract_handler.rb
 - lib/contract_state/handler.rb