rlsl 0.1.1 → 1.0.1

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../node_traversal"
+require_relative "../parameter_list"
+
+module RLSL
+  module Prism
+    class SourceExtractor
+      class BlockLocator
+        def extract(source, start_line)
+          extract_unit(source, start_line).to_source
+        end
+
+        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, parameters)
+          raise SourceNotAvailable, "Unable to locate block source" unless block
+
+          SourceUnit.from_block(block, source_name: source_name)
+        end
+
+        private
+
+        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
+
+          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
+  end
+end

data/lib/rlsl/prism/source_extractor.rb

@@ -1,151 +1,33 @@
 # frozen_string_literal: true
 
+require "prism"
+
+require_relative "source_unit"
+require_relative "source_extractor/block_locator"
+
 module RLSL
   module Prism
     class SourceExtractor
-      class SourceNotAvailable < StandardError; end
-
-      def extract(block)
-        file, line_num = block.source_location
-        raise SourceNotAvailable, "Block source location not available" unless file && File.exist?(file)
-
-        lines = File.readlines(file)
-        extract_block_source(lines, line_num - 1)
-      end
-
-      def extract_from_string(source)
-        source
-      end
-
-      private
-
-      def extract_block_source(lines, start_line)
-        source = +""
-        depth = 0
-        in_block = false
-        block_start_found = false
-
-        lines[start_line..].each_with_index do |line, idx|
-          tokens = tokenize_for_blocks(line)
-
-          tokens.each do |token|
-            case token
-            when :do, :brace_open
-              if !block_start_found
-                block_start_found = true
-                in_block = true
-              end
-              depth += 1
-            when :block_start
-              depth += 1
-            when :end, :brace_close
-              depth -= 1
-            end
-          end
-
-          if block_start_found
-            if idx == 0
-              source << extract_first_line(line)
-            else
-              source << line
-            end
-          end
-
-          break if in_block && depth == 0
-        end
+      class SourceNotAvailable < RLSL::Error; end
 
-        clean_block_source(source)
+      def initialize(block_locator = BlockLocator.new)
+        @block_locator = block_locator
       end
 
-      def tokenize_for_blocks(line)
-        tokens = []
-        in_string = nil
-        i = 0
-
-        while i < line.length
-          char = line[i]
-
-          if in_string
-            if char == in_string && (i == 0 || line[i - 1] != "\\")
-              in_string = nil
-            end
-            i += 1
-            next
-          end
-
-          if char == '"' || char == "'"
-            in_string = char
-            i += 1
-            next
-          end
-
-          break if char == "#"
-
-          prev_is_boundary = i == 0 || !line[i - 1].match?(/[a-zA-Z0-9_]/)
-
-          if char == "{"
-            tokens << :brace_open
-          elsif char == "}"
-            tokens << :brace_close
-          elsif prev_is_boundary && line[i..].match?(/\Ado\b/)
-            tokens << :do
-            i += 1
-          elsif prev_is_boundary && line[i..].match?(/\Aelsif\b/)
-            i += 4
-          elsif prev_is_boundary && line[i..].match?(/\Aelse\b/)
-            i += 3
-          elsif prev_is_boundary && (m = line[i..].match(/\A(if|unless|while|for|case|def|class|module)\b/))
-            tokens << :block_start
-            i += m[1].length - 1
-          elsif prev_is_boundary && line[i..].match?(/\Aend\b/)
-            tokens << :end
-            i += 2
-          end
-
-          i += 1
-        end
-
-        tokens
-      end
-
-      def extract_first_line(line)
-        if line.include?(" do")
-          match = line.match(/do\s*(\|[^|]*\|)?\s*(.*)$/)
-          if match
-            params = match[1] || ""
-            rest = match[2] || ""
-            "#{params}\n#{rest}\n"
-          else
-            "\n"
-          end
-        elsif line.include?("{")
-          match = line.match(/\{\s*(\|[^|]*\|)?\s*(.*)$/)
-          if match
-            params = match[1] || ""
-            rest = match[2] || ""
-            "#{params}\n#{rest}\n"
-          else
-            "\n"
-          end
-        else
-          line
-        end
+      def extract(block)
+        extract_unit(block).to_source
       end
 
-      def clean_block_source(source)
-        lines = source.lines
-        return "" if lines.empty?
-
-        last_line = lines.last.strip
-        if last_line == "end" || last_line == "}"
-          lines.pop
-        elsif last_line.end_with?("end") || last_line.end_with?("}")
-          lines[-1] = lines[-1].sub(/\s*(end|\})\s*$/, "\n")
-        end
-
-        lines.shift if lines.first&.strip&.empty?
+      def extract_unit(block)
+        file, line_num = block.source_location
+        raise SourceNotAvailable, "Block source location not available" unless file && File.exist?(file)
 
-        lines.join
+        @block_locator.extract_unit(
+          File.read(file),
+          line_num,
+          parameters: block.parameters,
+          source_name: file
+        )
       end
     end
   end

data/lib/rlsl/prism/source_unit/parser.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../node_traversal"
+require_relative "../parameter_list"
+
+module RLSL
+  module Prism
+    class SourceUnitParser
+      def initialize(source, source_name: "(shader source)")
+        @source = source.to_s
+        @source_name = source_name
+      end
+
+      def parse
+        normalized, leading_line_offset = strip_with_line_offset(@source)
+        if normalized.empty?
+          return SourceUnit.new(params: [], body: "", source_name: @source_name, line_offset: leading_line_offset)
+        end
+
+        params_source, body_source, parameter_line_offset = split_sections(normalized)
+        stripped_body, body_line_offset = strip_with_line_offset(body_source)
+        line_offset = leading_line_offset + parameter_line_offset + body_line_offset
+        validate_body!(stripped_body, line_offset)
+
+        SourceUnit.new(
+          params: parse_params(params_source),
+          body: stripped_body,
+          source_name: @source_name,
+          line_offset: line_offset
+        )
+      end
+
+      private
+
+      def split_sections(source)
+        lines = source.lines
+        first_line = lines.first&.strip
+        return [nil, source, 0] unless parameter_line?(first_line)
+
+        [first_line, lines[1..].to_a.join, 1]
+      end
+
+      def parameter_line?(line)
+        line&.start_with?("|") && line.end_with?("|")
+      end
+
+      def validate_body!(body_source, line_offset)
+        return if body_source.to_s.strip.empty?
+
+        parsed = ::Prism.parse(body_source)
+        return if parsed.success?
+
+        error = RLSL::ParseError.new("Unable to parse source unit body")
+        location = parsed.errors.first&.location
+        if location
+          error.with_source_location(
+            RLSL::SourceLocation.new(
+              source_name: @source_name,
+              line: line_offset + location.start_line,
+              column: location.start_column + 1
+            )
+          )
+        end
+        raise error
+      end
+
+      def parse_params(params_source)
+        return [] unless params_source
+
+        parsed = ::Prism.parse("proc do #{params_source}\nend\n")
+        raise RLSL::ParseError, "Unable to parse source unit params" unless parsed.success?
+
+        block = NodeTraversal.each(parsed.value).find { |node| node.is_a?(::Prism::BlockNode) }
+        return [] unless block
+
+        ParameterList.required_names(block.parameters)
+      end
+
+      def strip_with_line_offset(source)
+        text = source.to_s
+        leading_whitespace = text[/\A\s*/].to_s
+        [text.strip, leading_whitespace.count("\n")]
+      end
+    end
+  end
+end

data/lib/rlsl/prism/source_unit.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "source_unit/parser"
+require_relative "parameter_list"
+
+module RLSL
+  module Prism
+    SourceUnit = Struct.new(:params, :body, :source_name, :line_offset, keyword_init: true) do
+      class << self
+        def from_source(source, source_name: "(shader source)")
+          SourceUnitParser.new(source, source_name: source_name).parse
+        end
+
+        def from_block(block, source_name: "(shader block)")
+          new(
+            params: extract_params(block),
+            body: block.body&.slice.to_s.strip,
+            source_name: source_name,
+            line_offset: block.body ? block.body.location.start_line - 1 : block.location.start_line - 1
+          )
+        end
+
+        private
+
+        def extract_params(block)
+          ParameterList.required_names(block.parameters)
+        end
+      end
+
+      def without_params
+        self.class.new(params: [], body: body, source_name: source_name, line_offset: line_offset)
+      end
+
+      def to_source
+        segments = []
+        segments << "|#{params.join(', ')}|" unless params.empty?
+        segments << body unless body.empty?
+        segments.join("\n")
+      end
+    end
+  end
+end

data/lib/rlsl/prism/target_capability_validator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../types"
+require_relative "ir/traversal"
+require_relative "type_inference/type_shapes"
+
+module RLSL
+  module Prism
+    class TargetCapabilityError < RLSL::Error; end
+
+    class TargetCapabilityValidator
+      include TypeShapes
+
+      def validate!(node, target)
+        @target = target.to_sym
+        IR::Traversal.each(node) do |current|
+          validate_node!(current)
+        rescue RLSL::Error => error
+          error.with_source_location(current.location)
+          raise
+        end
+        node
+      end
+
+      private
+
+      attr_reader :target
+
+      def validate_node!(node)
+        return if node.nil?
+
+        validate_type!(node.type, context: node.class.name.split("::").last)
+
+        case node
+        when IR::FuncCall
+          validate_builtin!(node)
+        when IR::FunctionDefinition
+          validate_type!(node.return_type, context: "function #{node.name} return")
+          node.param_types.each_value do |type|
+            validate_type!(type, context: "function #{node.name} parameter")
+          end
+        when IR::GlobalDecl
+          validate_type!(node.element_type, context: "global #{node.name} element")
+        end
+      end
+
+      def validate_builtin!(node)
+        return unless Builtins.function?(node.name)
+
+        unless Builtins.supported_on_target?(node.name, target)
+          raise TargetCapabilityError, "Builtin #{node.name} is not supported on #{target.to_s.upcase}"
+        end
+
+        Builtins.explicit_types(node.name).each do |type|
+          validate_type!(type, context: "builtin #{node.name}")
+        end
+
+        validate_c_builtin_overload!(node) if target == :c
+      end
+
+      def validate_c_builtin_overload!(node)
+        vector_types = node.args.map(&:type).select { |type| Builtins.vector_type?(type) }
+        scalar_only = %i[sqrt abs sign floor ceil fract mod min max clamp step smoothstep]
+        if scalar_only.include?(node.name.to_sym) && !vector_types.empty?
+          raise TargetCapabilityError,
+                "Builtin #{node.name} does not support vector arguments on C"
+        end
+
+        if %i[length normalize dot distance].include?(node.name.to_sym) && vector_types.empty?
+          raise TargetCapabilityError, "Builtin #{node.name} requires vector arguments on C"
+        end
+
+        return unless %i[reflect refract].include?(node.name.to_sym)
+        return if node.args.first&.type == :vec3 && node.args[1]&.type == :vec3
+
+        raise TargetCapabilityError, "Builtin #{node.name} currently requires vec3 arguments on C"
+      end
+
+      def validate_type!(type, context:)
+        return if type.nil?
+
+        if TypeShapes.array?(type)
+          validate_type!(TypeShapes.element_type(type), context: "#{context} array element")
+          return
+        end
+
+        if type.is_a?(Array)
+          type.each { |element_type| validate_type!(element_type, context: "#{context} tuple element") }
+          return
+        end
+
+        if type.is_a?(IR::TupleType)
+          type.types.each { |element_type| validate_type!(element_type, context: "#{context} tuple element") }
+          return
+        end
+
+        return unless uniform_type_symbol?(type)
+
+        return if RLSL::UniformTypes.fetch(type).target_supported?(target)
+
+        raise TargetCapabilityError,
+              "Unsupported #{target.to_s.upcase} type #{type.inspect} in #{context}"
+      end
+
+      def uniform_type_symbol?(type)
+        type.is_a?(Symbol) && RLSL::UniformTypes.supported?(type)
+      end
+    end
+  end
+end