rlsl 0.1.1 → 1.0.0

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RLSL
+  module Prism
+    class SourceUnitParser
+      def initialize(source)
+        @source = source.to_s
+      end
+
+      def parse
+        normalized = @source.strip
+        return SourceUnit.new(params: [], body: "") if normalized.empty?
+
+        params_source, body_source = split_sections(normalized)
+        validate_body!(body_source)
+
+        SourceUnit.new(
+          params: parse_params(params_source),
+          body: body_source.strip
+        )
+      end
+
+      private
+
+      def split_sections(source)
+        lines = source.lines
+        first_line = lines.first&.strip
+        return [nil, source] unless parameter_line?(first_line)
+
+        [first_line, lines[1..].to_a.join]
+      end
+
+      def parameter_line?(line)
+        line&.start_with?("|") && line&.end_with?("|")
+      end
+
+      def validate_body!(body_source)
+        return if body_source.to_s.strip.empty?
+
+        parsed = ::Prism.parse(body_source)
+        raise ArgumentError, "Unable to parse source unit body" unless parsed.success?
+      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?
+
+        block = each_node(parsed.value).find { |node| node.is_a?(::Prism::BlockNode) }
+        return [] unless block&.parameters
+
+        block.parameters.parameters.requireds.map(&:name)
+      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
+      end
+    end
+  end
+end

data/lib/rlsl/prism/source_unit.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "source_unit/parser"
+
+module RLSL
+  module Prism
+    SourceUnit = Struct.new(:params, :body, keyword_init: true) do
+      class << self
+        def from_source(source)
+          SourceUnitParser.new(source).parse
+        end
+
+        def from_block(block)
+          new(
+            params: extract_params(block),
+            body: block.body&.slice.to_s.strip
+          )
+        end
+
+        private
+
+        def extract_params(block)
+          return [] unless block.parameters
+
+          parameters = block.parameters.parameters
+          parameters.requireds.map(&:name)
+        end
+      end
+
+      def without_params
+        self.class.new(params: [], body: body)
+      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,85 @@
+# frozen_string_literal: true
+
+require_relative "../types"
+require_relative "ir/traversal"
+require_relative "type_inference/type_shapes"
+
+module RLSL
+  module Prism
+    class TargetCapabilityError < StandardError; end
+
+    class TargetCapabilityValidator
+      include TypeShapes
+
+      def validate!(node, target)
+        @target = target.to_sym
+        IR::Traversal.each(node) { |current| validate_node!(current) }
+        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
+      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

data/lib/rlsl/prism/transpiler.rb

@@ -3,11 +3,15 @@
 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 "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 +27,91 @@ 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
-
-        emitter_class = TARGETS[target.to_sym]
-        raise "Unknown target: #{target}" unless emitter_class
+      def compile_helpers(block, function_signatures = {})
+        compile_unit(
+          @source_extractor.extract_unit(block).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)
+        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)
+      private
 
-        apply_function_signatures(@ir, function_signatures)
+      def source_unit(source)
+        SourceUnit.from_source(source)
+      end
 
-        inference = TypeInference.new(@uniforms, @custom_functions)
-        inference.infer(@ir)
+      def build_ir(unit)
+        visitor = ASTVisitor.new(uniforms: @uniforms, params: unit.params)
+        visitor.parse(unit.body)
+      end
 
-        emit(target, needs_return: false)
+      def compile_unit(unit, function_signatures: nil)
+        ir = build_ir(unit)
+        apply_function_signatures(ir, function_signatures || {})
+        infer_ir(ir)
+        CompilationUnit.new(source_unit: unit, ir: ir)
       end
 
-      private
+      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 "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)
@@ -101,28 +126,6 @@ module RLSL
           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)..]
-          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
 end

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

@@ -0,0 +1,35 @@
+# 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
+
+        node.receiver&.type
+      end
+
+      private
+
+      def resolve_builtin(node, signature)
+        arg_types = node.args.map(&:type)
+        @call_validator.validate_builtin!(node, arg_types, signature)
+        Builtins.resolve_return_type(signature[:returns], arg_types)
+      end
+
+      def resolve_custom(node, signature)
+        @call_validator.validate_custom!(node.name, node.args.map(&:type), signature)
+        signature[:returns]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# 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]
+        return unless params
+
+        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,80 @@
+# 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_type = node.elements.first&.type || :float
+        TypeShapes.array(element_type)
+      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
+          first_elem = node.initializer.elements.first
+          node.element_type ||= first_elem&.type || :float
+          return TypeShapes.array(node.element_type)
+        end
+
+        node.initializer&.type
+      end
+
+      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)
+
+        nil
+      end
+
+      private
+
+      def assign_tuple_targets(targets, types)
+        targets.each_with_index do |target, index|
+          assign_target(target, types[index])
+        end
+      end
+
+      def assign_array_targets(targets, type)
+        targets.each do |target|
+          assign_target(target, type)
+        end
+      end
+
+      def assign_custom_targets(targets, signature)
+        returns = signature[:returns]
+        return unless returns.is_a?(Array)
+
+        targets.each_with_index do |target, index|
+          assign_target(target, returns[index])
+        end
+      end
+
+      def assign_target(target, type)
+        target.type = type
+        @register.call(target.name, type)
+      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,66 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ControlFlowInferer
+      def initialize(infer:, infer_child_scope:, infer_in_scope:)
+        @infer = infer
+        @infer_child_scope = infer_child_scope
+        @infer_in_scope = infer_in_scope
+      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
+
+        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 = node.then_expr.type
+        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)
+
+        @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_child_scope.call(node.body)
+        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
+          node.type = node.return_type
+        end
+
+        node
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class DefinitionInferer
+      def initialize(infer:, register:, collection_type_resolver:)
+        @infer = infer
+        @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)
+        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
+    end
+  end
+end