dtr_to_rust 0.8.0 → 0.12.0

data/lib/optimization/binary_x_to_self_assignment_reduction.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module DTRToRust
-  module Optimization
-    # This class is responsible for reducing binary operations that assign the result to the same variable
-    class BinaryXToSelfAssignmentReduction
-      def initialize(instructions)
-        @instructions = instructions
-        @cur_instruction = nil
-        @optimized_instructions = []
-        @memoize_assigns = {}
-        @to_remove = {}
-        @last_was_eavluate = nil
-      end
-
-      def self.apply(instructions)
-        new(instructions).apply
-      end
-
-      def apply
-        @instructions.each_with_index do |instruction, index|
-          @cur_instruction = instruction
-
-          if skip_instruction?
-            @optimized_instructions << @cur_instruction
-            next unless @cur_instruction.assign && @cur_instruction.assign == @cur_instruction.assign.upcase
-
-            @memoize_assigns[@cur_instruction.assign] = {
-              inputs: @cur_instruction.inputs,
-              index:
-            }
-            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
-
-      private
-
-      def skip_instruction?
-        !%w[add subtract divide multiply].include?(@cur_instruction.instruction)
-      end
-
-      def apply_to_instruction(index)
-        match_on0 = @cur_instruction.inputs[0] == @cur_instruction.assign
-        match_on1 = @cur_instruction.inputs[1] == @cur_instruction.assign
-
-        unless @cur_instruction.inputs.length == 2 &&
-               (match_on1 || match_on0)
-
-          @optimized_instructions << @cur_instruction
-          return
-        end
-
-        optimized_inputs = []
-
-        if @memoize_assigns[@cur_instruction.inputs[0]]
-          optimized_inputs << @memoize_assigns[@cur_instruction.inputs[0]][:inputs]
-          @to_remove[@memoize_assigns[@cur_instruction.inputs[0]][:index]] = true
-        else
-          optimized_inputs << @cur_instruction.inputs[0]
-        end
-
-        if @memoize_assigns[@cur_instruction.inputs[1]]
-          optimized_inputs << @memoize_assigns[@cur_instruction.inputs[1]][:inputs]
-          @to_remove[@memoize_assigns[@cur_instruction.inputs[1]][:index]] = true
-        else
-          optimized_inputs << @cur_instruction.inputs[1]
-        end
-
-        optimized_inputs.flatten!
-        assignment = match_on0 ? optimized_inputs[0] : optimized_inputsinputs[1]
-
-        @optimized_instructions << DTRCore::Instruction.new(@cur_instruction.instruction, optimized_inputs, assignment,
-                                                            @cur_instruction.scope)
-
-        return unless @cur_instruction.assign && @cur_instruction.assign == @cur_instruction.assign.upcase
-
-        @memoize_assigns[@cur_instruction.assign] = {
-          inputs: optimized_inputs,
-          index:
-        }
-      end
-    end
-  end
-end

data/lib/optimization/chained_invocation_assignment_reduction.rb

@@ -1,123 +0,0 @@
-# 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?
-        return unless @cur_instruction.assign && @cur_instruction.assign == @cur_instruction.assign.upcase && !%w[
-          add subtract multiply divide
-        ].include?(@cur_instruction.instruction)
-
-        @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_to_clear = []
-        @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).to_s)
-          @optimized_inputs << input # evaluate_input(key, value)
-          done_a_thing = true
-          @to_remove[value[:index]] = true
-          memoize_assigns_to_clear << key
-          next
-        end
-
-        @optimized_inputs << input unless done_a_thing
-
-        memoize_assigns_to_clear.each do |key|
-          @memoize_assigns.delete(key)
-        end
-      end
-
-      def evaluate_input(_key, input)
-        InstructionHandler.new(DTRCore::Instruction.new('evaluate', input[:inputs], nil, 0), 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/optimization/field_to_assignment_conversion.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module DTRToRust
-  module Optimization
-    # This class is responsible for converting field instructions to assignment instructions
-    class FieldToAssignmentConversion
-      def initialize(instructions)
-        @instructions = instructions
-      end
-
-      def self.apply(instructions)
-        new(instructions).apply
-      end
-
-      def apply
-        @instructions.map do |instruction|
-          next instruction if skip_instruction?(instruction)
-
-          apply_to_instruction(instruction)
-        end
-      end
-
-      private
-
-      def skip_instruction?(instruction)
-        instruction.instruction != 'field'
-      end
-
-      def apply_to_instruction(instruction)
-        return instruction unless instruction.inputs.length == 2
-
-        DTRCore::Instruction.new('assign', ["#{instruction.inputs[0]}.#{instruction.inputs[1]}"], instruction.assign,
-                                 instruction.scope)
-      end
-    end
-  end
-end

data/lib/user_defined_types/handler.rb

@@ -1,89 +0,0 @@
-# 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|
-          if x[:value]
-            "    #{x[:name]} = #{x[:value]},"
-          elsif x[:type] && 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.size == 0 || x[:type] == '()'
-              "    #{x[:name]},"
-            else
-              "    #{x[:name]}(#{inner_types.join(', ')}),"
-            end
-          elsif x[:type] && 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
-end