rlsl 0.1.1 → 1.0.1

data/lib/rlsl/prism/type_inference.rb

@@ -1,288 +1,159 @@
 # frozen_string_literal: true
 
+require_relative "type_inference/scope_stack"
+require_relative "type_inference/type_shapes"
+require_relative "type_inference/inferer_registry"
+require_relative "type_inference/call_validator"
+require_relative "type_inference/type_environment"
+require_relative "type_inference/call_type_resolver"
+require_relative "type_inference/field_type_resolver"
+require_relative "type_inference/collection_type_resolver"
+require_relative "type_inference/expression_inferer"
+require_relative "type_inference/definition_inferer"
+require_relative "type_inference/control_flow_inferer"
+
 module RLSL
   module Prism
-    class TypeInference
-      attr_reader :symbol_table
+    class SignatureError < RLSL::Error; end
 
-      def initialize(uniforms = {}, custom_functions = {})
-        @symbol_table = {}
+    class TypeInference
+      EXPRESSION_NODES = {
+        IR::VarRef => :infer_var_ref,
+        IR::Literal => :infer_literal,
+        IR::BoolLiteral => :infer_bool_literal,
+        IR::BinaryOp => :infer_binary_op,
+        IR::UnaryOp => :infer_unary_op,
+        IR::FuncCall => :infer_func_call,
+        IR::FieldAccess => :infer_field_access,
+        IR::Swizzle => :infer_swizzle,
+        IR::Parenthesized => :infer_parenthesized,
+        IR::ArrayLiteral => :infer_array_literal,
+        IR::ArrayIndex => :infer_array_index
+      }.freeze
+
+      DEFINITION_NODES = {
+        IR::VarDecl => :infer_var_decl,
+        IR::Assignment => :infer_assignment,
+        IR::GlobalDecl => :infer_global_decl,
+        IR::MultipleAssignment => :infer_multiple_assignment
+      }.freeze
+
+      CONTROL_FLOW_NODES = {
+        IR::IfStatement => :infer_if_statement,
+        IR::Ternary => :infer_ternary,
+        IR::Return => :infer_return,
+        IR::ForLoop => :infer_for_loop,
+        IR::WhileLoop => :infer_while_loop,
+        IR::FunctionDefinition => :infer_function_definition
+      }.freeze
+
+      def initialize(uniforms = {}, custom_functions = {}, globals: {})
+        @types = TypeEnvironment.new
         @uniforms = uniforms
         @custom_functions = custom_functions
-
-        uniforms.each do |name, type|
-          @symbol_table[name.to_sym] = type
-        end
-      end
-
-      def register(name, type)
-        @symbol_table[name.to_sym] = type
-      end
-
-      def register_function(name, returns:)
-        @custom_functions[name.to_sym] = { returns: returns }
-      end
-
-      def lookup(name)
-        @symbol_table[name.to_sym]
-      end
-
-      def infer(node)
-        case node
-        when IR::Block
-          infer_block(node)
-        when IR::VarDecl
-          infer_var_decl(node)
-        when IR::VarRef
-          infer_var_ref(node)
-        when IR::Literal
-          infer_literal(node)
-        when IR::BoolLiteral
-          node.type = :bool
-          node
-        when IR::BinaryOp
-          infer_binary_op(node)
-        when IR::UnaryOp
-          infer_unary_op(node)
-        when IR::FuncCall
-          infer_func_call(node)
-        when IR::FieldAccess
-          infer_field_access(node)
-        when IR::Swizzle
-          infer_swizzle(node)
-        when IR::IfStatement
-          infer_if_statement(node)
-        when IR::Return
-          infer_return(node)
-        when IR::Assignment
-          infer_assignment(node)
-        when IR::ForLoop
-          infer_for_loop(node)
-        when IR::WhileLoop
-          infer_while_loop(node)
-        when IR::Parenthesized
-          infer_parenthesized(node)
-        when IR::FunctionDefinition
-          infer_function_definition(node)
-        when IR::ArrayLiteral
-          infer_array_literal(node)
-        when IR::ArrayIndex
-          infer_array_index(node)
-        when IR::GlobalDecl
-          infer_global_decl(node)
-        when IR::MultipleAssignment
-          infer_multiple_assignment(node)
-        else
-          node
-        end
-      end
-
-      private
-
-      def infer_block(node)
-        node.statements.each { |stmt| infer(stmt) }
-        node.type = node.statements.last&.type
-        node
-      end
-
-      def infer_var_decl(node)
-        infer(node.initializer) if node.initializer
-        node.type ||= node.initializer&.type
-        register(node.name, node.type) if node.type
-        node
-      end
-
-      def infer_var_ref(node)
-        node.type ||= lookup(node.name)
-        node
-      end
-
-      def infer_literal(node)
-        node
-      end
-
-      def infer_binary_op(node)
-        infer(node.left)
-        infer(node.right)
-
-        node.type = Builtins.binary_op_result_type(
-          node.operator,
-          node.left.type,
-          node.right.type
+        @globals = globals
+        @inferer_registry = InfererRegistry.new
+        @call_validator = CallValidator.new
+        @call_type_resolver = CallTypeResolver.new(
+          custom_functions: @custom_functions,
+          call_validator: @call_validator
         )
-        node
-      end
-
-      def infer_unary_op(node)
-        infer(node.operand)
+        @field_type_resolver = FieldTypeResolver.new(uniforms: @uniforms)
+        @collection_type_resolver = CollectionTypeResolver.new(
+          type_environment: @types,
+          custom_functions: @custom_functions,
+          register: method(:register)
+        )
+        @expression_inferer = ExpressionInferer.new(
+          infer: method(:infer),
+          lookup: method(:lookup),
+          call_type_resolver: @call_type_resolver,
+          field_type_resolver: @field_type_resolver,
+          collection_type_resolver: @collection_type_resolver
+        )
+        @definition_inferer = DefinitionInferer.new(
+          infer: method(:infer),
+          lookup: method(:lookup),
+          register: method(:register),
+          collection_type_resolver: @collection_type_resolver
+        )
+        @control_flow_inferer = ControlFlowInferer.new(
+          infer: method(:infer),
+          infer_in_scope: method(:infer_in_scope),
+          lookup: method(:lookup)
+        )
+        register_inferers
 
-        case node.operator.to_s
-        when "-"
-          node.type = node.operand.type
-        when "!"
-          node.type = :bool
+        uniforms.each do |name, type|
+          register(name, type)
         end
-        node
-      end
-
-      def infer_func_call(node)
-        node.args.each { |arg| infer(arg) }
-        infer(node.receiver) if node.receiver
+        register(:u, :uniforms)
 
-        sig = Builtins.function_signature(node.name)
-        if sig
-          arg_types = node.args.map(&:type)
-          node.type = Builtins.resolve_return_type(sig[:returns], arg_types)
-        elsif @custom_functions.key?(node.name.to_sym)
-          node.type = @custom_functions[node.name.to_sym][:returns]
-        else
-          node.type = node.receiver&.type
+        globals.each do |name, type|
+          register(name, type)
         end
-        node
       end
 
-      def infer_field_access(node)
-        infer(node.receiver)
-
-        if Builtins.single_component_field?(node.field)
-          node.type = :float
-        else
-          node.type = @uniforms[node.field.to_sym] || :float
-        end
-        node
+      def symbol_table
+        @types.to_h
       end
 
-      def infer_swizzle(node)
-        infer(node.receiver)
-        node.type = Builtins.swizzle_type(node.components)
-        node
+      def register(name, type)
+        @types.register(name, type)
       end
 
-      def infer_if_statement(node)
-        infer(node.condition)
-        infer(node.then_branch)
-        infer(node.else_branch) if node.else_branch
-
-        node.type = node.then_branch.type
-        node
+      def register_function(name, returns:, params: {})
+        @custom_functions[name.to_sym] = { returns: returns, params: params }
       end
 
-      def infer_return(node)
-        infer(node.expression) if node.expression
-        node.type = node.expression&.type
-        node
+      def lookup(name)
+        @types.lookup(name)
       end
 
-      def infer_assignment(node)
-        infer(node.target)
-        infer(node.value)
-        node.type = node.value.type
-        node
+      def infer(node, scoped: false)
+        options = node.is_a?(IR::Block) ? { scoped: scoped } : {}
+        @inferer_registry.infer(node, **options) || node
+      rescue RLSL::Error => error
+        error.with_source_location(node.location)
+        raise
       end
 
-      def infer_for_loop(node)
-        register(node.variable, :int)
-        infer(node.range_start)
-        infer(node.range_end)
-        infer(node.body)
-        node.type = nil
-        node
-      end
+      private
 
-      def infer_while_loop(node)
-        infer(node.condition)
-        infer(node.body)
-        node.type = nil
-        node
+      def register_inferers
+        @inferer_registry.register(IR::Block) { |node, scoped: false| infer_block(node, scoped: scoped) }
+        @inferer_registry.register_methods(@expression_inferer, EXPRESSION_NODES)
+        @inferer_registry.register_methods(@definition_inferer, DEFINITION_NODES)
+        @inferer_registry.register_methods(@control_flow_inferer, CONTROL_FLOW_NODES)
       end
 
-      def infer_function_definition(node)
-        node.param_types.each do |param_name, param_type|
-          register(param_name, param_type)
+      def infer_block(node, scoped: false)
+        infer_with_optional_scope(scoped) do
+          node.statements.each { |stmt| infer(stmt) }
+          node.type = node.statements.last&.type
+          node
         end
-
-        infer(node.body)
-
-        node.return_type ||= node.body&.type
-        node.type = node.return_type
-        node
-      end
-
-      def infer_parenthesized(node)
-        infer(node.expression)
-        node.type = node.expression.type
-        node
       end
 
-      def infer_array_literal(node)
-        node.elements.each { |elem| infer(elem) }
-
-        element_type = node.elements.first&.type || :float
-        node.type = :"array_#{element_type}"
-        node
-      end
-
-      def infer_array_index(node)
-        infer(node.array)
-        infer(node.index)
-
-        array_type = node.array.type
-        if array_type.to_s.start_with?("array_")
-          node.type = array_type.to_s.sub("array_", "").to_sym
-        else
-          node.type = @symbol_table["#{node.array.name}_element_type".to_sym] || :float
-        end
-        node
+      def infer_child_scope(node)
+        infer_in_scope { infer(node) }
       end
 
-      def infer_global_decl(node)
-        infer(node.initializer) if node.initializer
-
-        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
-          node.type = :"array_#{node.element_type}"
-        else
-          node.type ||= node.initializer&.type
-        end
-
-        register(node.name, node.type) if node.type
+      def infer_in_scope(initial_scope = nil)
+        initial_scope ? @types.push(initial_scope) : @types.push
 
-        if node.element_type
-          register("#{node.name}_element_type".to_sym, node.element_type)
-        end
-
-        node
+        yield
+      ensure
+        @types.pop
       end
 
-      def infer_multiple_assignment(node)
-        infer(node.value)
-
-        value_type = node.value.type
-        if value_type.is_a?(IR::TupleType)
-          node.targets.each_with_index do |target, i|
-            target.type = value_type.types[i]
-            register(target.name, target.type)
-          end
-        elsif value_type.to_s.start_with?("array_")
-          elem_type = value_type.to_s.sub("array_", "").to_sym
-          node.targets.each do |target|
-            target.type = elem_type
-            register(target.name, target.type)
-          end
-        elsif @custom_functions.key?(node.value.name) && node.value.is_a?(IR::FuncCall)
-          func_info = @custom_functions[node.value.name]
-          if func_info[:returns].is_a?(Array)
-            node.targets.each_with_index do |target, i|
-              target.type = func_info[:returns][i]
-              register(target.name, target.type)
-            end
-          end
-        end
+      def infer_with_optional_scope(scoped)
+        return yield unless scoped
 
-        node.type = nil
-        node
+        @types.push
+        yield
+      ensure
+        @types.pop if scoped
       end
     end
   end

data/lib/rlsl/runtime_shader.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RLSL
+  class RuntimeShader
+    attr_reader :name, :uniform_types, :uniform_names
+
+    def initialize(name, uniforms)
+      @name = name
+      @uniform_types = normalize_uniform_types(uniforms)
+      @uniform_names = @uniform_types.keys
+    end
+
+    def metal?
+      false
+    end
+
+    def render(*)
+      raise NotImplementedError, "Subclasses must implement render"
+    end
+
+    protected
+
+    def normalized_uniforms(uniforms)
+      UniformTypes.normalize_values(@uniform_types, uniforms, shader_name: @name)
+    end
+
+    def ordered_uniform_values(uniforms)
+      normalized = normalized_uniforms(uniforms)
+      @uniform_names.map { |name| normalized[name] }
+    end
+
+    private
+
+    def normalize_uniform_types(uniforms)
+      case uniforms
+      when Hash
+        uniforms.each_with_object({}) do |(name, type), normalized|
+          normalized[name.to_sym] = type
+        end
+      else
+        Array(uniforms).each_with_object({}) do |name, normalized|
+          normalized[name.to_sym] = nil
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/shader_builder/build_service.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RLSL
+  class ShaderBuilder
+    class BuildService
+      def initialize(name, definition, source_resolver_class: SourceResolver, compiler_factory: nil)
+        @name = name
+        @definition = definition
+        @source_resolver_class = source_resolver_class
+        @compiler_factory = compiler_factory
+      end
+
+      def compile_and_load
+        compiler = native_extension_compiler
+        base_code = generate_c_code
+        extension_name = compiler.extension_name_for(base_code)
+        c_code = generate_c_code(extension_name: extension_name)
+        artifact = compiler.build(c_code, ext_name: extension_name)
+
+        require artifact.file
+        CompiledShader.new(@name, artifact.ext_name, @definition.uniforms)
+      end
+
+      def build_metal_shader
+        translator = MSL::Translator.new(@definition.uniforms, *translation_sources(:msl), name: @name)
+        msl_source = translator.translate
+
+        MSL::Shader.new(@name, @definition.uniforms, msl_source)
+      end
+
+      def build_wgsl_shader
+        validate_wgsl_module_names!
+        WGSL::Translator.new(@definition.uniforms, *translation_sources(:wgsl), name: @name).translate
+      end
+
+      def build_glsl_shader(version: "450")
+        GLSL::Translator.new(
+          @definition.uniforms,
+          *translation_sources(:glsl),
+          version: version,
+          name: @name
+        ).translate
+      end
+
+      def transpile_fragment(target)
+        return "" unless @definition.fragment_block
+
+        source_resolver.fragment_code(target)
+      end
+
+      def transpile_helpers(target)
+        return "" unless @definition.helpers_block
+
+        source_resolver.helpers_code(target)
+      end
+
+      private
+
+      def generate_c_code(extension_name: @name)
+        helpers_code, fragment_code = resolved_sources(:c)
+        codegen = CodeGenerator.new(
+          @name,
+          @definition.uniforms,
+          -> { helpers_code },
+          -> { fragment_code },
+          extension_name: extension_name
+        )
+        codegen.generate
+      end
+
+      def resolved_sources(target)
+        source_resolver.sources_for(target)
+      end
+
+      def translation_sources(target)
+        source_resolver.translation_sources_for(target)
+      end
+
+      def source_resolver
+        @source_resolver ||= @source_resolver_class.new(@definition)
+      end
+
+      def native_extension_compiler
+        @native_extension_compiler ||= if @compiler_factory
+                                         @compiler_factory.call(@name)
+                                       else
+                                         NativeExtensionCompiler.new(@name)
+                                       end
+      end
+
+      def validate_wgsl_module_names!
+        resources = @definition.uniforms.filter_map do |name, type|
+          [name, :"#{name}_sampler"] if type == :sampler2D
+        end.flatten
+        generated = %i[u output_texture rlsl_mod shader_fragment main]
+        functions = @definition.custom_functions.keys
+        conflicts = (resources & (generated + functions)) | (functions & generated)
+        return if conflicts.empty?
+
+        raise ArgumentError, "WGSL module name conflict: #{conflicts.join(', ')}"
+      end
+    end
+  end
+end

data/lib/rlsl/shader_builder/native_extension_compiler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "digest"
+require "open3"
+require "shellwords"
+
+module RLSL
+  class ShaderBuilder
+    class NativeExtensionCompiler
+      Artifact = Struct.new(:ext_name, :directory, :file, keyword_init: true)
+
+      def initialize(
+        shader_name,
+        cache_dir: RLSL.cache_dir,
+        ruby_bin: RbConfig.ruby,
+        dylib_ext: RbConfig::CONFIG["DLEXT"],
+        make_command: RbConfig::CONFIG["MAKE"] || "make",
+        fast_math: false
+      )
+        @shader_name = RLSL.validate_shader_name!(shader_name)
+        @cache_dir = cache_dir
+        @ruby_bin = ruby_bin
+        @dylib_ext = dylib_ext
+        @make_command = Shellwords.split(make_command)
+        @fast_math = fast_math
+      end
+
+      def build(c_code, ext_name: nil)
+        resolved_ext_name = ext_name || declared_extension_name(c_code) || extension_name_for(c_code)
+        artifact = artifact_for(c_code, ext_name: resolved_ext_name)
+        FileUtils.mkdir_p(artifact.directory)
+        File.open(File.join(artifact.directory, ".build.lock"), "w") do |lock|
+          lock.flock(File::LOCK_EX)
+          compile(artifact, c_code) unless File.exist?(artifact.file)
+        end
+        artifact
+      end
+
+      def extension_name_for(c_code)
+        code_hash = Digest::SHA256.hexdigest(c_code)[0, 16]
+        "#{@shader_name}_#{code_hash}"
+      end
+
+      private
+
+      def artifact_for(c_code, ext_name: extension_name_for(c_code))
+        validated_ext_name = RLSL.validate_identifier!(ext_name, context: "extension name")
+        directory = File.join(@cache_dir, extension_name_for(c_code))
+
+        Artifact.new(
+          ext_name: validated_ext_name,
+          directory: directory,
+          file: File.join(directory, "#{validated_ext_name}.#{@dylib_ext}")
+        )
+      end
+
+      def compile(artifact, c_code)
+        File.write(File.join(artifact.directory, "#{artifact.ext_name}.c"), c_code)
+        File.write(File.join(artifact.directory, "extconf.rb"), extconf_source(artifact.ext_name))
+
+        run_command!(@ruby_bin, "extconf.rb", chdir: artifact.directory)
+        run_command!(*@make_command, chdir: artifact.directory)
+      end
+
+      def declared_extension_name(c_code)
+        c_code[/\bvoid\s+Init_([A-Za-z_][A-Za-z0-9_]*)\s*\(/, 1]
+      end
+
+      def extconf_source(ext_name)
+        <<~RUBY
+          require "mkmf"
+          $CFLAGS << " -O3#{@fast_math ? ' -ffast-math' : ''}"
+          if RUBY_PLATFORM =~ /darwin/
+            $CFLAGS << " -fblocks"
+          end
+          create_makefile("#{ext_name}")
+        RUBY
+      end
+
+      def run_command!(*args, chdir:)
+        runner = lambda do
+          stdout, stderr, status = Open3.capture3(*args, chdir: chdir)
+          return if status.success?
+
+          output = [stdout, stderr].reject(&:empty?).join("\n")
+          raise RLSL::CompilationError, "#{args.first} failed for #{@shader_name}:\n#{output}"
+        end
+
+        if defined?(Bundler) && Bundler.respond_to?(:with_unbundled_env)
+          Bundler.with_unbundled_env { runner.call }
+        else
+          runner.call
+        end
+      end
+    end
+  end
+end