rlsl 1.0.0 → 1.0.1

data/lib/rlsl/prism/emitters/wgsl_emitter.rb

@@ -39,45 +39,102 @@ module RLSL
 
         def emit_var_decl(node)
           type = type_name(node.type || :float)
+          return "var #{node.name}: #{type}" unless node.initializer
+
+          if node.initializer.is_a?(IR::ArrayLiteral)
+            element_type_symbol = TypeShapes.element_type(node.type) || :float
+            element_type = type_name(element_type_symbol)
+            size = node.initializer.elements.length
+            values = node.initializer.elements.map do |element|
+              emit_typed_argument(element, element_type_symbol)
+            end.join(", ")
+            return "var #{node.name}: array<#{element_type}, #{size}> = array<#{element_type}, #{size}>(#{values})"
+          end
+
           value = emit(node.initializer)
-          "let #{node.name}: #{type} = #{value}"
+          binding = node.mutable ? "var" : "let"
+          "#{binding} #{node.name}: #{type} = #{value}"
         end
 
         def emit_for_loop(node)
-          var = node.variable
+          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}  var #{variable}: i32 = #{counter};\n#{body}" if counter != variable
+
+          comparison = node.exclude_end ? "<" : "<="
+          return "for (var #{counter}: i32 = #{start_val}; #{counter} #{comparison} #{end_val}; #{counter}++) {\n#{body}#{indent}}" if node.range_end.is_a?(IR::Literal)
+
+          bound = next_temporary_name("end")
+          "let #{bound}: i32 = #{end_val};\n#{indent}for (var #{counter}: i32 = #{start_val}; #{counter} #{comparison} #{bound}; #{counter}++) {\n#{body}#{indent}}"
+        end
 
-          "for (var #{var}: i32 = #{start_val}; #{var} < #{end_val}; #{var}++) {\n#{body}#{indent}}"
+        def emit_ternary(_node)
+          raise TargetCapabilityError,
+                "WGSL conditional expressions cannot be emitted without eager branch evaluation"
         end
 
-        def emit_ternary(node)
-          condition = emit(node.condition)
-          then_expr = emit(node.then_expr)
-          else_expr = emit(node.else_expr)
-          "select(#{else_expr}, #{then_expr}, #{condition})"
+        def emit_binary_op(node)
+          if node.operator == "%" && node.type == :float
+            return "rlsl_mod(#{emit_float_operand(node.left)}, #{emit_float_operand(node.right)})"
+          end
+
+          super
+        end
+
+        def emit_func_call(node)
+          if node.name.to_sym == :mod
+            args = node.args.map { |argument| emit_float_operand(argument) }
+            return "rlsl_mod(#{args.join(', ')})"
+          end
+          if node.name.to_sym == :atan && node.args.length == 2
+            return emit_named_call("atan2", node.args, expected_types: node.expected_arg_types)
+          end
+
+          super
         end
 
         def emit_function_definition(node)
           name = node.name
-          params = node.params.map do |param|
-            param_type = type_name(node.param_types[param] || :float)
-            "#{param}: #{param_type}"
+          mutable_params = mutated_parameters(node)
+          initializers = []
+          sampler_params = {}
+          params = node.params.flat_map do |param|
+            type = node.param_types[param] || :float
+            if type == :sampler2D
+              if mutable_params.include?(param)
+                raise TargetCapabilityError, "WGSL texture parameter #{param} cannot be reassigned"
+              end
+
+              sampler_params[param] = next_temporary_name("sampler")
+              ["#{param}: #{type_name(type)}", "#{sampler_params[param]}: sampler"]
+            elsif mutable_params.include?(param)
+              argument = next_temporary_name("param")
+              initializers << "#{indent}  var #{param}: #{type_name(type)} = #{argument};\n"
+              ["#{argument}: #{type_name(type)}"]
+            else
+              ["#{param}: #{type_name(type)}"]
+            end
           end.join(", ")
 
           if node.return_type.is_a?(Array)
-            @current_return_struct_name = "#{name}_result"
             struct_def = emit_result_struct(name, node.return_type)
-            body = emit_indented_block(node.body, needs_return: true)
-            @current_return_struct_name = nil
+            body = with_return_struct_name("#{name}_result") do
+              with_sampler_parameters(sampler_params) do
+                with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+              end
+            end
 
-            "#{struct_def}fn #{name}(#{params}) -> #{name}_result {\n#{body}\n#{indent}}\n"
+            "#{struct_def}fn #{name}(#{params}) -> #{name}_result {\n#{initializers.join}#{body}#{indent}}\n"
           else
             return_type = type_name(node.return_type || :float)
-            body = emit_indented_block(node.body, needs_return: true)
+            body = with_sampler_parameters(sampler_params) do
+              with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+            end
 
-            "fn #{name}(#{params}) -> #{return_type} {\n#{body}\n#{indent}}\n"
+            "fn #{name}(#{params}) -> #{return_type} {\n#{initializers.join}#{body}#{indent}}\n"
           end
         end
 
@@ -85,7 +142,105 @@ module RLSL
           fields = types.each_with_index.map do |type, index|
             "#{indent}v#{index}: #{type_name(type)},"
           end.join("\n")
-          "struct #{func_name}_result {\n#{fields}\n};\n"
+          "struct #{func_name}_result {\n#{fields}\n}\n"
+        end
+
+        def emit_hoisted_declarations(node)
+          node.hoisted_variables.map do |name, type|
+            "#{indent}var #{name}: #{type_name(type || :float)};\n"
+          end.join
+        end
+
+        def emit_global_decl(node)
+          if node.initializer.is_a?(IR::ArrayLiteral)
+            element_type_symbol = node.element_type || TypeShapes.element_type(node.initializer.type) || :float
+            element_type = type_name(element_type_symbol)
+            size = node.array_size || node.initializer.elements.length
+            values = node.initializer.elements.map do |element|
+              emit_typed_argument(element, element_type_symbol)
+            end.join(", ")
+            prefix = node.is_const ? "const" : "var<private>"
+            return "#{prefix} #{node.name}: array<#{element_type}, #{size}> = array<#{element_type}, #{size}>(#{values})"
+          end
+
+          prefix = node.is_const ? "const" : "var<private>"
+          "#{prefix} #{node.name}: #{type_name(node.type || :float)} = #{emit(node.initializer)}"
+        end
+
+        def emit_field_access(node)
+          return node.field.to_s if node.receiver.type == :uniforms && node.type == :sampler2D
+
+          code = super
+          return "(#{code} != 0)" if node.receiver.type == :uniforms && node.type == :bool
+
+          code
+        end
+
+        def emit_texture_call(name, node)
+          return unless profile.texture_functions.key?(name) && node.args.length >= 2
+
+          texture = emit(node.args[0])
+          sampler = sampler_name(node.args[0], texture)
+          uv = emit(node.args[1])
+          lod = node.args[2] ? emit_typed_argument(node.args[2], :float) : "0.0"
+          "textureSampleLevel(#{texture}, #{sampler}, #{uv}, #{lod})"
+        end
+
+        def emit_named_call(name, args, receiver: nil, expected_types: [])
+          arguments = receiver ? [receiver, *args] : args
+          rendered = arguments.each_with_index.flat_map do |argument, index|
+            if expected_types[index] == :sampler2D
+              texture = emit(argument)
+              [texture, sampler_name(argument, texture)]
+            else
+              [emit_typed_argument(argument, expected_types[index])]
+            end
+          end
+          "#{name}(#{rendered.join(', ')})"
+        end
+
+        def emit_multiple_assignment_target(target, declaration)
+          declaration ? "var #{target.name}: #{type_name(target.type || :float)}" : target.name.to_s
+        end
+
+        def emit_temporary_declaration(type, name, value)
+          "let #{name}: #{type} = #{value}"
+        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
+
+        private
+
+        def mutated_parameters(node)
+          parameters = node.params.to_set
+          IR::Traversal.each(node.body).each_with_object(Set.new) do |current, names|
+            case current
+            when IR::Assignment
+              names.add(current.target.name) if current.target.is_a?(IR::VarRef) && parameters.include?(current.target.name)
+            when IR::MultipleAssignment
+              current.targets.each { |target| names.add(target.name) if parameters.include?(target.name) }
+            end
+          end
+        end
+
+        def with_sampler_parameters(parameters)
+          previous = @sampler_parameters
+          @sampler_parameters = parameters
+          yield
+        ensure
+          @sampler_parameters = previous
+        end
+
+        def sampler_name(argument, texture)
+          return @sampler_parameters[argument.name] if argument.is_a?(IR::VarRef) && @sampler_parameters&.key?(argument.name)
+
+          "#{texture}_sampler"
         end
       end
     end

data/lib/rlsl/prism/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module RLSL
+  module Prism
+    class UnsupportedSyntaxError < RLSL::Error; end
+  end
+end

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

@@ -4,15 +4,16 @@ module RLSL
   module Prism
     module IR
       class IfStatement < Node
-        attr_reader :condition, :then_branch, :else_branch
+        attr_reader :condition, :then_branch, :else_branch, :hoisted_variables
 
         visits :visit_if_statement
 
-        def initialize(condition, then_branch, else_branch = nil, type = nil)
+        def initialize(condition, then_branch, else_branch = nil, type = nil, hoisted_variables: {})
           super()
           @condition = condition
           @then_branch = then_branch
           @else_branch = else_branch
+          @hoisted_variables = hoisted_variables
           @type = type
         end
       end
@@ -43,16 +44,17 @@ module RLSL
       end
 
       class ForLoop < Node
-        attr_reader :variable, :range_start, :range_end, :body
+        attr_reader :variable, :range_start, :range_end, :body, :exclude_end
 
         visits :visit_for_loop
 
-        def initialize(variable, range_start, range_end, body)
+        def initialize(variable, range_start, range_end, body, exclude_end: true)
           super()
           @variable = variable
           @range_start = range_start
           @range_end = range_end
           @body = body
+          @exclude_end = exclude_end
           @type = nil
         end
       end

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

@@ -39,14 +39,15 @@ module RLSL
       end
 
       class MultipleAssignment < Node
-        attr_reader :targets, :value
+        attr_reader :targets, :value, :declarations
 
         visits :visit_multiple_assignment
 
-        def initialize(targets, value)
+        def initialize(targets, value, declarations: nil)
           super()
           @targets = targets
           @value = value
+          @declarations = declarations || Array.new(targets.length, true)
           @type = nil
         end
       end
@@ -61,6 +62,20 @@ module RLSL
         def to_sym
           :"tuple_#{types.map(&:to_s).join('_')}"
         end
+
+        def ==(other)
+          other.is_a?(self.class) && types == other.types
+        end
+
+        alias eql? ==
+
+        def hash
+          [self.class, types].hash
+        end
+
+        def inspect
+          "#<#{self.class.name} #{types.inspect}>"
+        end
       end
     end
   end

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

@@ -16,14 +16,16 @@ module RLSL
 
       class VarDecl < Node
         attr_reader :name, :initializer
+        attr_accessor :mutable
 
         visits :visit_var_decl
 
-        def initialize(name, initializer, type = nil)
+        def initialize(name, initializer, type = nil, mutable: false)
           super()
           @name = name
           @initializer = initializer
           @type = type
+          @mutable = mutable
         end
       end
 
@@ -92,6 +94,7 @@ module RLSL
 
       class FuncCall < Node
         attr_reader :name, :args, :receiver
+        attr_accessor :expected_arg_types
 
         visits :visit_func_call
 
@@ -100,6 +103,7 @@ module RLSL
           @name = name
           @args = args
           @receiver = receiver
+          @expected_arg_types = []
           @type = type
         end
       end

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

@@ -4,7 +4,7 @@ module RLSL
   module Prism
     module IR
       class Node
-        attr_accessor :type
+        attr_accessor :type, :location
 
         def self.visits(method_name)
           define_method(:accept) do |visitor|

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

@@ -10,8 +10,12 @@ module RLSL
           return enum_for(:each, node) unless block_given?
           return if node.nil?
 
-          yield node
-          child_nodes(node).each { |child| each(child, &block) }
+          stack = [node]
+          until stack.empty?
+            current = stack.pop
+            yield current
+            stack.concat(child_nodes(current).reverse)
+          end
         end
 
         def child_nodes(node)

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

data/lib/rlsl/prism/node_traversal.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module NodeTraversal
+      module_function
+
+      def each(node)
+        return enum_for(__method__, node) unless block_given?
+        return unless node
+
+        stack = [node]
+        until stack.empty?
+          current = stack.pop
+          yield current
+          stack.concat(child_nodes(current).reverse)
+        end
+      end
+
+      def depth_exceeds?(node, maximum)
+        return false unless node
+
+        stack = [[node, 1]]
+        until stack.empty?
+          current, depth = stack.pop
+          return true if depth > maximum
+
+          child_nodes(current).reverse_each { |child| stack << [child, depth + 1] }
+        end
+        false
+      end
+
+      def child_nodes(node)
+        return node.compact_child_nodes if node.respond_to?(:compact_child_nodes)
+
+        Array(node.child_nodes).compact
+      end
+      private_class_method :child_nodes
+    end
+  end
+end

data/lib/rlsl/prism/parameter_list.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module RLSL
+  module Prism
+    module ParameterList
+      module_function
+
+      def required_names(parameter_container)
+        parameters = unwrap(parameter_container)
+        return [] unless parameters
+
+        unsupported = children(parameters).reject { |parameter| parameter.is_a?(::Prism::RequiredParameterNode) }
+        unless unsupported.empty?
+          raise UnsupportedSyntaxError, "Only required positional parameters are supported"
+        end
+
+        parameters.requireds.map(&:name)
+      end
+
+      def names(parameter_container)
+        parameters = unwrap(parameter_container)
+        return [] unless parameters
+
+        children(parameters).filter_map { |parameter| parameter.name if parameter.respond_to?(:name) }
+      end
+
+      def unwrap(container)
+        return container.parameters if container.respond_to?(:parameters)
+
+        container
+      end
+      private_class_method :unwrap
+
+      def children(parameters)
+        if parameters.respond_to?(:compact_child_nodes)
+          parameters.compact_child_nodes
+        else
+          Array(parameters.child_nodes).compact
+        end
+      end
+      private_class_method :children
+    end
+  end
+end

data/lib/rlsl/prism/return_flow_validator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "ir/traversal"
+
+module RLSL
+  module Prism
+    class ReturnFlowError < RLSL::Error; end
+
+    class ReturnFlowValidator
+      VALUE_NODES = [
+        IR::VarDecl,
+        IR::Assignment,
+        IR::VarRef,
+        IR::Literal,
+        IR::BoolLiteral,
+        IR::BinaryOp,
+        IR::UnaryOp,
+        IR::FuncCall,
+        IR::FieldAccess,
+        IR::Swizzle,
+        IR::Ternary,
+        IR::Constant,
+        IR::Parenthesized,
+        IR::ArrayIndex
+      ].freeze
+
+      def validate!(node, needs_return:)
+        validate_functions!(node)
+        validate_returning_block!(node, "shader fragment") if needs_return
+        node
+      end
+
+      private
+
+      def validate_functions!(node)
+        IR::Traversal.each(node) do |current|
+          next unless current.is_a?(IR::FunctionDefinition)
+
+          validate_returning_block!(
+            current.body,
+            "function #{current.name}",
+            tuple_return: current.return_type.is_a?(Array)
+          )
+        end
+      end
+
+      def validate_returning_block!(node, context, tuple_return: false)
+        return if returns_value_on_all_paths?(node, tuple_return: tuple_return)
+
+        raise ReturnFlowError.new(
+          "#{context} does not return a value on every path"
+        ).with_source_location(node.location)
+      end
+
+      def returns_value_on_all_paths?(node, tuple_return: false)
+        case node
+        when IR::Block
+          returns_value_on_all_paths?(node.statements.last, tuple_return: tuple_return)
+        when IR::Return
+          !node.expression.nil? && (tuple_return || !node.expression.is_a?(IR::ArrayLiteral))
+        when IR::IfStatement
+          node.else_branch &&
+            returns_value_on_all_paths?(node.then_branch, tuple_return: tuple_return) &&
+            returns_value_on_all_paths?(node.else_branch, tuple_return: tuple_return)
+        when IR::ArrayLiteral
+          tuple_return
+        else
+          VALUE_NODES.any? { |klass| node.is_a?(klass) }
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../node_traversal"
+require_relative "../parameter_list"
+
 module RLSL
   module Prism
     class SourceExtractor
@@ -8,43 +11,38 @@ module RLSL
           extract_unit(source, start_line).to_source
         end
 
-        def extract_unit(source, start_line)
+        def extract_unit(source, start_line, parameters: nil, source_name: "(shader block)")
           parsed = ::Prism.parse(source)
           raise SourceNotAvailable, "Unable to parse block source" unless parsed.success?
 
-          block = block_at_line(parsed.value, start_line)
+          block = block_at_line(parsed.value, start_line, parameters)
           raise SourceNotAvailable, "Unable to locate block source" unless block
 
-          SourceUnit.from_block(block)
+          SourceUnit.from_block(block, source_name: source_name)
         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
+        def block_at_line(node, start_line, parameters)
+          candidates = NodeTraversal.each(node).select do |current|
+            current.is_a?(::Prism::BlockNode) && current.location.start_line == start_line
           end
+          candidates.select! { |candidate| parameter_names(candidate) == required_parameter_names(parameters) } if parameters
 
-          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)
+          if candidates.length > 1
+            raise SourceNotAvailable,
+                  "Multiple shader blocks start on line #{start_line}; put each block on its own line"
           end
+
+          candidates.first
+        end
+
+        def parameter_names(block)
+          ParameterList.names(block.parameters)
+        end
+
+        def required_parameter_names(parameters)
+          Array(parameters).filter_map { |_kind, name| name }
         end
       end
     end

data/lib/rlsl/prism/source_extractor.rb

@@ -8,7 +8,7 @@ require_relative "source_extractor/block_locator"
 module RLSL
   module Prism
     class SourceExtractor
-      class SourceNotAvailable < StandardError; end
+      class SourceNotAvailable < RLSL::Error; end
 
       def initialize(block_locator = BlockLocator.new)
         @block_locator = block_locator
@@ -22,11 +22,12 @@ module RLSL
         file, line_num = block.source_location
         raise SourceNotAvailable, "Block source location not available" unless file && File.exist?(file)
 
-        @block_locator.extract_unit(File.read(file), line_num)
-      end
-
-      def extract_from_string(source)
-        source
+        @block_locator.extract_unit(
+          File.read(file),
+          line_num,
+          parameters: block.parameters,
+          source_name: file
+        )
       end
     end
   end