rlsl 1.0.0 → 1.0.1

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

@@ -8,9 +8,30 @@ module RLSL
       end
 
       def resolve(node)
-        return :float if Builtins.single_component_field?(node.field)
+        if node.receiver.type == :uniforms
+          type = @uniforms[node.field.to_sym]
+          return type if type
 
-        @uniforms[node.field.to_sym] || :float
+          raise SignatureError, "Unknown uniform field #{node.field.inspect}"
+        end
+
+        if Builtins.single_component_field?(node.field)
+          unless Builtins.valid_swizzle_for_type?(node.field, node.receiver.type)
+            raise SignatureError, "Invalid component #{node.field.inspect} for #{node.receiver.type || :unknown}"
+          end
+
+          return :float
+        end
+
+        if Builtins.swizzle?(node.field)
+          unless Builtins.valid_swizzle_for_type?(node.field, node.receiver.type)
+            raise SignatureError, "Invalid swizzle #{node.field.inspect} for #{node.receiver.type || :unknown}"
+          end
+
+          return Builtins.swizzle_type(node.field)
+        end
+
+        raise SignatureError, "Unknown field #{node.field.inspect} for #{node.receiver.type || :unknown}"
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RLSL
       end
 
       def pop
-        raise "Cannot pop the global scope" if @scopes.length == 1
+        raise RLSL::InternalError, "Cannot pop the global scope" if @scopes.length == 1
 
         @scopes.pop
       end

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

@@ -3,7 +3,7 @@
 module RLSL
   module Prism
     module TypeShapes
-      ArrayType = Struct.new(:element_type) do
+      ArrayType = Struct.new(:element_type, :element_count) do
         def to_sym
           :"array_#{element_type}"
         end
@@ -15,8 +15,8 @@ module RLSL
 
       module_function
 
-      def array(element_type)
-        ArrayType.new(element_type)
+      def array(element_type, length = nil)
+        ArrayType.new(element_type, length)
       end
 
       def array?(type)

data/lib/rlsl/prism/type_inference.rb

@@ -14,7 +14,7 @@ require_relative "type_inference/control_flow_inferer"
 
 module RLSL
   module Prism
-    class SignatureError < StandardError; end
+    class SignatureError < RLSL::Error; end
 
     class TypeInference
       EXPRESSION_NODES = {
@@ -73,19 +73,21 @@ module RLSL
         )
         @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_child_scope: method(:infer_child_scope),
-          infer_in_scope: method(:infer_in_scope)
+          infer_in_scope: method(:infer_in_scope),
+          lookup: method(:lookup)
         )
         register_inferers
 
         uniforms.each do |name, type|
           register(name, type)
         end
+        register(:u, :uniforms)
 
         globals.each do |name, type|
           register(name, type)
@@ -100,8 +102,8 @@ module RLSL
         @types.register(name, type)
       end
 
-      def register_function(name, returns:)
-        @custom_functions[name.to_sym] = { returns: returns }
+      def register_function(name, returns:, params: {})
+        @custom_functions[name.to_sym] = { returns: returns, params: params }
       end
 
       def lookup(name)
@@ -111,6 +113,9 @@ module RLSL
       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
 
       private

data/lib/rlsl/shader_builder/build_service.rb

@@ -11,26 +11,35 @@ module RLSL
       end
 
       def compile_and_load
-        c_code = generate_c_code
-        artifact = native_extension_compiler.build(c_code)
+        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))
+        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
-        WGSL::Translator.new(@definition.uniforms, *translation_sources(:wgsl)).translate
+        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).translate
+        GLSL::Translator.new(
+          @definition.uniforms,
+          *translation_sources(:glsl),
+          version: version,
+          name: @name
+        ).translate
       end
 
       def transpile_fragment(target)
@@ -47,9 +56,15 @@ module RLSL
 
       private
 
-      def generate_c_code
+      def generate_c_code(extension_name: @name)
         helpers_code, fragment_code = resolved_sources(:c)
-        codegen = CodeGenerator.new(@name, @definition.uniforms, -> { helpers_code }, -> { fragment_code })
+        codegen = CodeGenerator.new(
+          @name,
+          @definition.uniforms,
+          -> { helpers_code },
+          -> { fragment_code },
+          extension_name: extension_name
+        )
         codegen.generate
       end
 
@@ -72,6 +87,18 @@ module RLSL
                                          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

@@ -1,55 +1,75 @@
 # 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"])
-        @shader_name = shader_name
+      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)
-        artifact = artifact_for(c_code)
-        compile(artifact, c_code) unless File.exist?(artifact.file)
+      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)
-        code_hash = Digest::MD5.hexdigest(c_code)[0..7]
-        ext_name = "#{@shader_name}_#{code_hash}"
-        directory = File.join(@cache_dir, ext_name)
+      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: ext_name,
+          ext_name: validated_ext_name,
           directory: directory,
-          file: File.join(directory, "#{@shader_name}.#{@dylib_ext}")
+          file: File.join(directory, "#{validated_ext_name}.#{@dylib_ext}")
         )
       end
 
       def compile(artifact, c_code)
-        FileUtils.mkdir_p(artifact.directory)
+        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))
 
-        File.write(File.join(artifact.directory, "#{@shader_name}.c"), c_code)
-        File.write(File.join(artifact.directory, "extconf.rb"), extconf_source(@shader_name))
+        run_command!(@ruby_bin, "extconf.rb", chdir: artifact.directory)
+        run_command!(*@make_command, chdir: artifact.directory)
+      end
 
-        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
+      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 -ffast-math"
+          $CFLAGS << " -O3#{@fast_math ? ' -ffast-math' : ''}"
           if RUBY_PLATFORM =~ /darwin/
             $CFLAGS << " -fblocks"
           end
@@ -57,13 +77,19 @@ module RLSL
         RUBY
       end
 
-      def run_command(*args)
+      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 do
-            system(*args, out: File::NULL, err: File::NULL)
-          end
+          Bundler.with_unbundled_env { runner.call }
         else
-          system(*args, out: File::NULL, err: File::NULL)
+          runner.call
         end
       end
     end

data/lib/rlsl/shader_builder/shader_definition.rb

@@ -9,7 +9,7 @@ module RLSL
         uniforms: {},
         custom_functions: {},
         helpers_block: nil,
-        helpers_mode: :c,
+        helpers_mode: :ruby,
         fragment_block: nil,
         fragment_mode: :c
       )
@@ -38,11 +38,11 @@ module RLSL
       end
 
       def ruby_fragment?
-        @fragment_mode == :ruby
+        %i[ruby ruby_source].include?(@fragment_mode)
       end
 
       def ruby_helpers?
-        @helpers_mode == :ruby
+        %i[ruby ruby_source].include?(@helpers_mode)
       end
 
       private

data/lib/rlsl/shader_builder/source_resolver.rb

@@ -28,6 +28,13 @@ module RLSL
 
       def helpers_source(target)
         return source_snippet("") unless @definition.helpers_block
+        if @definition.helpers_mode == :ruby_source
+          source = @definition.helpers_block.call
+          return source_snippet(
+            helpers_transpiler.transpile_helpers_source(source, target, @definition.custom_functions),
+            format: :target
+          )
+        end
         return source_snippet(@definition.helpers_block.call) unless ruby_helpers?
 
         source_snippet(
@@ -38,6 +45,10 @@ module RLSL
 
       def fragment_source(target)
         return source_snippet("") unless @definition.fragment_block
+        if @definition.fragment_mode == :ruby_source
+          source = @definition.fragment_block.call
+          return source_snippet(fragment_transpiler.transpile_source(source, target), format: :target)
+        end
         return source_snippet(@definition.fragment_block.call) unless ruby_fragment?
 
         source_snippet(fragment_transpiler.transpile(@definition.fragment_block, target), format: :target)
@@ -63,7 +74,14 @@ module RLSL
         return {} unless ruby_helpers? && @definition.helpers_block
 
         @helper_globals ||= begin
-          compilation = helpers_transpiler.compile_helpers(@definition.helpers_block, @definition.custom_functions)
+          compilation = if @definition.helpers_mode == :ruby_source
+                          helpers_transpiler.compile_helpers_source(
+                            @definition.helpers_block.call,
+                            @definition.custom_functions
+                          )
+                        else
+                          helpers_transpiler.compile_helpers(@definition.helpers_block, @definition.custom_functions)
+                        end
           extract_global_types(compilation.ir)
         end
       end

data/lib/rlsl/shader_builder.rb

@@ -10,7 +10,7 @@ module RLSL
     attr_reader :name
 
     def initialize(name, definition = ShaderDefinition.new)
-      @name = name.to_s
+      @name = RLSL.validate_shader_name!(name)
       @definition = definition
     end
 
@@ -18,27 +18,62 @@ module RLSL
       if block_given?
         ctx = UniformContext.new
         ctx.instance_eval(&block)
-        @definition = @definition.with_uniforms(ctx.uniforms)
+        update_definition(@definition.with_uniforms(ctx.uniforms))
       else
         @definition.uniforms
       end
     end
 
+    def uniform_types
+      @definition.uniforms
+    end
+
     def helpers(mode = :ruby, &block)
-      @definition = @definition.with_helpers(mode: mode, block: block)
+      raise ArgumentError, "helpers requires a block" unless block
+
+      resolved_mode = mode.to_sym
+      raise ArgumentError, "helpers mode must be :c or :ruby" unless %i[c ruby].include?(resolved_mode)
+
+      if resolved_mode == :ruby
+        source_unit = Prism::SourceExtractor.new.extract_unit(block)
+        update_definition(@definition.with_helpers(mode: :ruby_source, block: -> { source_unit }))
+      else
+        update_definition(@definition.with_helpers(mode: :c, block: block))
+      end
+    end
+
+    def helpers_source(source)
+      update_definition(@definition.with_helpers(mode: :ruby_source, block: -> { source.to_s }))
     end
 
     def functions(&block)
       ctx = FunctionContext.new
       ctx.instance_eval(&block)
-      @definition = @definition.with_custom_functions(ctx.functions)
+      update_definition(@definition.with_custom_functions(ctx.functions))
+    end
+
+    def fragment(mode = :auto, &block)
+      raise ArgumentError, "fragment requires a block" unless block
+
+      resolved_mode = if mode == :auto
+                        block.parameters.empty? ? :c : :ruby
+                      else
+                        mode.to_sym
+                      end
+      unless %i[c ruby].include?(resolved_mode)
+        raise ArgumentError, "fragment mode must be :c or :ruby"
+      end
+
+      if resolved_mode == :ruby
+        source_unit = Prism::SourceExtractor.new.extract_unit(block)
+        update_definition(@definition.with_fragment(mode: :ruby_source, block: -> { source_unit }))
+      else
+        update_definition(@definition.with_fragment(mode: :c, block: block))
+      end
     end
 
-    def fragment(&block)
-      @definition = @definition.with_fragment(
-        mode: block.arity > 0 ? :ruby : :c,
-        block: block
-      )
+    def fragment_source(source)
+      update_definition(@definition.with_fragment(mode: :ruby_source, block: -> { source.to_s }))
     end
 
     def compile_and_load
@@ -68,7 +103,12 @@ module RLSL
     private
 
     def build_service
-      BuildService.new(@name, @definition)
+      @build_service ||= BuildService.new(@name, @definition)
+    end
+
+    def update_definition(definition)
+      @definition = definition
+      @build_service = nil
     end
   end
 end

data/lib/rlsl/shader_name.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RLSL
+  IDENTIFIER_PATTERN = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+  SHADER_NAME_PATTERN = IDENTIFIER_PATTERN
+
+  def self.validate_identifier!(name, context: "identifier")
+    normalized = name.to_s
+    return normalized if normalized.match?(IDENTIFIER_PATTERN)
+
+    raise ArgumentError,
+          "Invalid #{context} #{name.inspect}: use an ASCII identifier beginning with a letter or underscore"
+  end
+
+  def self.validate_shader_name!(name)
+    validate_identifier!(name, context: "shader name")
+  end
+end

data/lib/rlsl/types/type_spec.rb

@@ -116,8 +116,8 @@ module RLSL
     bool: UniformTypeSpec.new(
       c_type: "int",
       glsl_type: "bool",
-      wgsl_type: "bool",
-      msl_type: "bool",
+      wgsl_type: "i32",
+      msl_type: "int",
       wrapper_kind: :bool,
       metal_alignment: 4,
       metal_size: 4,
@@ -156,7 +156,7 @@ module RLSL
       c_type: "sampler2D",
       glsl_type: "sampler2D",
       wgsl_type: "texture_2d<f32>",
-      msl_type: nil,
+      msl_type: "texture2d<float>",
       compiled_supported: false,
       runtime_supported: false,
       function_shorthand: true

data/lib/rlsl/types/value_normalizer.rb

@@ -17,26 +17,24 @@ module RLSL
         return value if type.nil?
 
         spec = fetch(type)
-        raise ArgumentError, unsupported_runtime_type_message(type, shader_name) unless spec.runtime_supported?
+        raise UniformValueError, unsupported_runtime_type_message(type, shader_name) unless spec.runtime_supported?
 
         case spec.wrapper_kind
         when :float
           Float(value)
         when :int
-          Integer(value)
+          normalize_int(value, name: name, shader_name: shader_name)
         when :bool
           normalize_bool(value, name: name, shader_name: shader_name)
         when :vector
           normalize_vector(value, spec.vector_size, name: name, shader_name: shader_name)
         else
-          raise ArgumentError, unsupported_runtime_type_message(type, shader_name)
+          raise UniformValueError, unsupported_runtime_type_message(type, shader_name)
         end
-      rescue TypeError
-        raise ArgumentError, invalid_uniform_message(name, type, value, shader_name)
-      rescue ArgumentError => e
-        raise e if e.message.start_with?("Invalid value for uniform", "Unsupported runtime uniform type")
-
-        raise ArgumentError, invalid_uniform_message(name, type, value, shader_name)
+      rescue UniformValueError
+        raise
+      rescue TypeError, ArgumentError, RangeError
+        raise UniformValueError, invalid_uniform_message(name, type, value, shader_name)
       end
 
       def normalize_bool(value, name:, shader_name: nil)
@@ -44,12 +42,19 @@ module RLSL
         return false if value == 0
         return true if value == 1
 
-        raise ArgumentError, invalid_uniform_message(name, :bool, value, shader_name)
+        raise UniformValueError, invalid_uniform_message(name, :bool, value, shader_name)
+      end
+
+      def normalize_int(value, name:, shader_name: nil)
+        integer = Integer(value)
+        return integer if (-2**31...2**31).cover?(integer)
+
+        raise UniformValueError, invalid_uniform_message(name, :int, value, shader_name)
       end
 
       def normalize_vector(value, vector_size, name:, shader_name: nil)
         unless value.is_a?(Array) && value.length == vector_size
-          raise ArgumentError, invalid_vector_message(name, vector_size, value, shader_name)
+          raise UniformValueError, invalid_vector_message(name, vector_size, value, shader_name)
         end
 
         value.map { |component| Float(component) }

data/lib/rlsl/types.rb

@@ -11,8 +11,4 @@ module RLSL
     extend TargetResolver
     extend ValueNormalizer
   end
-
-  module TypeMapping
-    C_UNIFORM_TYPES = UNIFORM_TYPE_SPECS.transform_values(&:c_type).freeze
-  end
 end

data/lib/rlsl/uniform_context.rb

@@ -3,6 +3,8 @@
 module RLSL
   # DSL context for defining uniform variables
   class UniformContext
+    RESERVED_NAMES = %i[resolution u frag_coord].freeze
+
     attr_reader :uniforms
 
     def initialize
@@ -10,7 +12,22 @@ module RLSL
     end
 
     def define_uniform(name, type)
-      @uniforms[name] = type
+      normalized_name = RLSL.validate_identifier!(name, context: "uniform name").to_sym
+      if RESERVED_NAMES.include?(normalized_name)
+        raise ArgumentError, "Uniform name #{normalized_name.inspect} is reserved by RLSL"
+      end
+      if @uniforms.key?(normalized_name)
+        raise ArgumentError, "Uniform #{normalized_name.inspect} is already defined"
+      end
+      generated_sampler_names = @uniforms.filter_map do |uniform_name, uniform_type|
+        :"#{uniform_name}_sampler" if uniform_type == :sampler2D
+      end
+      if generated_sampler_names.include?(normalized_name) ||
+         (type == :sampler2D && @uniforms.key?(:"#{normalized_name}_sampler"))
+        raise ArgumentError, "Uniform #{normalized_name.inspect} conflicts with a generated sampler name"
+      end
+
+      @uniforms[normalized_name] = type
     end
 
     RLSL::UNIFORM_TYPES.each do |type|

data/lib/rlsl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RLSL
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end