dtr_to_rust 0.8.1 → 0.12.1

data/lib/user_defined_types_handler.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SorobanRustBackend
+  class UserDefinedTypesHandler
+    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|
+        if x[:value]
+          "    #{x[:name]} = #{x[:value]},"
+        elsif x[:type]&.start_with?('(') && x[:type]&.end_with?(')')
+          inner_types = x[:type].gsub('(', '').gsub(')', '').split(',').map do |x|
+            Common::TypeTranslator.translate_type(x)
+          end
+          if inner_types.empty? || x[:type] == '()'
+            "    #{x[:name]}: (),"
+          else
+            "    #{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])}),"
+        else
+          "    #{x[:name]}: (),"
+        end
+      end.join("\n")
+    end
+
+    def derives
+      base = if error? && enum?
+               "#[contracterror]\n#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]\n"
+             else
+               "#[contracttype]\n#[derive(Clone, Debug, Eq, PartialEq)]\n"
+             end
+
+      base += "#[repr(u32)]\n" if numbered_enum?
+
+      base
+    end
+
+    # TODO: fix this terrible hack
+    def error?
+      @user_defined_type.name.start_with? 'Error'
+    end
+
+    def struct?
+      @user_defined_type.name.end_with? '_STRUCT'
+    end
+
+    def enum?
+      @user_defined_type.name.end_with? '_ENUM'
+    end
+
+    def numbered_enum?
+      enum? && @user_defined_type.attributes.all? { |x| x[:value] }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtr_to_rust
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.12.1
 platform: ruby
 authors:
 - Rob Durst
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-24 00:00:00.000000000 Z
+date: 2024-07-15 00:00:00.000000000 Z
 dependencies: []
 description: Rust to DTR translator (Digicus Textual Representation).
 email:
@@ -17,42 +17,44 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/aggregator/scope_block_aggregator.rb
-- lib/common/input_interpreter.rb
-- lib/common/reference_appender.rb
+- lib/code_generator.rb
 - lib/common/type_translator.rb
-- lib/dtr_to_rust.rb
-- lib/generator.rb
+- lib/contract_handler.rb
+- lib/contract_state/handler.rb
+- lib/function_handler.rb
 - lib/instruction/add.rb
 - lib/instruction/and.rb
 - lib/instruction/assign.rb
+- lib/instruction/binary_instruction.rb
+- lib/instruction/break.rb
 - lib/instruction/divide.rb
 - lib/instruction/end_of_iteration_check.rb
 - lib/instruction/evaluate.rb
 - lib/instruction/exit_with_message.rb
 - lib/instruction/field.rb
-- lib/instruction/goto.rb
 - lib/instruction/handler.rb
 - lib/instruction/increment.rb
 - lib/instruction/instantiate_object.rb
 - lib/instruction/jump.rb
-- lib/instruction/label.rb
 - lib/instruction/multiply.rb
 - lib/instruction/or.rb
 - lib/instruction/print.rb
 - lib/instruction/return.rb
 - lib/instruction/subtract.rb
+- lib/instruction/try_assign.rb
 - lib/instruction_handler.rb
-- lib/optimization/binary_x_to_self_assignment_reduction.rb
-- lib/optimization/chained_invocation_assignment_reduction.rb
-- lib/optimization/field_to_assignment_conversion.rb
-- lib/user_defined_types/handler.rb
+- lib/lcpbt_forrest.rb
+- lib/left_child_preferential_binary_tree.rb
+- lib/non_translatables/handler.rb
+- lib/silviculturist.rb
+- lib/soroban_rust_backend.rb
+- lib/user_defined_types_handler.rb
 homepage: https://spaced-out-thoughts-dev-foundation.github.io/digicus/
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -67,8 +69,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.13
-signing_key:
+rubygems_version: 3.4.10
+signing_key: 
 specification_version: 4
 summary: Rust to DTR translator (Digicus Textual Representation).
 test_files: []

data/lib/aggregator/scope_block_aggregator.rb

@@ -1,72 +0,0 @@
-# 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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module DTRToRust
-  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/reference_appender.rb

@@ -1,59 +0,0 @@
-# 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/dtr_to_rust.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-# This is the main module for the DTR to Rust gem.
-module DTRToRust
-  autoload :Generator, 'generator'
-  autoload :InstructionHandler, 'instruction_handler'
-
-  # This module contains all the classes that handle the different types of instructions.
-  module Instruction
-    autoload :Evaluate, 'instruction/evaluate'
-    autoload :Field, 'instruction/field'
-    autoload :Handler, 'instruction/handler'
-    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

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-require 'dtr_core'
-
-module DTRToRust
-  # Generates Rust code from a DTR contract
-  class Generator
-    def initialize(content)
-      @dtr_contract = ::DTRCore::Contract.from_dtr_raw(content)
-    end
-
-    def generate
-      @content = ''
-
-      generate_user_defined_types
-      generate_state
-      generate_contract_name
-      generate_interface
-      generate_helpers
-
-      generate_contract_header
-
-      @content
-    end
-
-    def self.generate_from_file(file_path)
-      new(File.read(file_path)).generate
-    end
-
-    def self.generate_from_string(dtr_string)
-      new(dtr_string).generate
-    end
-
-    private
-
-    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::{#{used_imports.join(', ')}};\n\n" + @content
-    end
-
-    def generate_contract_name
-      @content += "#[contract]\npub struct #{dtr_contract.name};\n\n"
-    end
-
-    def generate_state
-      return if dtr_contract.state.nil?
-
-      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"
-        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_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|
-        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"
-        if function.output
-          return_string += "        let Thing_to_return: #{Common::TypeTranslator.translate_type(function.output)};\n"
-        end
-        return_string += "#{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?
-
-      "-> #{Common::TypeTranslator.translate_type(function.output)}"
-    end
-
-    def generate_function_args(function)
-      all_inputs = [] + function.inputs
-
-      all_inputs.map { |x| "#{x[:name]}: #{Common::TypeTranslator.translate_type(x[:type_name])}" }.join(', ')
-    end
-
-    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|
-        content = ''
-        content += generate_instruction(instruction, spacing_scope, function_names, is_helper)
-
-        content
-      end.join("\n")
-    end
-
-    def form_rust_string(instruction_string, scope, is_helper)
-      "#{spacing(scope, is_helper)}#{instruction_string}"
-    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 += DTRToRust::UserDefinedTypes::Handler.generate(udt)
-      end
-    end
-  end
-end

data/lib/instruction/label.rb

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