rlsl 0.1.0 → 1.0.0

data/lib/rlsl/prism/ast_visitor.rb

@@ -3,17 +3,38 @@
 require "prism"
 require "set"
 
+require_relative "ast_visitor/visitor_registry"
+require_relative "ast_visitor/scope_context"
+require_relative "ast_visitor/expression_visiting"
+require_relative "ast_visitor/control_flow_visiting"
+require_relative "ast_visitor/definition_visiting"
+
 module RLSL
   module Prism
+    class UnsupportedSyntaxError < StandardError; end
+
     class ASTVisitor
       BINARY_OPERATORS = %w[+ - * / % == != < > <= >= && ||].freeze
       UNARY_OPERATORS = %w[- !].freeze
+      TRANSPARENT_NODES = VisitorRegistry::TRANSPARENT_NODES
+      NODE_VISITORS = VisitorRegistry.build(
+        {}.tap do |visitors|
+          visitors[::Prism::ProgramNode] = :visit_program if defined?(::Prism::ProgramNode)
+          visitors[::Prism::StatementsNode] = :visit_statements if defined?(::Prism::StatementsNode)
+        end,
+        ExpressionVisiting::VISITORS,
+        ControlFlowVisiting::VISITORS,
+        DefinitionVisiting::VISITORS
+      )
+
+      include ExpressionVisiting
+      include ControlFlowVisiting
+      include DefinitionVisiting
 
       def initialize(context = {})
         @context = context
         @uniforms = context[:uniforms] || {}
-        @params = Set.new(context[:params] || [])
-        @declared_vars = Set.new
+        @scope_context = ScopeContext.new(params: context[:params] || [])
       end
 
       def parse(source)
@@ -31,24 +52,16 @@ module RLSL
       def visit(node)
         return nil if node.nil?
 
-        method_name = "visit_#{node_type(node)}"
-        if respond_to?(method_name, true)
-          send(method_name, node)
-        else
-          visit_default(node)
-        end
-      end
+        method_name = NODE_VISITORS[node.class]
+        return send(method_name, node) if method_name
 
-      private
+        raise UnsupportedSyntaxError, "Unsupported Prism node: #{node.class}" unless transparent_node?(node)
 
-      def node_type(node)
-        node.class.name.split("::").last
-          .gsub(/Node$/, "")
-          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-          .downcase
+        visit_default(node)
       end
 
+      private
+
       def visit_default(node)
         children = []
         node.child_nodes.compact.each do |child|
@@ -58,6 +71,10 @@ module RLSL
         children.length == 1 ? children.first : children
       end
 
+      def transparent_node?(node)
+        TRANSPARENT_NODES.include?(node.class)
+      end
+
       def visit_program(node)
         visit(node.statements)
       end
@@ -67,304 +84,43 @@ module RLSL
         IR::Block.new(statements)
       end
 
-      def visit_block(node)
-        if node.parameters
-          node.parameters.parameters&.requireds&.each do |param|
-            @params.add(param.name.to_sym)
-          end
-        end
-
-        visit(node.body)
-      end
-
-      def visit_lambda(node)
-        visit_block(node)
-      end
-
-      def visit_local_variable_write(node)
-        name = node.name.to_sym
-        value = visit(node.value)
-
-        if @declared_vars.include?(name) || @params.include?(name)
-          IR::Assignment.new(IR::VarRef.new(name), value)
-        else
-          @declared_vars.add(name)
-          IR::VarDecl.new(name, value)
-        end
-      end
-
-      def visit_local_variable_read(node)
-        name = node.name.to_sym
-        type = infer_param_type(name)
-        IR::VarRef.new(name, type)
-      end
-
-      def visit_integer(node)
-        IR::Literal.new(node.value.to_f, :float)
-      end
-
-      def visit_float(node)
-        IR::Literal.new(node.value, :float)
-      end
-
-      def visit_rational(node)
-        IR::Literal.new(node.value.to_f, :float)
-      end
-
-      def visit_true(node)
-        IR::BoolLiteral.new(true)
-      end
-
-      def visit_false(node)
-        IR::BoolLiteral.new(false)
+      def visit_with_scoped_vars(node, params: [])
+        @scope_context.with_scope(params: params) { visit(node) }
       end
 
-      def visit_parentheses(node)
-        inner = visit(node.body)
-        if inner.is_a?(IR::Block) && inner.statements.length == 1
-          inner = inner.statements.first
-        end
-        IR::Parenthesized.new(inner)
-      end
-
-      def visit_call(node)
-        method_name = node.name.to_s
-        receiver = visit(node.receiver) if node.receiver
-        args = node.arguments&.arguments&.map { |arg| visit(arg) } || []
-
-        if !receiver && args.empty? && @params.include?(method_name.to_sym)
-          type = infer_param_type(method_name.to_sym)
-          return IR::VarRef.new(method_name.to_sym, type)
-        end
-
-        if receiver && args.empty? && !node.arguments
-          if Builtins.single_component_field?(method_name)
-            return IR::FieldAccess.new(receiver, method_name, :float)
-          elsif Builtins.swizzle?(method_name)
-            type = Builtins.swizzle_type(method_name)
-            return IR::Swizzle.new(receiver, method_name, type)
-          else
-            return IR::FieldAccess.new(receiver, method_name)
-          end
-        end
-
-        if BINARY_OPERATORS.include?(method_name) && receiver && args.length == 1
-          return IR::BinaryOp.new(method_name, receiver, args.first)
-        end
-
-        if method_name == "-@" && receiver
-          return IR::UnaryOp.new("-", receiver)
-        end
-        if method_name == "!" && args.length == 1
-          return IR::UnaryOp.new("!", args.first)
-        end
-
-        if method_name == "[]" && receiver && args.length == 1
-          return IR::ArrayIndex.new(receiver, args.first)
-        end
-
-        IR::FuncCall.new(method_name.to_sym, args, receiver)
-      end
-
-      def visit_if(node)
-        condition = visit(node.predicate)
-        then_branch = visit_with_scoped_vars(node.statements)
-        else_branch = node.subsequent ? visit_with_scoped_vars(node.subsequent) : nil
-
-        IR::IfStatement.new(condition, then_branch, else_branch)
-      end
-
-      def visit_with_scoped_vars(node)
-        saved_vars = @declared_vars.dup
-        result = visit(node)
-        @declared_vars = saved_vars
-        result
-      end
-
-      def visit_else(node)
-        visit(node.statements)
-      end
-
-      def visit_elsif(node)
-        visit_if(node)
-      end
-
-      def visit_if_node(node)
-        visit_if(node)
-      end
-
-      def visit_unless(node)
-        condition = IR::UnaryOp.new("!", visit(node.predicate))
-        then_branch = visit(node.statements)
-        else_branch = node.else_clause ? visit(node.else_clause) : nil
-
-        IR::IfStatement.new(condition, then_branch, else_branch)
-      end
-
-      def visit_return(node)
-        expr = node.arguments ? visit(node.arguments.arguments.first) : nil
-        IR::Return.new(expr)
-      end
-
-      def visit_range(node)
-        [visit(node.left), visit(node.right)]
-      end
-
-      def visit_for(node)
-        var_name = node.index.name.to_sym
-        range = visit(node.collection)
-        body = visit(node.statements)
-
-        IR::ForLoop.new(var_name, range[0], range[1], body)
-      end
-
-      def visit_call_with_block(node)
-        call_node = node
-        method_name = call_node.name.to_s
-
-        if method_name == "times" && call_node.receiver
-          count = visit(call_node.receiver)
-          block = visit(call_node.block)
-
-          var_name = :i
-          if call_node.block&.parameters&.parameters&.requireds&.any?
-            var_name = call_node.block.parameters.parameters.requireds.first.name.to_sym
-          end
-
-          IR::ForLoop.new(var_name, IR::Literal.new(0, :int), count, block)
-        else
-          visit_call(node)
-        end
-      end
-
-      def visit_and(node)
-        left = visit(node.left)
-        right = visit(node.right)
-        IR::BinaryOp.new("&&", left, right, :bool)
-      end
-
-      def visit_or(node)
-        left = visit(node.left)
-        right = visit(node.right)
-        IR::BinaryOp.new("||", left, right, :bool)
-      end
-
-      def visit_not(node)
-        operand = visit(node.expression)
-        IR::UnaryOp.new("!", operand, :bool)
-      end
-
-      def visit_while(node)
-        condition = visit(node.predicate)
-        body = visit(node.statements)
-        IR::WhileLoop.new(condition, body)
-      end
-
-      def visit_break(node)
-        IR::Break.new
-      end
-
-      def visit_constant_read(node)
-        name = node.name.to_s
-        if %w[PI TAU].include?(name)
-          IR::Constant.new(name.to_sym, :float)
+      def infer_param_type(name)
+        case name
+        when :frag_coord, :resolution
+          :vec2
+        when :u
+          :uniforms
         else
-          IR::VarRef.new(name.to_sym)
-        end
-      end
-
-      def visit_def(node)
-        name = node.name.to_sym
-        params = []
-
-        if node.parameters
-          node.parameters.requireds&.each do |param|
-            params << param.name.to_sym
-          end
-        end
-
-        saved_params = @params.dup
-        saved_declared_vars = @declared_vars.dup
-        @declared_vars = Set.new
-        params.each { |p| @params.add(p) }
-
-        body = visit(node.body)
-
-        @params = saved_params
-        @declared_vars = saved_declared_vars
-
-        IR::FunctionDefinition.new(name, params, body)
-      end
-
-      def visit_array(node)
-        elements = node.elements.map { |elem| visit(elem) }
-        IR::ArrayLiteral.new(elements)
-      end
-
-      def visit_index(node)
-        array = visit(node.receiver)
-        index = visit(node.arguments.arguments.first)
-        IR::ArrayIndex.new(array, index)
-      end
-
-      def visit_constant_path(node)
-        path_parts = []
-        current = node
-        while current.is_a?(::Prism::ConstantPathNode)
-          path_parts.unshift(current.name.to_s)
-          current = current.parent
+          nil
         end
-        path_parts.unshift(current.name.to_s) if current.respond_to?(:name)
-
-        full_name = path_parts.join("_")
-        IR::VarRef.new(full_name.to_sym)
-      end
-
-      def visit_global_variable_read(node)
-        name = node.name.to_s.sub(/^\$/, "").to_sym
-        IR::VarRef.new(name)
       end
 
-      def visit_global_variable_write(node)
-        name = node.name.to_s.sub(/^\$/, "").to_sym
-        value = visit(node.value)
+      def extract_required_params(node)
+        return [] unless node
 
-        IR::GlobalDecl.new(name, value, is_static: true)
+        node.requireds&.map { |param| param.name.to_sym } || []
       end
 
-      def visit_constant_write(node)
-        name = node.name.to_sym
-        value = visit(node.value)
+      def extract_block_params(node)
+        return [] unless node&.parameters
 
-        IR::GlobalDecl.new(name, value, is_const: true, is_static: true)
+        extract_required_params(node.parameters.parameters)
       end
 
-      def visit_multi_write(node)
-        targets = node.lefts.map do |target|
-          name = target.name.to_sym
-          @declared_vars.add(name)
-          IR::VarRef.new(name)
-        end
-
-        value = visit(node.value)
-        IR::MultipleAssignment.new(targets, value)
+      def parameter_reference?(name)
+        @scope_context.parameter?(name)
       end
 
-      def visit_local_variable_target(node)
-        name = node.name.to_sym
-        @declared_vars.add(name)
-        IR::VarRef.new(name)
+      def known_variable?(name)
+        @scope_context.known_variable?(name)
       end
 
-      def infer_param_type(name)
-        case name
-        when :frag_coord, :resolution
-          :vec2
-        when :u
-          :uniforms
-        else
-          nil
-        end
+      def declare_variable(name)
+        @scope_context.declare(name)
       end
     end
   end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Builtins
+      module FunctionRegistry
+        ALL_TARGETS = %i[c glsl wgsl msl].freeze
+        META_TYPES = %i[any same first second third].freeze
+
+        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, targets: %i[glsl wgsl msl] },
+          transpose: { args: [:any], returns: :same, targets: %i[glsl wgsl msl] },
+          determinant: { args: [:any], returns: :float, targets: %i[glsl wgsl msl] },
+
+          texture2D: { args: %i[sampler2D vec2], returns: :vec4 },
+          texture: { args: %i[sampler2D vec2], returns: :vec4 },
+          textureLod: { args: %i[sampler2D vec2 float], returns: :vec4 }
+        }.freeze
+
+        module_function
+
+        def function?(name)
+          FUNCTIONS.key?(name.to_sym)
+        end
+
+        def function_signature(name)
+          FUNCTIONS[name.to_sym]
+        end
+
+        def supported_on_target?(name, target)
+          signature = function_signature(name)
+          return false unless signature
+
+          Array(signature[:targets] || ALL_TARGETS).include?(target.to_sym)
+        end
+
+        def explicit_types(name)
+          signature = function_signature(name)
+          return [] unless signature
+
+          ([signature[:returns]] + Array(signature[:args])).filter_map do |type|
+            type if explicit_type?(type)
+          end.uniq
+        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
+        end
+
+        def explicit_type?(type)
+          type.is_a?(Symbol) && !META_TYPES.include?(type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# 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]
+
+          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 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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[xyzwrgba]{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
+      end
+    end
+  end
+end