rlsl 0.1.1 → 1.0.0

data/lib/rlsl/prism/type_inference.rb

@@ -1,22 +1,103 @@
 # 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 < StandardError; 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
+        @globals = globals
+        @inferer_registry = InfererRegistry.new
+        @call_validator = CallValidator.new
+        @call_type_resolver = CallTypeResolver.new(
+          custom_functions: @custom_functions,
+          call_validator: @call_validator
+        )
+        @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),
+          register: method(:register),
+          collection_type_resolver: @collection_type_resolver
+        )
+        @control_flow_inferer = ControlFlowInferer.new(
+          infer: method(:infer),
+          infer_child_scope: method(:infer_child_scope),
+          infer_in_scope: method(:infer_in_scope)
+        )
+        register_inferers
 
         uniforms.each do |name, type|
-          @symbol_table[name.to_sym] = type
+          register(name, type)
         end
+
+        globals.each do |name, type|
+          register(name, type)
+        end
+      end
+
+      def symbol_table
+        @types.to_h
       end
 
       def register(name, type)
-        @symbol_table[name.to_sym] = type
+        @types.register(name, type)
       end
 
       def register_function(name, returns:)
@@ -24,265 +105,50 @@ module RLSL
       end
 
       def lookup(name)
-        @symbol_table[name.to_sym]
+        @types.lookup(name)
       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
+      def infer(node, scoped: false)
+        options = node.is_a?(IR::Block) ? { scoped: scoped } : {}
+        @inferer_registry.infer(node, **options) || node
       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
+      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_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
-        )
-        node
-      end
-
-      def infer_unary_op(node)
-        infer(node.operand)
-
-        case node.operator.to_s
-        when "-"
-          node.type = node.operand.type
-        when "!"
-          node.type = :bool
-        end
-        node
-      end
-
-      def infer_func_call(node)
-        node.args.each { |arg| infer(arg) }
-        infer(node.receiver) if node.receiver
-
-        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
-        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
+      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
-        node
       end
 
-      def infer_swizzle(node)
-        infer(node.receiver)
-        node.type = Builtins.swizzle_type(node.components)
-        node
+      def infer_child_scope(node)
+        infer_in_scope { infer(node) }
       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
-      end
-
-      def infer_return(node)
-        infer(node.expression) if node.expression
-        node.type = node.expression&.type
-        node
-      end
-
-      def infer_assignment(node)
-        infer(node.target)
-        infer(node.value)
-        node.type = node.value.type
-        node
-      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
+      def infer_in_scope(initial_scope = nil)
+        initial_scope ? @types.push(initial_scope) : @types.push
 
-      def infer_while_loop(node)
-        infer(node.condition)
-        infer(node.body)
-        node.type = nil
-        node
+        yield
+      ensure
+        @types.pop
       end
 
-      def infer_function_definition(node)
-        node.param_types.each do |param_name, param_type|
-          register(param_name, param_type)
-        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
-      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
-
-        if node.element_type
-          register("#{node.name}_element_type".to_sym, node.element_type)
-        end
-
-        node
-      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,77 @@
+# 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
+        c_code = generate_c_code
+        artifact = native_extension_compiler.build(c_code)
+
+        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))
+        msl_source = translator.translate
+
+        MSL::Shader.new(@name, @definition.uniforms, msl_source)
+      end
+
+      def build_wgsl_shader
+        WGSL::Translator.new(@definition.uniforms, *translation_sources(:wgsl)).translate
+      end
+
+      def build_glsl_shader(version: "450")
+        GLSL::Translator.new(@definition.uniforms, *translation_sources(:glsl), version: version).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
+        helpers_code, fragment_code = resolved_sources(:c)
+        codegen = CodeGenerator.new(@name, @definition.uniforms, -> { helpers_code }, -> { fragment_code })
+        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
+    end
+  end
+end

data/lib/rlsl/shader_builder/native_extension_compiler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "digest"
+
+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"])
+        @shader_name = shader_name
+        @cache_dir = cache_dir
+        @ruby_bin = ruby_bin
+        @dylib_ext = dylib_ext
+      end
+
+      def build(c_code)
+        artifact = artifact_for(c_code)
+        compile(artifact, c_code) unless File.exist?(artifact.file)
+        artifact
+      end
+
+      private
+
+      def artifact_for(c_code)
+        code_hash = Digest::MD5.hexdigest(c_code)[0..7]
+        ext_name = "#{@shader_name}_#{code_hash}"
+        directory = File.join(@cache_dir, ext_name)
+
+        Artifact.new(
+          ext_name: ext_name,
+          directory: directory,
+          file: File.join(directory, "#{@shader_name}.#{@dylib_ext}")
+        )
+      end
+
+      def compile(artifact, c_code)
+        FileUtils.mkdir_p(artifact.directory)
+
+        File.write(File.join(artifact.directory, "#{@shader_name}.c"), c_code)
+        File.write(File.join(artifact.directory, "extconf.rb"), extconf_source(@shader_name))
+
+        Dir.chdir(artifact.directory) do
+          run_command(@ruby_bin, "extconf.rb") or raise "extconf failed for #{artifact.ext_name}"
+          run_command("/usr/bin/make") or raise "make failed for #{artifact.ext_name}"
+        end
+      end
+
+      def extconf_source(ext_name)
+        <<~RUBY
+          require "mkmf"
+          $CFLAGS << " -O3 -ffast-math"
+          if RUBY_PLATFORM =~ /darwin/
+            $CFLAGS << " -fblocks"
+          end
+          create_makefile("#{ext_name}")
+        RUBY
+      end
+
+      def run_command(*args)
+        if defined?(Bundler) && Bundler.respond_to?(:with_unbundled_env)
+          Bundler.with_unbundled_env do
+            system(*args, out: File::NULL, err: File::NULL)
+          end
+        else
+          system(*args, out: File::NULL, err: File::NULL)
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/shader_builder/shader_definition.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RLSL
+  class ShaderBuilder
+    class ShaderDefinition
+      attr_reader :uniforms, :custom_functions, :helpers_block, :helpers_mode, :fragment_block, :fragment_mode
+
+      def initialize(
+        uniforms: {},
+        custom_functions: {},
+        helpers_block: nil,
+        helpers_mode: :c,
+        fragment_block: nil,
+        fragment_mode: :c
+      )
+        @uniforms = normalize_hash(uniforms)
+        @custom_functions = normalize_hash(custom_functions)
+        @helpers_block = helpers_block
+        @helpers_mode = helpers_mode
+        @fragment_block = fragment_block
+        @fragment_mode = fragment_mode
+      end
+
+      def with_uniforms(uniforms)
+        copy(uniforms: uniforms)
+      end
+
+      def with_custom_functions(custom_functions)
+        copy(custom_functions: custom_functions)
+      end
+
+      def with_helpers(mode:, block:)
+        copy(helpers_mode: mode, helpers_block: block)
+      end
+
+      def with_fragment(mode:, block:)
+        copy(fragment_mode: mode, fragment_block: block)
+      end
+
+      def ruby_fragment?
+        @fragment_mode == :ruby
+      end
+
+      def ruby_helpers?
+        @helpers_mode == :ruby
+      end
+
+      private
+
+      def copy(**overrides)
+        self.class.new(
+          uniforms: overrides.fetch(:uniforms, @uniforms),
+          custom_functions: overrides.fetch(:custom_functions, @custom_functions),
+          helpers_block: overrides.fetch(:helpers_block, @helpers_block),
+          helpers_mode: overrides.fetch(:helpers_mode, @helpers_mode),
+          fragment_block: overrides.fetch(:fragment_block, @fragment_block),
+          fragment_mode: overrides.fetch(:fragment_mode, @fragment_mode)
+        )
+      end
+
+      def normalize_hash(hash)
+        hash.each_with_object({}) do |(name, value), normalized|
+          normalized[name.to_sym] = value
+        end.freeze
+      end
+    end
+  end
+end