rlsl 0.1.1 → 1.0.1

data/lib/rlsl/prism/transpiler.rb

@@ -3,11 +3,17 @@
 require "prism"
 
 require_relative "ir/nodes"
+require_relative "compilation_unit"
+require_relative "source_unit"
 require_relative "source_extractor"
 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"
 require_relative "emitters/msl_emitter"
 require_relative "emitters/wgsl_emitter"
@@ -23,70 +29,115 @@ module RLSL
         glsl: Emitters::GLSLEmitter
       }.freeze
 
-      attr_reader :ir, :uniforms, :custom_functions
+      attr_reader :uniforms, :custom_functions
 
-      def initialize(uniforms = {}, custom_functions = {})
+      def initialize(uniforms = {}, custom_functions = {}, globals: {})
         @uniforms = uniforms
         @custom_functions = custom_functions
+        @globals = globals
         @source_extractor = SourceExtractor.new
-        @ir = nil
       end
 
-      def parse_block(block)
-        source = @source_extractor.extract(block)
-        parse_source(source)
+      def compile_block(block)
+        compile_unit(@source_extractor.extract_unit(block))
       end
 
-      def parse_source(source)
-        params, body = extract_block_body(source)
-
-        visitor = ASTVisitor.new(uniforms: @uniforms, params: params)
-        @ir = visitor.parse(body)
-
-        inference = TypeInference.new(@uniforms, @custom_functions)
-        inference.register(:frag_coord, :vec2)
-        inference.register(:resolution, :vec2)
-        inference.infer(@ir)
-
-        @ir
+      def compile_source(source)
+        compile_unit(source_unit(source))
       end
 
-      def emit(target, needs_return: true)
-        raise "No IR parsed yet. Call parse_block or parse_source first." unless @ir
+      def compile_helpers(block, function_signatures = {})
+        compile_unit(
+          @source_extractor.extract_unit(block).without_params,
+          function_signatures: function_signatures
+        )
+      end
 
-        emitter_class = TARGETS[target.to_sym]
-        raise "Unknown target: #{target}" unless emitter_class
+      def compile_helpers_source(source, function_signatures = {})
+        compile_unit(
+          source_unit(source).without_params,
+          function_signatures: function_signatures
+        )
+      end
 
-        emitter = emitter_class.new
-        emitter.emit(@ir, needs_return: needs_return)
+      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
 
       def transpile(block, target)
-        parse_block(block)
-        emit(target)
+        emit(target, compilation: compile_block(block))
       end
 
       def transpile_source(source, target)
-        parse_source(source)
-        emit(target)
+        emit(target, compilation: compile_source(source))
       end
 
       def transpile_helpers(block, target, function_signatures = {})
-        source = @source_extractor.extract(block)
-        _, body = extract_block_body(source)
+        emit(
+          target,
+          needs_return: false,
+          compilation: compile_helpers(block, function_signatures)
+        )
+      end
 
-        visitor = ASTVisitor.new(uniforms: @uniforms)
-        @ir = visitor.parse(body)
+      def transpile_helpers_source(source, target, function_signatures = {})
+        emit(
+          target,
+          needs_return: false,
+          compilation: compile_helpers_source(source, function_signatures)
+        )
+      end
 
-        apply_function_signatures(@ir, function_signatures)
+      private
 
-        inference = TypeInference.new(@uniforms, @custom_functions)
-        inference.infer(@ir)
+      def source_unit(source)
+        return source if source.is_a?(SourceUnit)
 
-        emit(target, needs_return: false)
+        SourceUnit.from_source(source)
       end
 
-      private
+      def build_ir(unit)
+        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
+
+      def infer_ir(ir)
+        inference = TypeInference.new(@uniforms, @custom_functions, globals: @globals)
+        register_pipeline_symbols(inference)
+        inference.infer(ir)
+      end
+
+      def register_pipeline_symbols(inference)
+        inference.register(:frag_coord, :vec2)
+        inference.register(:resolution, :vec2)
+      end
+
+      def resolve_emitter(target)
+        emitter_class = TARGETS[target.to_sym]
+        raise RLSL::Error, "Unknown target: #{target}" unless emitter_class
+
+        emitter_class.new
+      end
+
+      def validate_target_capabilities!(ir, target)
+        TargetCapabilityValidator.new.validate!(ir, target)
+      end
 
       def apply_function_signatures(ir, signatures)
         return unless ir.is_a?(IR::Block)
@@ -95,33 +146,22 @@ 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] || {}
-        end
-      end
-
-      def extract_block_body(source)
-        lines = source.strip.lines
-        params = []
-
-        first_line = lines.first&.strip || ""
-
-        if first_line.start_with?("|")
-          param_end = first_line.index("|", 1)
-          if param_end
-            param_str = first_line[1...param_end]
-            params = param_str.split(",").map { |p| p.strip.to_sym }
-            lines[0] = first_line[(param_end + 1)..]
+          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
-
-        lines.shift while lines.first&.strip&.empty?
-        lines.pop while lines.last&.strip&.empty?
-
-        body = lines.join.strip
-        [params, body]
       end
     end
   end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class CallTypeResolver
+      def initialize(custom_functions:, call_validator:)
+        @custom_functions = custom_functions
+        @call_validator = call_validator
+      end
+
+      def resolve(node)
+        sig = Builtins.function_signature(node.name)
+        return resolve_builtin(node, sig) if sig
+
+        custom_function = @custom_functions[node.name.to_sym]
+        return resolve_custom(node, custom_function) if custom_function
+
+        raise SignatureError, "Unknown shader function #{node.name}"
+      end
+
+      private
+
+      def resolve_builtin(node, signature)
+        arg_types = effective_arg_types(node)
+        @call_validator.validate_builtin!(node, arg_types, signature)
+        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, 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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class CallValidator
+      def validate_builtin!(node, arg_types, signature)
+        validate_signature!(
+          node.name,
+          arg_types,
+          signature[:args],
+          variadic: signature[:variadic],
+          min_args: signature[:min_args]
+        ) unless skip_builtin_validation?(node, signature)
+      end
+
+      def validate_custom!(name, arg_types, signature)
+        params = signature[: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
+
+      private
+
+      def validate_signature!(name, arg_types, expected_types, variadic: false, min_args: nil)
+        validate_argument_count!(name, arg_types.length, expected_types.length, variadic: variadic, min_args: min_args)
+
+        arg_types.each_with_index do |actual_type, index|
+          expected_type = expected_types[index]
+          next if compatible_argument_type?(expected_type, actual_type)
+
+          raise SignatureError,
+                "Invalid argument #{index + 1} for #{name}: expected #{expected_type}, got #{actual_type || :unknown}"
+        end
+      end
+
+      def validate_argument_count!(name, actual_count, expected_count, variadic:, min_args:)
+        return if valid_argument_count?(actual_count, expected_count, variadic: variadic, min_args: min_args)
+
+        raise SignatureError,
+              "Wrong number of arguments for #{name}: expected #{expected_count_description(expected_count, variadic, min_args)}, got #{actual_count}"
+      end
+
+      def valid_argument_count?(actual_count, expected_count, variadic:, min_args:)
+        return actual_count == expected_count unless variadic
+
+        minimum = min_args || expected_count
+        actual_count.between?(minimum, expected_count)
+      end
+
+      def expected_count_description(expected_count, variadic, min_args)
+        return expected_count.to_s unless variadic
+
+        minimum = min_args || expected_count
+        minimum == expected_count ? minimum.to_s : "#{minimum}..#{expected_count}"
+      end
+
+      def compatible_argument_type?(expected_type, actual_type)
+        return true if expected_type == :any
+        return true if expected_type == actual_type
+        return true if expected_type == :float && actual_type == :int
+
+        false
+      end
+
+      def skip_builtin_validation?(node, signature)
+        signature[:variadic] && node.args.empty? && !node.type.nil?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class CollectionTypeResolver
+      include TypeShapes
+
+      def initialize(type_environment:, custom_functions:, register:)
+        @type_environment = type_environment
+        @custom_functions = custom_functions
+        @register = register
+      end
+
+      def resolve_array_literal(node)
+        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)
+        array_type = node.array.type
+        return TypeShapes.element_type(array_type) if TypeShapes.array?(array_type)
+        return @type_environment.array_element_type(node.array.name) || :float if node.array.is_a?(IR::VarRef)
+
+        :float
+      end
+
+      def resolve_global_decl(node)
+        if node.initializer.is_a?(IR::ArrayLiteral)
+          node.array_size ||= node.initializer.elements.length
+          node.element_type ||= TypeShapes.element_type(node.initializer.type)
+          return TypeShapes.array(node.element_type, node.array_size)
+        end
+
+        node.initializer&.type
+      end
+
+      def assign_multiple_targets(node)
+        value_type = node.value.type
+        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(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(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(node, signature)
+        returns = signature[:returns]
+        return unless returns.is_a?(Array)
+
+        assign_tuple_targets(node, returns)
+      end
+
+      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
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ControlFlowInferer
+      def initialize(infer:, infer_in_scope:, lookup:)
+        @infer = infer
+        @infer_in_scope = infer_in_scope
+        @lookup = lookup
+      end
+
+      def infer_if_statement(node)
+        @infer.call(node.condition)
+        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
+      end
+
+      def infer_ternary(node)
+        @infer.call(node.condition)
+        @infer.call(node.then_expr)
+        @infer.call(node.else_expr)
+        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
+
+      def infer_return(node)
+        @infer.call(node.expression) if node.expression
+        node.type = node.expression&.type
+        node
+      end
+
+      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)
+        end
+
+        node.type = nil
+        node
+      end
+
+      def infer_while_loop(node)
+        @infer.call(node.condition)
+        @infer.call(node.body, scoped: true)
+        node.type = nil
+        node
+      end
+
+      def infer_function_definition(node)
+        @infer_in_scope.call(node.param_types) do
+          @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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class DefinitionInferer
+      def initialize(infer:, lookup:, register:, collection_type_resolver:)
+        @infer = infer
+        @lookup = lookup
+        @register = register
+        @collection_type_resolver = collection_type_resolver
+      end
+
+      def infer_var_decl(node)
+        @infer.call(node.initializer) if node.initializer
+        node.type ||= node.initializer&.type
+        @register.call(node.name, node.type) if node.type
+        node
+      end
+
+      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
+
+      def infer_global_decl(node)
+        @infer.call(node.initializer) if node.initializer
+        node.type ||= @collection_type_resolver.resolve_global_decl(node)
+        @register.call(node.name, node.type) if node.type
+        node
+      end
+
+      def infer_multiple_assignment(node)
+        @infer.call(node.value)
+        @collection_type_resolver.assign_multiple_targets(node)
+        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