rlsl 0.1.1 → 1.0.1

data/lib/rlsl/prism/ast_visitor.rb

@@ -3,17 +3,53 @@
 require "prism"
 require "set"
 
+require_relative "node_traversal"
+require_relative "errors"
+require_relative "parameter_list"
+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 ASTVisitor
+      MAX_AST_DEPTH = 512
       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
+        @source_name = context[:source_name] || "(shader source)"
+        @line_offset = context[:line_offset].to_i
+        params = context[:params] || []
+        @scope_context = ScopeContext.new(params: params)
+        positional_types = params.each_with_index.to_h do |name, index|
+          [name.to_sym, %i[vec2 vec2 uniforms][index]]
+        end
+        @parameter_types = { frag_coord: :vec2, resolution: :vec2, u: :uniforms }.merge(positional_types)
+        @parameter_bindings = { frag_coord: :frag_coord, resolution: :resolution, u: :u }
+        @implicit_loop_index = 0
+        @source_identifiers = Set.new
+        params.each_with_index do |name, index|
+          @parameter_bindings[name.to_sym] = %i[frag_coord resolution u][index]
+        end
       end
 
       def parse(source)
@@ -21,34 +57,39 @@ module RLSL
 
         unless result.success?
           errors = result.errors.map(&:message).join(", ")
-          raise "Parse error: #{errors}"
+          raise RLSL::ParseError, "Parse error: #{errors}"
         end
 
         program = result.value
+        if NodeTraversal.depth_exceeds?(program, MAX_AST_DEPTH)
+          raise UnsupportedSyntaxError, "Shader syntax nesting exceeds #{MAX_AST_DEPTH} nodes"
+        end
+        @source_identifiers = NodeTraversal.each(program).filter_map do |node|
+          node.name.to_sym if node.respond_to?(:name)
+        end.to_set
+
         visit(program)
       end
 
       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
+        method_name = NODE_VISITORS[node.class]
+        result = if method_name
+                   send(method_name, node)
+                 else
+                   raise UnsupportedSyntaxError, "Unsupported Prism node: #{node.class}" unless transparent_node?(node)
+
+                   visit_default(node)
+                 end
+        attach_source_location(result, node.location)
+      rescue RLSL::Error => error
+        error.with_source_location(source_location(node.location))
+        raise
       end
 
       private
 
-      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
-      end
-
       def visit_default(node)
         children = []
         node.child_nodes.compact.each do |child|
@@ -58,6 +99,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 +112,73 @@ 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)
+      def visit_with_scoped_vars(node, params: [])
+        @scope_context.with_scope(params: params) { visit(node) }
       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)
-      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
+      def infer_param_type(name)
+        @parameter_types[name.to_sym]
       end
 
-      def visit_and(node)
-        left = visit(node.left)
-        right = visit(node.right)
-        IR::BinaryOp.new("&&", left, right, :bool)
+      def emitted_parameter_name(name)
+        @parameter_bindings[name.to_sym] || name.to_sym
       end
 
-      def visit_or(node)
-        left = visit(node.left)
-        right = visit(node.right)
-        IR::BinaryOp.new("||", left, right, :bool)
+      def extract_required_params(node)
+        ParameterList.required_names(node).map(&:to_sym)
       end
 
-      def visit_not(node)
-        operand = visit(node.expression)
-        IR::UnaryOp.new("!", operand, :bool)
-      end
+      def extract_block_params(node)
+        return [] unless node&.parameters
 
-      def visit_while(node)
-        condition = visit(node.predicate)
-        body = visit(node.statements)
-        IR::WhileLoop.new(condition, body)
+        extract_required_params(node.parameters.parameters)
       end
 
-      def visit_break(node)
-        IR::Break.new
+      def parameter_reference?(name)
+        @scope_context.parameter?(name)
       end
 
-      def visit_constant_read(node)
-        name = node.name.to_s
-        if %w[PI TAU].include?(name)
-          IR::Constant.new(name.to_sym, :float)
-        else
-          IR::VarRef.new(name.to_sym)
-        end
+      def fragment_parameter_reference?(name)
+        @scope_context.root_parameter?(name)
       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
+      def emitted_assignment_name(name)
+        if fragment_parameter_reference?(name) && infer_param_type(name) == :uniforms
+          raise UnsupportedSyntaxError, "The fragment uniform parameter cannot be reassigned"
         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)
+        fragment_parameter_reference?(name) ? emitted_parameter_name(name) : name
       end
 
-      def visit_array(node)
-        elements = node.elements.map { |elem| visit(elem) }
-        IR::ArrayLiteral.new(elements)
+      def known_variable?(name)
+        @scope_context.known_variable?(name)
       end
 
-      def visit_index(node)
-        array = visit(node.receiver)
-        index = visit(node.arguments.arguments.first)
-        IR::ArrayIndex.new(array, index)
+      def declare_variable(name)
+        @scope_context.declare(name)
       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
+      def next_implicit_loop_variable
+        loop do
+          name = :"_rlsl_i#{@implicit_loop_index}"
+          @implicit_loop_index += 1
+          return name unless @source_identifiers.include?(name)
         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 attach_source_location(result, prism_location)
+        return result unless result.is_a?(IR::Node)
 
-        IR::GlobalDecl.new(name, value, is_static: true)
-      end
-
-      def visit_constant_write(node)
-        name = node.name.to_sym
-        value = visit(node.value)
-
-        IR::GlobalDecl.new(name, value, is_const: true, is_static: true)
-      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)
-      end
-
-      def visit_local_variable_target(node)
-        name = node.name.to_sym
-        @declared_vars.add(name)
-        IR::VarRef.new(name)
+        result.location ||= source_location(prism_location)
+        result
       end
 
-      def infer_param_type(name)
-        case name
-        when :frag_coord, :resolution
-          :vec2
-        when :u
-          :uniforms
-        else
-          nil
-        end
+      def source_location(prism_location)
+        RLSL::SourceLocation.new(
+          source_name: @source_name,
+          line: @line_offset + prism_location.start_line,
+          column: prism_location.start_column + 1
+        )
       end
     end
   end

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

@@ -0,0 +1,131 @@
+# 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 common floating interpolated].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, targets: %i[glsl wgsl msl] },
+          mat3: { args: %i[any any any any any any any any any], returns: :mat3, variadic: true, min_args: 1, targets: %i[glsl wgsl msl] },
+          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, targets: %i[glsl wgsl msl] },
+
+          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: :floating },
+
+          abs: { args: [:any], returns: :same },
+          sign: { args: [:any], returns: :same },
+          floor: { args: [:any], returns: :floating },
+          ceil: { args: [:any], returns: :floating },
+          fract: { args: [:any], returns: :floating },
+          mod: { args: %i[float float], returns: :float },
+          min: { args: %i[any any], returns: :common },
+          max: { args: %i[any any], returns: :common },
+          clamp: { args: %i[any any any], returns: :common },
+          mix: { args: %i[any any float], returns: :interpolated },
+          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, targets: [:c] },
+          hash22: { args: [:vec2], returns: :vec2, targets: [:c] },
+
+          lessThan: { args: %i[any any], returns: :bool, targets: [] },
+          lessThanEqual: { args: %i[any any], returns: :bool, targets: [] },
+          greaterThan: { args: %i[any any], returns: :bool, targets: [] },
+          greaterThanEqual: { args: %i[any any], returns: :bool, targets: [] },
+          equal: { args: %i[any any], returns: :bool, targets: [] },
+          notEqual: { args: %i[any any], returns: :bool, targets: [] },
+
+          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, targets: %i[glsl wgsl msl] },
+          texture: { args: %i[sampler2D vec2], returns: :vec4, targets: %i[glsl wgsl msl] },
+          textureLod: { args: %i[sampler2D vec2 float], returns: :vec4, targets: %i[glsl wgsl msl] }
+        }.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 :common
+            type = OperatorRules.common_type(arg_types)
+            type if numeric_type?(type)
+          when :floating
+            type = arg_types.first
+            return :float if type == :int
+
+            type if type == :float || OperatorRules.vector_type?(type)
+          when :interpolated
+            type = OperatorRules.common_type(arg_types.first(2))
+            return :float if type == :int
+
+            type if numeric_type?(type)
+          when Symbol then rule
+          end
+        end
+
+        def explicit_type?(type)
+          type.is_a?(Symbol) && !META_TYPES.include?(type)
+        end
+
+        def numeric_type?(type)
+          OperatorRules.scalar_type?(type) || OperatorRules.vector_type?(type)
+        end
+      end
+    end
+  end
+end