rlsl 1.0.0 → 1.0.1

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

@@ -2,23 +2,33 @@
 
 require "prism"
 
+require_relative "../node_traversal"
+require_relative "../parameter_list"
+
 module RLSL
   module Prism
     class SourceUnitParser
-      def initialize(source)
+      def initialize(source, source_name: "(shader source)")
         @source = source.to_s
+        @source_name = source_name
       end
 
       def parse
-        normalized = @source.strip
-        return SourceUnit.new(params: [], body: "") if normalized.empty?
+        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 = split_sections(normalized)
-        validate_body!(body_source)
+        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: body_source.strip
+          body: stripped_body,
+          source_name: @source_name,
+          line_offset: line_offset
         )
       end
 
@@ -27,51 +37,51 @@ module RLSL
       def split_sections(source)
         lines = source.lines
         first_line = lines.first&.strip
-        return [nil, source] unless parameter_line?(first_line)
+        return [nil, source, 0] unless parameter_line?(first_line)
 
-        [first_line, lines[1..].to_a.join]
+        [first_line, lines[1..].to_a.join, 1]
       end
 
       def parameter_line?(line)
-        line&.start_with?("|") && line&.end_with?("|")
+        line&.start_with?("|") && line.end_with?("|")
       end
 
-      def validate_body!(body_source)
+      def validate_body!(body_source, line_offset)
         return if body_source.to_s.strip.empty?
 
         parsed = ::Prism.parse(body_source)
-        raise ArgumentError, "Unable to parse source unit body" unless parsed.success?
+        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 ArgumentError, "Unable to parse source unit params" unless parsed.success?
+        raise RLSL::ParseError, "Unable to parse source unit params" unless parsed.success?
 
-        block = each_node(parsed.value).find { |node| node.is_a?(::Prism::BlockNode) }
-        return [] unless block&.parameters
+        block = NodeTraversal.each(parsed.value).find { |node| node.is_a?(::Prism::BlockNode) }
+        return [] unless block
 
-        block.parameters.parameters.requireds.map(&:name)
+        ParameterList.required_names(block.parameters)
       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)
-        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

data/lib/rlsl/prism/source_unit.rb

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 
 require_relative "source_unit/parser"
+require_relative "parameter_list"
 
 module RLSL
   module Prism
-    SourceUnit = Struct.new(:params, :body, keyword_init: true) do
+    SourceUnit = Struct.new(:params, :body, :source_name, :line_offset, keyword_init: true) do
       class << self
-        def from_source(source)
-          SourceUnitParser.new(source).parse
+        def from_source(source, source_name: "(shader source)")
+          SourceUnitParser.new(source, source_name: source_name).parse
         end
 
-        def from_block(block)
+        def from_block(block, source_name: "(shader block)")
           new(
             params: extract_params(block),
-            body: block.body&.slice.to_s.strip
+            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)
-          return [] unless block.parameters
-
-          parameters = block.parameters.parameters
-          parameters.requireds.map(&:name)
+          ParameterList.required_names(block.parameters)
         end
       end
 
       def without_params
-        self.class.new(params: [], body: body)
+        self.class.new(params: [], body: body, source_name: source_name, line_offset: line_offset)
       end
 
       def to_source

data/lib/rlsl/prism/target_capability_validator.rb

@@ -6,14 +6,19 @@ require_relative "type_inference/type_shapes"
 
 module RLSL
   module Prism
-    class TargetCapabilityError < StandardError; end
+    class TargetCapabilityError < RLSL::Error; end
 
     class TargetCapabilityValidator
       include TypeShapes
 
       def validate!(node, target)
         @target = target.to_sym
-        IR::Traversal.each(node) { |current| validate_node!(current) }
+        IR::Traversal.each(node) do |current|
+          validate_node!(current)
+        rescue RLSL::Error => error
+          error.with_source_location(current.location)
+          raise
+        end
         node
       end
 
@@ -49,6 +54,26 @@ module RLSL
         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:)

data/lib/rlsl/prism/transpiler.rb

@@ -10,6 +10,8 @@ require_relative "builtins"
 require_relative "ast_visitor"
 require_relative "type_inference"
 require_relative "target_capability_validator"
+require_relative "mutation_analyzer"
+require_relative "return_flow_validator"
 require_relative "emitters/base_emitter"
 require_relative "emitters/target_emitter"
 require_relative "emitters/c_emitter"
@@ -51,9 +53,17 @@ module RLSL
         )
       end
 
+      def compile_helpers_source(source, function_signatures = {})
+        compile_unit(
+          source_unit(source).without_params,
+          function_signatures: function_signatures
+        )
+      end
+
       def emit(target, compilation:, needs_return: true)
         emitter = resolve_emitter(target)
         validate_target_capabilities!(compilation.ir, target)
+        ReturnFlowValidator.new.validate!(compilation.ir, needs_return: needs_return)
         emitter.emit(compilation.ir, needs_return: needs_return)
       end
 
@@ -73,20 +83,36 @@ module RLSL
         )
       end
 
+      def transpile_helpers_source(source, target, function_signatures = {})
+        emit(
+          target,
+          needs_return: false,
+          compilation: compile_helpers_source(source, function_signatures)
+        )
+      end
+
       private
 
       def source_unit(source)
+        return source if source.is_a?(SourceUnit)
+
         SourceUnit.from_source(source)
       end
 
       def build_ir(unit)
-        visitor = ASTVisitor.new(uniforms: @uniforms, params: unit.params)
+        visitor = ASTVisitor.new(
+          uniforms: @uniforms,
+          params: unit.params,
+          source_name: unit.source_name,
+          line_offset: unit.line_offset
+        )
         visitor.parse(unit.body)
       end
 
       def compile_unit(unit, function_signatures: nil)
         ir = build_ir(unit)
         apply_function_signatures(ir, function_signatures || {})
+        MutationAnalyzer.new.analyze(ir)
         infer_ir(ir)
         CompilationUnit.new(source_unit: unit, ir: ir)
       end
@@ -104,7 +130,7 @@ module RLSL
 
       def resolve_emitter(target)
         emitter_class = TARGETS[target.to_sym]
-        raise "Unknown target: #{target}" unless emitter_class
+        raise RLSL::Error, "Unknown target: #{target}" unless emitter_class
 
         emitter_class.new
       end
@@ -120,10 +146,21 @@ module RLSL
           next unless stmt.is_a?(IR::FunctionDefinition)
 
           sig = signatures[stmt.name]
-          next unless sig
+          unless sig
+            raise SignatureError.new(
+              "Function #{stmt.name} requires an explicit signature in functions"
+            ).with_source_location(stmt.location)
+          end
 
           stmt.return_type = sig[:returns]
           stmt.param_types = sig[:params] || {}
+          unless stmt.params == stmt.param_types.keys
+            error = SignatureError.new(
+              "Function #{stmt.name} parameters #{stmt.params.inspect} " \
+              "do not match signature #{stmt.param_types.keys.inspect}"
+            )
+            raise error.with_source_location(stmt.location)
+          end
         end
       end
     end

data/lib/rlsl/prism/type_inference/call_type_resolver.rb

@@ -15,21 +15,45 @@ module RLSL
         custom_function = @custom_functions[node.name.to_sym]
         return resolve_custom(node, custom_function) if custom_function
 
-        node.receiver&.type
+        raise SignatureError, "Unknown shader function #{node.name}"
       end
 
       private
 
       def resolve_builtin(node, signature)
-        arg_types = node.args.map(&:type)
+        arg_types = effective_arg_types(node)
         @call_validator.validate_builtin!(node, arg_types, signature)
-        Builtins.resolve_return_type(signature[:returns], arg_types)
+        return_type = Builtins.resolve_return_type(signature[:returns], arg_types)
+        unless return_type
+          raise SignatureError, "Incompatible argument types for #{node.name}: #{arg_types.join(', ')}"
+        end
+
+        node.expected_arg_types = expected_builtin_types(signature, arg_types.length, return_type)
+        return_type
       end
 
       def resolve_custom(node, signature)
-        @call_validator.validate_custom!(node.name, node.args.map(&:type), signature)
+        @call_validator.validate_custom!(node.name, effective_arg_types(node), signature)
+        node.expected_arg_types = signature[:params]&.values || []
         signature[:returns]
       end
+
+      def effective_arg_types(node)
+        types = node.args.map(&:type)
+        node.receiver ? [node.receiver.type, *types] : types
+      end
+
+      def expected_builtin_types(signature, argument_count, return_type)
+        expected = signature[:args].first(argument_count)
+        case signature[:returns]
+        when :common, :floating
+          expected.map { |type| type == :any ? return_type : type }
+        when :interpolated
+          expected.each_with_index.map { |type, index| index < 2 && type == :any ? return_type : type }
+        else
+          expected
+        end
+      end
     end
   end
 end

data/lib/rlsl/prism/type_inference/call_validator.rb

@@ -15,7 +15,11 @@ module RLSL
 
       def validate_custom!(name, arg_types, signature)
         params = signature[:params]
-        return unless params
+        unless params
+          return if arg_types.empty?
+
+          raise SignatureError, "Function #{name} requires explicit parameter types"
+        end
 
         validate_signature!(name, arg_types, params.values)
       end

data/lib/rlsl/prism/type_inference/collection_type_resolver.rb

@@ -12,8 +12,13 @@ module RLSL
       end
 
       def resolve_array_literal(node)
-        element_type = node.elements.first&.type || :float
-        TypeShapes.array(element_type)
+        element_types = node.elements.map(&:type)
+        element_type = element_types.empty? ? :float : Builtins.common_type(element_types)
+        unless element_type
+          raise SignatureError, "Array elements have incompatible types: #{element_types.uniq.join(', ')}"
+        end
+
+        TypeShapes.array(element_type, node.elements.length)
       end
 
       def resolve_array_index(node)
@@ -27,9 +32,8 @@ module RLSL
       def resolve_global_decl(node)
         if node.initializer.is_a?(IR::ArrayLiteral)
           node.array_size ||= node.initializer.elements.length
-          first_elem = node.initializer.elements.first
-          node.element_type ||= first_elem&.type || :float
-          return TypeShapes.array(node.element_type)
+          node.element_type ||= TypeShapes.element_type(node.initializer.type)
+          return TypeShapes.array(node.element_type, node.array_size)
         end
 
         node.initializer&.type
@@ -37,41 +41,63 @@ module RLSL
 
       def assign_multiple_targets(node)
         value_type = node.value.type
-        return assign_tuple_targets(node.targets, value_type.types) if value_type.is_a?(IR::TupleType)
-        return assign_array_targets(node.targets, TypeShapes.element_type(value_type)) if TypeShapes.array?(value_type)
-        return assign_custom_targets(node.targets, @custom_functions[node.value.name]) if custom_multi_return?(node.value)
+        return assign_tuple_targets(node, node.value.elements.map(&:type)) if node.value.is_a?(IR::ArrayLiteral)
+        return assign_tuple_targets(node, value_type.types) if value_type.is_a?(IR::TupleType)
+        return assign_array_targets(node, TypeShapes.element_type(value_type)) if TypeShapes.array?(value_type)
+        return assign_custom_targets(node, @custom_functions[node.value.name]) if custom_multi_return?(node.value)
 
         nil
       end
 
       private
 
-      def assign_tuple_targets(targets, types)
-        targets.each_with_index do |target, index|
-          assign_target(target, types[index])
+      def assign_tuple_targets(node, types)
+        validate_target_count!(node.targets, types.length)
+        node.targets.each_with_index do |target, index|
+          assign_target(node, target, index, types[index])
         end
       end
 
-      def assign_array_targets(targets, type)
-        targets.each do |target|
-          assign_target(target, type)
+      def assign_array_targets(node, type)
+        count = node.value.type.element_count
+        validate_target_count!(node.targets, count) if count
+        node.targets.each_with_index do |target, index|
+          assign_target(node, target, index, type)
         end
       end
 
-      def assign_custom_targets(targets, signature)
+      def assign_custom_targets(node, signature)
         returns = signature[:returns]
         return unless returns.is_a?(Array)
 
-        targets.each_with_index do |target, index|
-          assign_target(target, returns[index])
-        end
+        assign_tuple_targets(node, returns)
       end
 
-      def assign_target(target, type)
+      def assign_target(node, target, index, type)
+        unless node.declarations[index]
+          existing_type = @type_environment.lookup(target.name)
+          unless compatible_assignment?(existing_type, type)
+            raise SignatureError, "Cannot assign #{type} to #{target.name} (#{existing_type})"
+          end
+
+          target.type = existing_type
+          return
+        end
+
         target.type = type
         @register.call(target.name, type)
       end
 
+      def validate_target_count!(targets, value_count)
+        return if targets.length == value_count
+
+        raise SignatureError, "Multiple assignment has #{targets.length} targets for #{value_count} values"
+      end
+
+      def compatible_assignment?(target_type, value_type)
+        target_type == value_type || (target_type == :float && value_type == :int)
+      end
+
       def custom_multi_return?(value)
         value.is_a?(IR::FuncCall) && @custom_functions.key?(value.name)
       end

data/lib/rlsl/prism/type_inference/control_flow_inferer.rb

@@ -3,18 +3,27 @@
 module RLSL
   module Prism
     class ControlFlowInferer
-      def initialize(infer:, infer_child_scope:, infer_in_scope:)
+      def initialize(infer:, infer_in_scope:, lookup:)
         @infer = infer
-        @infer_child_scope = infer_child_scope
         @infer_in_scope = infer_in_scope
+        @lookup = lookup
       end
 
       def infer_if_statement(node)
         @infer.call(node.condition)
-        @infer_child_scope.call(node.then_branch)
-        @infer_child_scope.call(node.else_branch) if node.else_branch
+        if node.hoisted_variables.empty?
+          @infer.call(node.then_branch, scoped: true)
+          @infer.call(node.else_branch, scoped: true) if node.else_branch
+        else
+          @infer.call(node.then_branch)
+          @infer.call(node.else_branch) if node.else_branch
+        end
+
+        node.hoisted_variables.each_key do |name|
+          node.hoisted_variables[name] = @lookup.call(name)
+        end
 
-        node.type = node.then_branch.type
+        node.type = node.then_branch&.type
         node
       end
 
@@ -22,7 +31,11 @@ module RLSL
         @infer.call(node.condition)
         @infer.call(node.then_expr)
         @infer.call(node.else_expr)
-        node.type = node.then_expr.type
+        node.type = Builtins.common_type([node.then_expr.type, node.else_expr.type])
+        unless node.type
+          raise SignatureError,
+                "Conditional branches have incompatible types: #{node.then_expr.type} and #{node.else_expr.type}"
+        end
         node
       end
 
@@ -35,6 +48,10 @@ module RLSL
       def infer_for_loop(node)
         @infer.call(node.range_start)
         @infer.call(node.range_end)
+        unless node.range_start.type == :int && node.range_end.type == :int
+          raise SignatureError,
+                "Loop bounds must be integers, got #{node.range_start.type.inspect} and #{node.range_end.type.inspect}"
+        end
 
         @infer_in_scope.call(node.variable => :int) do
           @infer.call(node.body)
@@ -46,7 +63,7 @@ module RLSL
 
       def infer_while_loop(node)
         @infer.call(node.condition)
-        @infer_child_scope.call(node.body)
+        @infer.call(node.body, scoped: true)
         node.type = nil
         node
       end
@@ -56,11 +73,75 @@ module RLSL
           @infer.call(node.body)
 
           node.return_type ||= node.body&.type
+          validate_return_types!(node) if node.return_type
           node.type = node.return_type
         end
 
         node
       end
+
+      private
+
+      def validate_return_types!(function)
+        expressions = explicit_return_expressions(function.body)
+        expressions.concat(terminal_expressions(function.body))
+        expressions.uniq.each do |expression|
+          next if compatible_return?(function.return_type, expression)
+
+          raise SignatureError,
+                "Function #{function.name} returns #{return_type_of(expression).inspect}, expected #{function.return_type.inspect}"
+        end
+      end
+
+      def explicit_return_expressions(node)
+        case node
+        when IR::Block
+          node.statements.flat_map { |statement| explicit_return_expressions(statement) }
+        when IR::IfStatement
+          explicit_return_expressions(node.then_branch) + explicit_return_expressions(node.else_branch)
+        when IR::ForLoop, IR::WhileLoop
+          explicit_return_expressions(node.body)
+        when IR::Return
+          node.expression ? [node.expression] : []
+        else
+          []
+        end
+      end
+
+      def terminal_expressions(node)
+        case node
+        when IR::Block
+          terminal_expressions(node.statements.last)
+        when IR::IfStatement
+          terminal_expressions(node.then_branch) + terminal_expressions(node.else_branch)
+        when IR::Return, nil
+          []
+        else
+          node.type ? [node] : []
+        end
+      end
+
+      def compatible_return?(expected, expression)
+        if expected.is_a?(Array)
+          actual = return_type_of(expression)
+          return false unless actual.is_a?(Array) && actual.length == expected.length
+
+          return expected.zip(actual).all? { |expected_type, actual_type| compatible_type?(expected_type, actual_type) }
+        end
+
+        compatible_type?(expected, expression.type)
+      end
+
+      def return_type_of(expression)
+        return expression.elements.map(&:type) if expression.is_a?(IR::ArrayLiteral)
+        return expression.type.types if expression.type.is_a?(IR::TupleType)
+
+        expression.type
+      end
+
+      def compatible_type?(expected, actual)
+        expected == actual || (expected == :float && actual == :int)
+      end
     end
   end
 end

data/lib/rlsl/prism/type_inference/definition_inferer.rb

@@ -3,8 +3,9 @@
 module RLSL
   module Prism
     class DefinitionInferer
-      def initialize(infer:, register:, collection_type_resolver:)
+      def initialize(infer:, lookup:, register:, collection_type_resolver:)
         @infer = infer
+        @lookup = lookup
         @register = register
         @collection_type_resolver = collection_type_resolver
       end
@@ -19,6 +20,14 @@ module RLSL
       def infer_assignment(node)
         @infer.call(node.target)
         @infer.call(node.value)
+        existing_type = node.target.is_a?(IR::VarRef) ? @lookup.call(node.target.name) : node.target.type
+        if existing_type && node.value.type && !compatible_assignment?(existing_type, node.value.type)
+          raise SignatureError,
+                "Cannot assign #{node.value.type} to #{node.target.name} (#{existing_type})"
+        end
+
+        node.target.type ||= node.value.type
+        @register.call(node.target.name, node.value.type) if node.target.is_a?(IR::VarRef) && !existing_type
         node.type = node.value.type
         node
       end
@@ -36,6 +45,12 @@ module RLSL
         node.type = nil
         node
       end
+
+      private
+
+      def compatible_assignment?(target_type, value_type)
+        target_type == value_type || (target_type == :float && value_type == :int)
+      end
     end
   end
 end

data/lib/rlsl/prism/type_inference/expression_inferer.rb

@@ -65,6 +65,10 @@ module RLSL
 
       def infer_swizzle(node)
         @infer.call(node.receiver)
+        unless Builtins.valid_swizzle_for_type?(node.components, node.receiver.type)
+          raise SignatureError, "Invalid swizzle #{node.components.inspect} for #{node.receiver.type || :unknown}"
+        end
+
         node.type = Builtins.swizzle_type(node.components)
         node
       end