rlsl 0.1.1 → 1.0.0

data/lib/rlsl/prism/ir/nodes.rb

@@ -1,373 +1,6 @@
 # frozen_string_literal: true
 
-module RLSL
-  module Prism
-    module IR
-      class Node
-        attr_accessor :type
-
-        def accept(visitor)
-          raise NotImplementedError
-        end
-      end
-
-      class Block < Node
-        attr_reader :statements
-
-        def initialize(statements = [])
-          super()
-          @statements = statements
-        end
-
-        def accept(visitor)
-          visitor.visit_block(self)
-        end
-      end
-
-      class VarDecl < Node
-        attr_reader :name, :initializer
-
-        def initialize(name, initializer, type = nil)
-          super()
-          @name = name
-          @initializer = initializer
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_var_decl(self)
-        end
-      end
-
-      class VarRef < Node
-        attr_reader :name
-
-        def initialize(name, type = nil)
-          super()
-          @name = name
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_var_ref(self)
-        end
-      end
-
-      class Literal < Node
-        attr_reader :value
-
-        def initialize(value, type = nil)
-          super()
-          @value = value
-          @type = type || (value.is_a?(Float) ? :float : :int)
-        end
-
-        def accept(visitor)
-          visitor.visit_literal(self)
-        end
-      end
-
-      class BoolLiteral < Node
-        attr_reader :value
-
-        def initialize(value)
-          super()
-          @value = value
-          @type = :bool
-        end
-
-        def accept(visitor)
-          visitor.visit_bool_literal(self)
-        end
-      end
-
-      class BinaryOp < Node
-        attr_reader :operator, :left, :right
-
-        def initialize(operator, left, right, type = nil)
-          super()
-          @operator = operator
-          @left = left
-          @right = right
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_binary_op(self)
-        end
-      end
-
-      class UnaryOp < Node
-        attr_reader :operator, :operand
-
-        def initialize(operator, operand, type = nil)
-          super()
-          @operator = operator
-          @operand = operand
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_unary_op(self)
-        end
-      end
-
-      class FuncCall < Node
-        attr_reader :name, :args, :receiver
-
-        def initialize(name, args = [], receiver = nil, type = nil)
-          super()
-          @name = name
-          @args = args
-          @receiver = receiver
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_func_call(self)
-        end
-      end
-
-      class FieldAccess < Node
-        attr_reader :receiver, :field
-
-        def initialize(receiver, field, type = nil)
-          super()
-          @receiver = receiver
-          @field = field
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_field_access(self)
-        end
-      end
-
-      class Swizzle < Node
-        attr_reader :receiver, :components
-
-        def initialize(receiver, components, type = nil)
-          super()
-          @receiver = receiver
-          @components = components
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_swizzle(self)
-        end
-      end
-
-      class IfStatement < Node
-        attr_reader :condition, :then_branch, :else_branch
-
-        def initialize(condition, then_branch, else_branch = nil, type = nil)
-          super()
-          @condition = condition
-          @then_branch = then_branch
-          @else_branch = else_branch
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_if_statement(self)
-        end
-      end
-
-      class Return < Node
-        attr_reader :expression
-
-        def initialize(expression)
-          super()
-          @expression = expression
-          @type = expression&.type
-        end
-
-        def accept(visitor)
-          visitor.visit_return(self)
-        end
-      end
-
-      class Assignment < Node
-        attr_reader :target, :value
-
-        def initialize(target, value)
-          super()
-          @target = target
-          @value = value
-          @type = value&.type
-        end
-
-        def accept(visitor)
-          visitor.visit_assignment(self)
-        end
-      end
-
-      class ForLoop < Node
-        attr_reader :variable, :range_start, :range_end, :body
-
-        def initialize(variable, range_start, range_end, body)
-          super()
-          @variable = variable
-          @range_start = range_start
-          @range_end = range_end
-          @body = body
-          @type = nil
-        end
-
-        def accept(visitor)
-          visitor.visit_for_loop(self)
-        end
-      end
-
-      class WhileLoop < Node
-        attr_reader :condition, :body
-
-        def initialize(condition, body)
-          super()
-          @condition = condition
-          @body = body
-          @type = nil
-        end
-
-        def accept(visitor)
-          visitor.visit_while_loop(self)
-        end
-      end
-
-      class Break < Node
-        def initialize
-          super()
-          @type = nil
-        end
-
-        def accept(visitor)
-          visitor.visit_break(self)
-        end
-      end
-
-      class Constant < Node
-        attr_reader :name
-
-        def initialize(name, type = :float)
-          super()
-          @name = name
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_constant(self)
-        end
-      end
-
-      class Parenthesized < Node
-        attr_reader :expression
-
-        def initialize(expression)
-          super()
-          @expression = expression
-          @type = expression&.type
-        end
-
-        def accept(visitor)
-          visitor.visit_parenthesized(self)
-        end
-      end
-
-      class ArrayLiteral < Node
-        attr_reader :elements
-
-        def initialize(elements, type = nil)
-          super()
-          @elements = elements
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_array_literal(self)
-        end
-      end
-
-      class ArrayIndex < Node
-        attr_reader :array, :index
-
-        def initialize(array, index, type = nil)
-          super()
-          @array = array
-          @index = index
-          @type = type
-        end
-
-        def accept(visitor)
-          visitor.visit_array_index(self)
-        end
-      end
-
-      class GlobalDecl < Node
-        attr_reader :name, :initializer
-        attr_accessor :is_const, :is_static, :array_size, :element_type
-
-        def initialize(name, initializer, type: nil, is_const: false, is_static: true, array_size: nil, element_type: nil)
-          super()
-          @name = name
-          @initializer = initializer
-          @type = type
-          @is_const = is_const
-          @is_static = is_static
-          @array_size = array_size
-          @element_type = element_type
-        end
-
-        def accept(visitor)
-          visitor.visit_global_decl(self)
-        end
-      end
-
-      class FunctionDefinition < Node
-        attr_reader :name, :params, :body
-        attr_accessor :return_type, :param_types
-
-        def initialize(name, params, body, return_type: nil, param_types: {})
-          super()
-          @name = name
-          @params = params
-          @body = body
-          @return_type = return_type
-          @param_types = param_types
-          @type = return_type
-        end
-
-        def accept(visitor)
-          visitor.visit_function_definition(self)
-        end
-      end
-
-      class MultipleAssignment < Node
-        attr_reader :targets, :value
-
-        def initialize(targets, value)
-          super()
-          @targets = targets
-          @value = value
-          @type = nil
-        end
-
-        def accept(visitor)
-          visitor.visit_multiple_assignment(self)
-        end
-      end
-
-      class TupleType
-        attr_reader :types
-
-        def initialize(*types)
-          @types = types
-        end
-
-        def to_sym
-          :"tuple_#{types.map(&:to_s).join('_')}"
-        end
-      end
-    end
-  end
-end
+require_relative "node"
+require_relative "expressions"
+require_relative "control_flow"
+require_relative "definitions"

data/lib/rlsl/prism/ir/traversal.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      module Traversal
+        module_function
+
+        def each(node, &block)
+          return enum_for(:each, node) unless block_given?
+          return if node.nil?
+
+          yield node
+          child_nodes(node).each { |child| each(child, &block) }
+        end
+
+        def child_nodes(node)
+          case node
+          when Block
+            node.statements
+          when VarDecl
+            [node.initializer]
+          when BinaryOp
+            [node.left, node.right]
+          when UnaryOp
+            [node.operand]
+          when FuncCall
+            [node.receiver, *node.args]
+          when FieldAccess, Swizzle
+            [node.receiver]
+          when IfStatement
+            [node.condition, node.then_branch, node.else_branch]
+          when Ternary
+            [node.condition, node.then_expr, node.else_expr]
+          when Return
+            [node.expression]
+          when Assignment
+            [node.target, node.value]
+          when ForLoop
+            [node.range_start, node.range_end, node.body]
+          when WhileLoop
+            [node.condition, node.body]
+          when Parenthesized
+            [node.expression]
+          when ArrayLiteral
+            node.elements
+          when ArrayIndex
+            [node.array, node.index]
+          when GlobalDecl
+            [node.initializer]
+          when FunctionDefinition
+            [node.body]
+          when MultipleAssignment
+            [*node.targets, node.value]
+          else
+            []
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/source_extractor/block_locator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class SourceExtractor
+      class BlockLocator
+        def extract(source, start_line)
+          extract_unit(source, start_line).to_source
+        end
+
+        def extract_unit(source, start_line)
+          parsed = ::Prism.parse(source)
+          raise SourceNotAvailable, "Unable to parse block source" unless parsed.success?
+
+          block = block_at_line(parsed.value, start_line)
+          raise SourceNotAvailable, "Unable to locate block source" unless block
+
+          SourceUnit.from_block(block)
+        end
+
+        private
+
+        def block_at_line(node, start_line)
+          each_node(node) do |current|
+            next unless current.is_a?(::Prism::BlockNode)
+            return current if current.location.start_line == start_line
+          end
+
+          nil
+        end
+        def each_node(node)
+          return enum_for(:each_node, node) unless block_given?
+          return unless node
+
+          stack = [node]
+
+          until stack.empty?
+            current = stack.pop
+            yield current
+
+            children = if current.respond_to?(:compact_child_nodes)
+                         current.compact_child_nodes
+                       else
+                         Array(current.child_nodes).compact
+                       end
+            stack.concat(children.reverse)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/source_extractor.rb

@@ -1,152 +1,33 @@
 # frozen_string_literal: true
 
+require "prism"
+
+require_relative "source_unit"
+require_relative "source_extractor/block_locator"
+
 module RLSL
   module Prism
     class SourceExtractor
       class SourceNotAvailable < StandardError; end
 
+      def initialize(block_locator = BlockLocator.new)
+        @block_locator = block_locator
+      end
+
       def extract(block)
+        extract_unit(block).to_source
+      end
+
+      def extract_unit(block)
         file, line_num = block.source_location
         raise SourceNotAvailable, "Block source location not available" unless file && File.exist?(file)
 
-        lines = File.readlines(file)
-        extract_block_source(lines, line_num - 1)
+        @block_locator.extract_unit(File.read(file), line_num)
       end
 
       def extract_from_string(source)
         source
       end
-
-      private
-
-      def extract_block_source(lines, start_line)
-        source = +""
-        depth = 0
-        in_block = false
-        block_start_found = false
-
-        lines[start_line..].each_with_index do |line, idx|
-          tokens = tokenize_for_blocks(line)
-
-          tokens.each do |token|
-            case token
-            when :do, :brace_open
-              if !block_start_found
-                block_start_found = true
-                in_block = true
-              end
-              depth += 1
-            when :block_start
-              depth += 1
-            when :end, :brace_close
-              depth -= 1
-            end
-          end
-
-          if block_start_found
-            if idx == 0
-              source << extract_first_line(line)
-            else
-              source << line
-            end
-          end
-
-          break if in_block && depth == 0
-        end
-
-        clean_block_source(source)
-      end
-
-      def tokenize_for_blocks(line)
-        tokens = []
-        in_string = nil
-        i = 0
-
-        while i < line.length
-          char = line[i]
-
-          if in_string
-            if char == in_string && (i == 0 || line[i - 1] != "\\")
-              in_string = nil
-            end
-            i += 1
-            next
-          end
-
-          if char == '"' || char == "'"
-            in_string = char
-            i += 1
-            next
-          end
-
-          break if char == "#"
-
-          prev_is_boundary = i == 0 || !line[i - 1].match?(/[a-zA-Z0-9_]/)
-
-          if char == "{"
-            tokens << :brace_open
-          elsif char == "}"
-            tokens << :brace_close
-          elsif prev_is_boundary && line[i..].match?(/\Ado\b/)
-            tokens << :do
-            i += 1
-          elsif prev_is_boundary && line[i..].match?(/\Aelsif\b/)
-            i += 4
-          elsif prev_is_boundary && line[i..].match?(/\Aelse\b/)
-            i += 3
-          elsif prev_is_boundary && (m = line[i..].match(/\A(if|unless|while|for|case|def|class|module)\b/))
-            tokens << :block_start
-            i += m[1].length - 1
-          elsif prev_is_boundary && line[i..].match?(/\Aend\b/)
-            tokens << :end
-            i += 2
-          end
-
-          i += 1
-        end
-
-        tokens
-      end
-
-      def extract_first_line(line)
-        if line.include?(" do")
-          match = line.match(/do\s*(\|[^|]*\|)?\s*(.*)$/)
-          if match
-            params = match[1] || ""
-            rest = match[2] || ""
-            "#{params}\n#{rest}\n"
-          else
-            "\n"
-          end
-        elsif line.include?("{")
-          match = line.match(/\{\s*(\|[^|]*\|)?\s*(.*)$/)
-          if match
-            params = match[1] || ""
-            rest = match[2] || ""
-            "#{params}\n#{rest}\n"
-          else
-            "\n"
-          end
-        else
-          line
-        end
-      end
-
-      def clean_block_source(source)
-        lines = source.lines
-        return "" if lines.empty?
-
-        last_line = lines.last.strip
-        if last_line == "end" || last_line == "}"
-          lines.pop
-        elsif last_line.end_with?("end") || last_line.end_with?("}")
-          lines[-1] = lines[-1].sub(/\s*(end|\})\s*$/, "\n")
-        end
-
-        lines.shift if lines.first&.strip&.empty?
-
-        lines.join
-      end
     end
   end
 end