rlsl 0.1.1 → 1.0.1

data/lib/rlsl/prism/builtins/operator_rules.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Builtins
+      module OperatorRules
+        BINARY_OPERATORS = {
+          "+" => :arithmetic,
+          "-" => :arithmetic,
+          "*" => :arithmetic,
+          "/" => :arithmetic,
+          "%" => :arithmetic,
+
+          "==" => :comparison,
+          "!=" => :comparison,
+          "<" => :comparison,
+          ">" => :comparison,
+          "<=" => :comparison,
+          ">=" => :comparison,
+
+          "&&" => :logical,
+          "||" => :logical
+        }.freeze
+
+        UNARY_OPERATORS = {
+          "-" => :negate,
+          "!" => :not
+        }.freeze
+
+        module_function
+
+        def binary_operator?(op)
+          BINARY_OPERATORS.key?(op.to_s)
+        end
+
+        def unary_operator?(op)
+          UNARY_OPERATORS.key?(op.to_s)
+        end
+
+        def binary_op_result_type(op, left_type, right_type)
+          op_kind = BINARY_OPERATORS[op.to_s]
+          validate_operand_shapes!(op, left_type, right_type)
+
+          case op_kind
+          when :comparison, :logical
+            :bool
+          when :arithmetic
+            if matrix_type?(left_type) && vector_type?(right_type)
+              matrix_vector_result(left_type)
+            elsif vector_type?(left_type) && matrix_type?(right_type)
+              matrix_vector_result(right_type)
+            elsif matrix_type?(left_type) && matrix_type?(right_type)
+              left_type
+            elsif matrix_type?(left_type) && scalar_type?(right_type)
+              left_type
+            elsif scalar_type?(left_type) && matrix_type?(right_type)
+              right_type
+            elsif vector_type?(left_type) && vector_type?(right_type)
+              left_type
+            elsif vector_type?(left_type) && scalar_type?(right_type)
+              left_type
+            elsif scalar_type?(left_type) && vector_type?(right_type)
+              right_type
+            else
+              scalar_arithmetic_result_type(op, left_type, right_type)
+            end
+          end
+        end
+
+        def vector_type?(type)
+          %i[vec2 vec3 vec4].include?(type)
+        end
+
+        def matrix_type?(type)
+          %i[mat2 mat3 mat4].include?(type)
+        end
+
+        def scalar_type?(type)
+          %i[float int].include?(type)
+        end
+
+        def common_type(types)
+          types = Array(types).compact.uniq
+          return types.first if types.length == 1
+          return :float if types.sort == %i[float int]
+
+          nil
+        end
+
+        def scalar_arithmetic_result_type(op, left_type, right_type)
+          return :float unless scalar_type?(left_type) && scalar_type?(right_type)
+          return :float if op.to_s == "/"
+          return :int if left_type == :int && right_type == :int
+
+          :float
+        end
+
+        def matrix_vector_result(matrix_type)
+          case matrix_type
+          when :mat2 then :vec2
+          when :mat3 then :vec3
+          when :mat4 then :vec4
+          end
+        end
+
+        def validate_operand_shapes!(op, left_type, right_type)
+          if vector_type?(left_type) && vector_type?(right_type) && left_type != right_type
+            raise SignatureError, "Vector size mismatch for #{op}: #{left_type} and #{right_type}"
+          end
+
+          if matrix_type?(left_type) && vector_type?(right_type) && matrix_vector_result(left_type) != right_type
+            raise SignatureError, "Matrix/vector size mismatch for #{op}: #{left_type} and #{right_type}"
+          end
+
+          return unless vector_type?(left_type) && matrix_type?(right_type)
+          return if left_type == matrix_vector_result(right_type)
+
+          raise SignatureError, "Vector/matrix size mismatch for #{op}: #{left_type} and #{right_type}"
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/builtins/swizzle_rules.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Builtins
+      module SwizzleRules
+        SWIZZLE_COMPONENTS = {
+          "x" => 0, "r" => 0, "s" => 0,
+          "y" => 1, "g" => 1, "t" => 1,
+          "z" => 2, "b" => 2, "p" => 2,
+          "w" => 3, "a" => 3, "q" => 3
+        }.freeze
+
+        SINGLE_COMPONENT_FIELDS = %w[x y z w r g b a s t p q].freeze
+        SWIZZLE_PATTERNS = /\A(?:[xyzw]{2,4}|[rgba]{2,4}|[stpq]{2,4})\z/
+
+        module_function
+
+        def single_component_field?(name)
+          SINGLE_COMPONENT_FIELDS.include?(name.to_s)
+        end
+
+        def swizzle?(name)
+          name.to_s.match?(SWIZZLE_PATTERNS)
+        end
+
+        def swizzle_type(components)
+          case components.length
+          when 2 then :vec2
+          when 3 then :vec3
+          when 4 then :vec4
+          else :float
+          end
+        end
+
+        def valid_for_type?(components, receiver_type)
+          vector_size = { vec2: 2, vec3: 3, vec4: 4 }[receiver_type]
+          return false unless vector_size
+
+          components.to_s.each_char.all? do |component|
+            SWIZZLE_COMPONENTS.fetch(component) < vector_size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/builtins.rb

@@ -1,195 +1,86 @@
 # frozen_string_literal: true
 
+require_relative "builtins/function_registry"
+require_relative "builtins/operator_rules"
+require_relative "builtins/swizzle_rules"
+
 module RLSL
   module Prism
     module Builtins
-      FUNCTIONS = {
-        vec2: { args: %i[any any], returns: :vec2, variadic: true, min_args: 1 },
-        vec3: { args: %i[any any any], returns: :vec3, variadic: true, min_args: 1 },
-        vec4: { args: %i[any any any any], returns: :vec4, variadic: true, min_args: 1 },
-
-        mat2: { args: %i[any any any any], returns: :mat2, variadic: true, min_args: 1 },
-        mat3: { args: %i[any any any any any any any any any], returns: :mat3, variadic: true, min_args: 1 },
-        mat4: { args: %i[any any any any any any any any any any any any any any any any], returns: :mat4, variadic: true, min_args: 1 },
-
-        sin: { args: [:float], returns: :float },
-        cos: { args: [:float], returns: :float },
-        tan: { args: [:float], returns: :float },
-        asin: { args: [:float], returns: :float },
-        acos: { args: [:float], returns: :float },
-        atan: { args: %i[float float], returns: :float, variadic: true, min_args: 1 },
-        atan2: { args: %i[float float], returns: :float },
-
-        pow: { args: %i[float float], returns: :float },
-        exp: { args: [:float], returns: :float },
-        log: { args: [:float], returns: :float },
-        sqrt: { args: [:any], returns: :same },
-
-        abs: { args: [:any], returns: :same },
-        sign: { args: [:any], returns: :same },
-        floor: { args: [:any], returns: :same },
-        ceil: { args: [:any], returns: :same },
-        fract: { args: [:any], returns: :same },
-        mod: { args: %i[any float], returns: :first },
-        min: { args: %i[any any], returns: :first },
-        max: { args: %i[any any], returns: :first },
-        clamp: { args: %i[any any any], returns: :first },
-        mix: { args: %i[any any float], returns: :first },
-        step: { args: %i[float any], returns: :second },
-        smoothstep: { args: %i[float float any], returns: :third },
-
-        length: { args: [:any], returns: :float },
-        distance: { args: %i[any any], returns: :float },
-        dot: { args: %i[any any], returns: :float },
-        cross: { args: %i[vec3 vec3], returns: :vec3 },
-        normalize: { args: [:any], returns: :same },
-        reflect: { args: %i[any any], returns: :first },
-        refract: { args: %i[any any float], returns: :first },
-
-        hash21: { args: [:vec2], returns: :float },
-        hash22: { args: [:vec2], returns: :vec2 },
-
-        lessThan: { args: %i[any any], returns: :bool },
-        lessThanEqual: { args: %i[any any], returns: :bool },
-        greaterThan: { args: %i[any any], returns: :bool },
-        greaterThanEqual: { args: %i[any any], returns: :bool },
-        equal: { args: %i[any any], returns: :bool },
-        notEqual: { args: %i[any any], returns: :bool },
-
-        inverse: { args: [:any], returns: :same },
-        transpose: { args: [:any], returns: :same },
-        determinant: { args: [:any], returns: :float },
-
-        texture2D: { args: %i[sampler2D vec2], returns: :vec4 },
-        texture: { args: %i[sampler2D vec2], returns: :vec4 },
-        textureLod: { args: %i[sampler2D vec2 float], returns: :vec4 }
-      }.freeze
-
-      BINARY_OPERATORS = {
-        "+" => :arithmetic,
-        "-" => :arithmetic,
-        "*" => :arithmetic,
-        "/" => :arithmetic,
-        "%" => :arithmetic,
-
-        "==" => :comparison,
-        "!=" => :comparison,
-        "<" => :comparison,
-        ">" => :comparison,
-        "<=" => :comparison,
-        ">=" => :comparison,
-
-        "&&" => :logical,
-        "||" => :logical
-      }.freeze
-
-      UNARY_OPERATORS = {
-        "-" => :negate,
-        "!" => :not
-      }.freeze
-
-      SWIZZLE_COMPONENTS = {
-        "x" => 0, "r" => 0, "s" => 0,
-        "y" => 1, "g" => 1, "t" => 1,
-        "z" => 2, "b" => 2, "p" => 2,
-        "w" => 3, "a" => 3, "q" => 3
-      }.freeze
-
-      SINGLE_COMPONENT_FIELDS = %w[x y z w r g b a s t p q].freeze
-
-      SWIZZLE_PATTERNS = /\A[xyzwrgba]{2,4}\z/
+      FUNCTIONS = FunctionRegistry::FUNCTIONS
+      BINARY_OPERATORS = OperatorRules::BINARY_OPERATORS
+      UNARY_OPERATORS = OperatorRules::UNARY_OPERATORS
+      SWIZZLE_COMPONENTS = SwizzleRules::SWIZZLE_COMPONENTS
+      SINGLE_COMPONENT_FIELDS = SwizzleRules::SINGLE_COMPONENT_FIELDS
+      SWIZZLE_PATTERNS = SwizzleRules::SWIZZLE_PATTERNS
 
       class << self
         def function?(name)
-          FUNCTIONS.key?(name.to_sym)
+          FunctionRegistry.function?(name)
         end
 
         def function_signature(name)
-          FUNCTIONS[name.to_sym]
+          FunctionRegistry.function_signature(name)
+        end
+
+        def supported_on_target?(name, target)
+          FunctionRegistry.supported_on_target?(name, target)
+        end
+
+        def explicit_types(name)
+          FunctionRegistry.explicit_types(name)
         end
 
         def binary_operator?(op)
-          BINARY_OPERATORS.key?(op.to_s)
+          OperatorRules.binary_operator?(op)
         end
 
         def unary_operator?(op)
-          UNARY_OPERATORS.key?(op.to_s)
+          OperatorRules.unary_operator?(op)
         end
 
         def single_component_field?(name)
-          SINGLE_COMPONENT_FIELDS.include?(name.to_s)
+          SwizzleRules.single_component_field?(name)
         end
 
         def swizzle?(name)
-          name.to_s.match?(SWIZZLE_PATTERNS)
+          SwizzleRules.swizzle?(name)
         end
 
         def swizzle_type(components)
-          case components.length
-          when 2 then :vec2
-          when 3 then :vec3
-          when 4 then :vec4
-          else :float
-          end
+          SwizzleRules.swizzle_type(components)
+        end
+
+        def valid_swizzle_for_type?(components, receiver_type)
+          SwizzleRules.valid_for_type?(components, receiver_type)
         end
 
         def resolve_return_type(rule, arg_types)
-          case rule
-          when :same then arg_types.first
-          when :first then arg_types.first
-          when :second then arg_types[1]
-          when :third then arg_types[2]
-          when Symbol then rule
-          end
+          FunctionRegistry.resolve_return_type(rule, arg_types)
         end
 
         def binary_op_result_type(op, left_type, right_type)
-          op_kind = BINARY_OPERATORS[op.to_s]
-
-          case op_kind
-          when :comparison, :logical
-            :bool
-          when :arithmetic
-            if matrix_type?(left_type) && vector_type?(right_type)
-              matrix_vector_result(left_type)
-            elsif vector_type?(left_type) && matrix_type?(right_type)
-              matrix_vector_result(right_type)
-            elsif matrix_type?(left_type) && matrix_type?(right_type)
-              left_type
-            elsif matrix_type?(left_type) && scalar_type?(right_type)
-              left_type
-            elsif scalar_type?(left_type) && matrix_type?(right_type)
-              right_type
-            elsif vector_type?(left_type) && vector_type?(right_type)
-              left_type
-            elsif vector_type?(left_type) && scalar_type?(right_type)
-              left_type
-            elsif scalar_type?(left_type) && vector_type?(right_type)
-              right_type
-            else
-              :float
-            end
-          end
+          OperatorRules.binary_op_result_type(op, left_type, right_type)
         end
 
         def vector_type?(type)
-          %i[vec2 vec3 vec4].include?(type)
+          OperatorRules.vector_type?(type)
         end
 
         def matrix_type?(type)
-          %i[mat2 mat3 mat4].include?(type)
+          OperatorRules.matrix_type?(type)
         end
 
         def scalar_type?(type)
-          %i[float int].include?(type)
+          OperatorRules.scalar_type?(type)
+        end
+
+        def common_type(types)
+          OperatorRules.common_type(types)
         end
 
         def matrix_vector_result(matrix_type)
-          case matrix_type
-          when :mat2 then :vec2
-          when :mat3 then :vec3
-          when :mat4 then :vec4
-          end
+          OperatorRules.matrix_vector_result(matrix_type)
         end
       end
     end

data/lib/rlsl/prism/compilation_unit.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    CompilationUnit = Struct.new(:source_unit, :ir, keyword_init: true)
+  end
+end

data/lib/rlsl/prism/emitters/base_emitter/control_flow_emission.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Emitters
+      class BaseEmitter
+        module ControlFlowEmission
+          def emit_tuple_return(node)
+            "#{indent}return #{emit_tuple_value(node)};\n"
+          end
+
+          def emit_if_statement(node)
+            emit_conditional(node, needs_return: return_context?)
+          end
+
+          def emit_conditional(node, needs_return:)
+            condition = emit(node.condition)
+            then_code = emit_branch(node.then_branch, needs_return: needs_return)
+            declarations = emit_hoisted_declarations(node)
+
+            unless node.else_branch
+              return "#{declarations}#{indent}if (#{condition}) {\n#{then_code}#{indent}}#{needs_return ? "\n" : ""}"
+            end
+
+            if elsif_node?(node.else_branch)
+              elsif_code = emit_elsif(node.else_branch, needs_return: needs_return)
+              "#{declarations}#{indent}if (#{condition}) {\n#{then_code}#{indent}} #{elsif_code}#{needs_return ? "\n" : ""}"
+            else
+              else_code = emit_branch(node.else_branch, needs_return: needs_return)
+              "#{declarations}#{indent}if (#{condition}) {\n#{then_code}#{indent}} else {\n#{else_code}#{indent}}#{needs_return ? "\n" : ""}"
+            end
+          end
+
+          def emit_elsif(node, needs_return: false)
+            if_node = node.is_a?(IR::Block) ? node.statements.first : node
+            condition = emit(if_node.condition)
+            then_code = emit_branch(if_node.then_branch, needs_return: needs_return)
+
+            return "else if (#{condition}) {\n#{then_code}#{indent}}" unless if_node.else_branch
+
+            if elsif_node?(if_node.else_branch)
+              elsif_code = emit_elsif(if_node.else_branch, needs_return: needs_return)
+              "else if (#{condition}) {\n#{then_code}#{indent}} #{elsif_code}"
+            else
+              else_code = emit_branch(if_node.else_branch, needs_return: needs_return)
+              "else if (#{condition}) {\n#{then_code}#{indent}} else {\n#{else_code}#{indent}}"
+            end
+          end
+
+          def elsif_node?(node)
+            return true if node.is_a?(IR::IfStatement)
+            return false unless node.is_a?(IR::Block)
+
+            node.statements.length == 1 && node.statements.first.is_a?(IR::IfStatement)
+          end
+
+          def emit_return(node)
+            if node.expression.is_a?(IR::ArrayLiteral) && @return_struct_name_stack.any?
+              return "return #{emit_tuple_value(node.expression)}"
+            end
+
+            node.expression ? "return #{emit_return_expression(node.expression)}" : "return"
+          end
+
+          def emit_for_loop(node)
+            variable = node.variable
+            counter = loop_variable_mutated?(node) ? next_temporary_name("i") : variable
+            start_val = emit(node.range_start)
+            end_val = emit(node.range_end)
+            body = emit_indented_block(node.body)
+            body = "#{indent}  #{type_name(:int)} #{variable} = #{counter};\n#{body}" if counter != variable
+
+            comparison = node.exclude_end ? "<" : "<="
+            return "for (int #{counter} = #{start_val}; #{counter} #{comparison} #{end_val}; #{counter}++) {\n#{body}#{indent}}" if node.range_end.is_a?(IR::Literal)
+
+            bound = next_temporary_name("end")
+            "int #{bound} = #{end_val};\n#{indent}for (int #{counter} = #{start_val}; #{counter} #{comparison} #{bound}; #{counter}++) {\n#{body}#{indent}}"
+          end
+
+          def emit_while_loop(node)
+            condition = emit(node.condition)
+            body = emit_indented_block(node.body)
+
+            "while (#{condition}) {\n#{body}#{indent}}"
+          end
+
+          def emit_break(_node)
+            "break"
+          end
+
+          def emit_hoisted_declarations(node)
+            node.hoisted_variables.map do |name, type|
+              "#{indent}#{type_name(type || :float)} #{name};\n"
+            end.join
+          end
+
+          def emit_tuple_value(node)
+            expected_types = Array(current_return_type)
+            elements = node.elements.each_with_index.map do |element, index|
+              emit_typed_argument(element, expected_types[index])
+            end.join(", ")
+            "(#{current_return_struct_name}){#{elements}}"
+          end
+
+          def emit_return_expression(node)
+            emit_typed_argument(node, current_return_type)
+          end
+
+          def loop_variable_mutated?(node)
+            IR::Traversal.each(node.body).any? do |current|
+              case current
+              when IR::Assignment
+                current.target.is_a?(IR::VarRef) && current.target.name == node.variable
+              when IR::MultipleAssignment
+                current.targets.any? { |target| target.name == node.variable }
+              else
+                false
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/emitters/base_emitter/definition_emission.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Emitters
+      class BaseEmitter
+        module DefinitionEmission
+          def emit_function_definition(node)
+            name = node.name
+            params = node.params.map do |param|
+              "#{type_name(node.param_types[param] || :float)} #{param}"
+            end.join(", ")
+
+            if node.return_type.is_a?(Array)
+              struct_def = emit_result_struct(name, node.return_type)
+              body = with_return_struct_name("#{name}_result") do
+                with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+              end
+              "#{struct_def}#{function_qualifier}#{name}_result #{name}(#{params}) {\n#{body}#{indent}}\n"
+            else
+              body = with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+              "#{function_qualifier}#{type_name(node.return_type || :float)} #{name}(#{params}) {\n#{body}#{indent}}\n"
+            end
+          end
+
+          def emit_result_struct(func_name, types)
+            fields = types.each_with_index.map { |type, index| "#{type_name(type)} v#{index};" }.join(" ")
+            "typedef struct { #{fields} } #{func_name}_result;\n"
+          end
+
+          def current_return_struct_name
+            @return_struct_name_stack.last || "result"
+          end
+
+          def emit_array_literal(node, for_static_init: false)
+            element_type = TypeShapes.element_type(node.type)
+            elements = node.elements.map do |element|
+              if for_static_init
+                emit_for_static_init(element, true)
+              else
+                emit_typed_argument(element, element_type)
+              end
+            end.join(", ")
+            "{#{elements}}"
+          end
+
+          def emit_for_static_init(node, for_static_init)
+            return emit(node) unless for_static_init
+
+            case node
+            when IR::FuncCall
+              if %i[vec2 vec3 vec4].include?(node.name)
+                args = node.args.map { |arg| emit_for_static_init(arg, true) }.join(", ")
+                "{#{args}}"
+              else
+                emit(node)
+              end
+            when IR::ArrayLiteral
+              emit_array_literal(node, for_static_init: true)
+            else
+              emit(node)
+            end
+          end
+
+          def emit_global_decl(node)
+            prefix = ""
+            prefix += "static " if node.is_static
+            prefix += "const " if node.is_const
+
+            if node.initializer.is_a?(IR::ArrayLiteral)
+              elem_type = type_name(node.element_type || :float)
+              size = node.array_size || node.initializer.elements.length
+              elements = emit_array_literal(node.initializer, for_static_init: true)
+              "#{prefix}#{elem_type} #{node.name}[#{size}] = #{elements}"
+            else
+              value = node.is_static ? emit_for_static_init(node.initializer, true) : emit(node.initializer)
+              "#{prefix}#{type_name(node.type || :float)} #{node.name} = #{value}"
+            end
+          end
+
+          def emit_multiple_assignment(node)
+            value_code = emit(node.value)
+
+            if node.value.is_a?(IR::FuncCall)
+              emit_multi_return_assignment(node, value_code)
+            elsif node.value.is_a?(IR::ArrayLiteral)
+              emit_literal_assignment(node)
+            else
+              emit_indexed_assignment(node, value_code)
+            end
+          end
+
+          private
+
+          def emit_multi_return_assignment(node, value_code)
+            func_name = node.value.name
+            temporary = next_temporary_name("result")
+            lines = [emit_temporary_declaration("#{func_name}_result", temporary, value_code)]
+            node.targets.each_with_index do |target, index|
+              lines << "#{emit_multiple_assignment_target(target, node.declarations[index])} = #{temporary}.v#{index}"
+            end
+            lines.join(";\n#{indent}")
+          end
+
+          def emit_indexed_assignment(node, value_code)
+            node.targets.each_with_index.map do |target, index|
+              "#{emit_multiple_assignment_target(target, node.declarations[index])} = #{value_code}[#{index}]"
+            end.join(";\n#{indent}")
+          end
+
+          def emit_literal_assignment(node)
+            temporaries = node.value.elements.map do |element|
+              name = next_temporary_name("value")
+              [name, emit_temporary_declaration(type_name(element.type || :float), name, emit(element))]
+            end
+            lines = temporaries.map(&:last)
+            node.targets.each_with_index do |target, index|
+              lines << "#{emit_multiple_assignment_target(target, node.declarations[index])} = #{temporaries[index].first}"
+            end
+            lines.join(";\n#{indent}")
+          end
+
+          def emit_multiple_assignment_target(target, declaration)
+            declaration ? "#{type_name(target.type || :float)} #{target.name}" : target.name.to_s
+          end
+
+          def emit_temporary_declaration(type, name, value)
+            "#{type} #{name} = #{value}"
+          end
+        end
+      end
+    end
+  end
+end