rlsl 0.1.1 → 1.0.1

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

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class Block < Node
+        attr_reader :statements
+
+        visits :visit_block
+
+        def initialize(statements = [])
+          super()
+          @statements = statements
+        end
+      end
+
+      class VarDecl < Node
+        attr_reader :name, :initializer
+        attr_accessor :mutable
+
+        visits :visit_var_decl
+
+        def initialize(name, initializer, type = nil, mutable: false)
+          super()
+          @name = name
+          @initializer = initializer
+          @type = type
+          @mutable = mutable
+        end
+      end
+
+      class VarRef < Node
+        attr_reader :name
+
+        visits :visit_var_ref
+
+        def initialize(name, type = nil)
+          super()
+          @name = name
+          @type = type
+        end
+      end
+
+      class Literal < Node
+        attr_reader :value
+
+        visits :visit_literal
+
+        def initialize(value, type = nil)
+          super()
+          @value = value
+          @type = type || (value.is_a?(Float) ? :float : :int)
+        end
+      end
+
+      class BoolLiteral < Node
+        attr_reader :value
+
+        visits :visit_bool_literal
+
+        def initialize(value)
+          super()
+          @value = value
+          @type = :bool
+        end
+      end
+
+      class BinaryOp < Node
+        attr_reader :operator, :left, :right
+
+        visits :visit_binary_op
+
+        def initialize(operator, left, right, type = nil)
+          super()
+          @operator = operator
+          @left = left
+          @right = right
+          @type = type
+        end
+      end
+
+      class UnaryOp < Node
+        attr_reader :operator, :operand
+
+        visits :visit_unary_op
+
+        def initialize(operator, operand, type = nil)
+          super()
+          @operator = operator
+          @operand = operand
+          @type = type
+        end
+      end
+
+      class FuncCall < Node
+        attr_reader :name, :args, :receiver
+        attr_accessor :expected_arg_types
+
+        visits :visit_func_call
+
+        def initialize(name, args = [], receiver = nil, type = nil)
+          super()
+          @name = name
+          @args = args
+          @receiver = receiver
+          @expected_arg_types = []
+          @type = type
+        end
+      end
+
+      class FieldAccess < Node
+        attr_reader :receiver, :field
+
+        visits :visit_field_access
+
+        def initialize(receiver, field, type = nil)
+          super()
+          @receiver = receiver
+          @field = field
+          @type = type
+        end
+      end
+
+      class Swizzle < Node
+        attr_reader :receiver, :components
+
+        visits :visit_swizzle
+
+        def initialize(receiver, components, type = nil)
+          super()
+          @receiver = receiver
+          @components = components
+          @type = type
+        end
+      end
+
+      class Ternary < Node
+        attr_reader :condition, :then_expr, :else_expr
+
+        visits :visit_ternary
+
+        def initialize(condition, then_expr, else_expr, type = nil)
+          super()
+          @condition = condition
+          @then_expr = then_expr
+          @else_expr = else_expr
+          @type = type
+        end
+      end
+
+      class Constant < Node
+        attr_reader :name
+
+        visits :visit_constant
+
+        def initialize(name, type = :float)
+          super()
+          @name = name
+          @type = type
+        end
+      end
+
+      class Parenthesized < Node
+        attr_reader :expression
+
+        visits :visit_parenthesized
+
+        def initialize(expression)
+          super()
+          @expression = expression
+          @type = expression&.type
+        end
+      end
+
+      class ArrayLiteral < Node
+        attr_reader :elements
+
+        visits :visit_array_literal
+
+        def initialize(elements, type = nil)
+          super()
+          @elements = elements
+          @type = type
+        end
+      end
+
+      class ArrayIndex < Node
+        attr_reader :array, :index
+
+        visits :visit_array_index
+
+        def initialize(array, index, type = nil)
+          super()
+          @array = array
+          @index = index
+          @type = type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class Node
+        attr_accessor :type, :location
+
+        def self.visits(method_name)
+          define_method(:accept) do |visitor|
+            visitor.public_send(method_name, self)
+          end
+        end
+
+        def accept(_visitor)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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,66 @@
+# 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?
+
+          stack = [node]
+          until stack.empty?
+            current = stack.pop
+            yield current
+            stack.concat(child_nodes(current).reverse)
+          end
+        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/mutation_analyzer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "ir/traversal"
+
+module RLSL
+  module Prism
+    class MutationAnalyzer
+      def analyze(node)
+        assigned_names = IR::Traversal.each(node).filter_map do |current|
+          case current
+          when IR::Assignment
+            current.target.name if current.target.is_a?(IR::VarRef)
+          when IR::MultipleAssignment
+            current.targets.select { |target| target.is_a?(IR::VarRef) }.map(&:name)
+          end
+        end.flatten.to_set
+
+        IR::Traversal.each(node) do |current|
+          next unless current.is_a?(IR::VarDecl)
+
+          current.mutable = assigned_names.include?(current.name)
+        end
+
+        node
+      end
+    end
+  end
+end