panko_serializer 0.8.5 → 1.0.0

data/lib/panko/code_gen/generators/json_sink.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module Panko::CodeGen
+  module Generators
+    class JsonSink < Sink
+      def output
+        :json
+      end
+
+      def suffix
+        "JSON"
+      end
+
+      def entry_name
+        GeneratedNames.write_one
+      end
+
+      def generic_entry_name
+        GeneratedNames.generic_write_one
+      end
+
+      def split_hash_helper
+        GeneratedNames.write_one_hash
+      end
+
+      def split_object_helper
+        GeneratedNames.write_one_object
+      end
+
+      def entry_params
+        "record, writer, context, scope, filters"
+      end
+
+      def emit_class_constants(descriptor, config, builder)
+        return unless config.pool_writer
+        subclass = defined?(ActiveSupport::IsolatedExecutionState) ? "IsolatedExecutionState" : "ThreadLocal"
+        builder.line "POOL = Panko::CodeGen::WritersPool::#{subclass}.new"
+      end
+
+      def emit_serialize_one(config, builder)
+        signature = config.supports_root_key ?
+          "def serialize_one(record, context: nil, scope: nil, filters: nil, root_key: nil)" :
+          "def serialize_one(record, context: nil, scope: nil, filters: nil)"
+        builder.line signature
+        builder.indent do
+          builder.line "filters = Panko::CodeGen::Filter.wrap(filters, #{GeneratedNames.field_index_const})"
+          if config.supports_root_key
+            builder.line "validate_root_key!(root_key)"
+          end
+          with_writer(config, builder) { emit_serialize_one_body(config, builder) }
+        end
+        builder.line "end"
+      end
+
+      def emit_serialize_many(config, builder)
+        signature = config.supports_root_key ?
+          "def serialize_many(records, context: nil, scope: nil, filters: nil, root_key: nil)" :
+          "def serialize_many(records, context: nil, scope: nil, filters: nil)"
+        builder.line signature
+        builder.indent do
+          builder.line "filters = Panko::CodeGen::Filter.wrap(filters, #{GeneratedNames.field_index_const})"
+          if config.supports_root_key
+            builder.line "validate_root_key!(root_key)"
+          end
+          with_writer(config, builder) { emit_serialize_many_body(config, builder) }
+        end
+        builder.line "end"
+      end
+
+      # Write into a writer the caller owns, so a JSON document that holds this output
+      # (Panko::Response) gets it without a String copy. No pooled writer, no root key.
+      def emit_serialize_to(config, builder)
+        builder.line "def serialize_one_to(writer, record, key = nil, context: nil, scope: nil, filters: nil)"
+        builder.indent do
+          builder.line "filters = Panko::CodeGen::Filter.wrap(filters, #{GeneratedNames.field_index_const})"
+          builder.line "writer.push_key(key) if key"
+          builder.line "#{GeneratedNames.write_one}(record, writer, context, scope, filters)"
+          builder.line "nil"
+        end
+        builder.line "end"
+        builder.blank
+        builder.line "def serialize_many_to(writer, records, key = nil, context: nil, scope: nil, filters: nil)"
+        builder.indent do
+          builder.line "filters = Panko::CodeGen::Filter.wrap(filters, #{GeneratedNames.field_index_const})"
+          builder.line "writer.push_array(key)"
+          builder.line "records.each { |r| #{GeneratedNames.write_one}(r, writer, context, scope, filters) }"
+          builder.line "writer.pop"
+          builder.line "nil"
+        end
+        builder.line "end"
+      end
+
+      def open_record(builder)
+        builder.line "writer.push_object"
+      end
+
+      def close_record(builder)
+        builder.line "writer.pop"
+      end
+
+      # +cast:+ exists to match {HashSink#attribute} and is ignored: Oj's +:rails+ mode formats
+      # JSON values.
+      def attribute(attribute, read_expr, config, index, builder, cast: true)
+        builder.line "unless filters.drops?(#{index})"
+        builder.indent do
+          builder.line %(writer.push_value(#{read_expr}, "#{attribute.name}"))
+        end
+        builder.line "end"
+      end
+
+      def specialized_attribute(attribute, ar_model, config, index, builder)
+        if RecordAccess::Specialized.json_column_attribute?(attribute, ar_model)
+          json_column_attribute(attribute, config, index, builder)
+        elsif RecordAccess::Specialized.datetime_column_attribute?(attribute, ar_model)
+          datetime_column_attribute(attribute, index, builder)
+        else
+          attribute(attribute, RecordAccess::Specialized.attribute_read_expr(attribute, ar_model), config, index, builder)
+        end
+      end
+
+      # +equal?+, not +==+, so an object that overrides +==+ cannot match +SKIP+.
+      def method_attribute(method_attribute, config, index, builder)
+        builder.line "unless filters.drops?(#{index})"
+        builder.indent do
+          builder.line "value = #{method_attribute_call_expression(method_attribute)}"
+          builder.line "unless value.equal?(Panko::CodeGen::SKIP)"
+          builder.indent do
+            builder.line %(writer.push_value(value, "#{method_attribute.name}"))
+          end
+          builder.line "end"
+        end
+        builder.line "end"
+      end
+
+      def association(association, source_read_expr, config, index, builder)
+        builder.line "unless filters.drops?(#{index})"
+        builder.indent do
+          with_if_guard(association, builder) do
+            case association.kind
+            when :has_one
+              builder.line "value = #{source_read_expr}"
+              if config.null_for_missing_has_one
+                has_one_default(association, builder)
+              else
+                has_one_omit(association, builder)
+              end
+            when :has_many
+              has_many(association, source_read_expr, builder)
+            end
+          end
+        end
+        builder.line "end"
+      end
+
+      private
+
+      # +result+ starts nil so a body that raises hands checkin nil, and the writer is dropped.
+      def with_writer(config, builder, &block)
+        if config.pool_writer
+          builder.line "writer = POOL.checkout"
+          builder.line "result = nil"
+          builder.line "begin"
+          builder.indent(&block)
+          builder.line "ensure"
+          builder.indent do
+            builder.line "POOL.checkin(writer, result)"
+          end
+          builder.line "end"
+        else
+          builder.line "writer = Oj::StringWriter.new(mode: :rails)"
+          yield
+        end
+      end
+
+      def emit_serialize_one_body(config, builder)
+        if config.supports_root_key
+          builder.line "if root_key"
+          builder.indent do
+            builder.line "writer.push_object"
+            builder.line "writer.push_key(root_key)"
+          end
+          builder.line "end"
+        end
+        builder.line "#{GeneratedNames.write_one}(record, writer, context, scope, filters)"
+        builder.line "writer.pop if root_key" if config.supports_root_key
+        builder.line "result = writer.to_s"
+        builder.line "result.chomp!"
+        builder.line "result"
+      end
+
+      def emit_serialize_many_body(config, builder)
+        if config.supports_root_key
+          builder.line "writer.push_object if root_key"
+          builder.line "writer.push_array(root_key)"
+        else
+          builder.line "writer.push_array"
+        end
+        builder.line "records.each { |r| #{GeneratedNames.write_one}(r, writer, context, scope, filters) }"
+        builder.line "writer.pop"
+        builder.line "writer.pop if root_key" if config.supports_root_key
+        builder.line "result = writer.to_s"
+        builder.line "result.chomp!"
+        builder.line "result"
+      end
+
+      # A non-nil +has_one+ pushes its key separately instead of +push_object("name")+: the
+      # child's +_write_one+ opens its own +push_object+ frame.
+      def has_one_default(association, builder)
+        builder.line "if value.nil?"
+        builder.indent { builder.line %(writer.push_value(nil, "#{association.name}")) }
+        builder.line "else"
+        builder.indent do
+          builder.line %(writer.push_key("#{association.name}"))
+          child_write(association, "value", builder) do |ivar|
+            "#{ivar}.#{GeneratedNames.write_one}(value, writer, context, scope, #{child_filter_expr(association)})"
+          end
+        end
+        builder.line "end"
+      end
+
+      def has_one_omit(association, builder)
+        builder.line "unless value.nil?"
+        builder.indent do
+          builder.line %(writer.push_key("#{association.name}"))
+          child_write(association, "value", builder) do |ivar|
+            "#{ivar}.#{GeneratedNames.write_one}(value, writer, context, scope, #{child_filter_expr(association)})"
+          end
+        end
+        builder.line "end"
+      end
+
+      def has_many(association, source_read_expr, builder)
+        builder.line "child_filter = #{child_filter_expr(association)}"
+        builder.line %(writer.push_array("#{association.name}"))
+        builder.line "#{source_read_expr}.each do |element|"
+        builder.indent do
+          child_write(association, "element", builder) do |ivar|
+            "#{ivar}.#{GeneratedNames.write_one}(element, writer, context, scope, child_filter)"
+          end
+        end
+        builder.line "end"
+        builder.line "writer.pop"
+      end
+
+      # Raw column bytes are pushed only after a strict parse accepts them; anything else
+      # (non-String, empty, malformed) falls back to the typed read.
+      def json_column_attribute(attribute, config, index, builder)
+        if config.json_column_emit == :html_safe
+          attribute(attribute, %(record._read_attribute("#{attribute.source}")), config, index, builder)
+          return
+        end
+        source_lit = %("#{attribute.source}")
+        key_lit = %("#{attribute.name}")
+        builder.line "unless filters.drops?(#{index})"
+        builder.indent do
+          builder.line %(raw = record.read_attribute_before_type_cast(#{source_lit}))
+          builder.line "if raw.is_a?(String) && !raw.empty? && (begin"
+          builder.indent do
+            builder.line "Oj.sc_parse(Panko::CodeGen::JSON_NOOP_PARSER, raw, Panko::CodeGen::JSON_STRICT_PARSE_OPTS)"
+            builder.line "true"
+          end
+          builder.line "rescue Oj::ParseError, EncodingError"
+          builder.indent do
+            builder.line "false"
+          end
+          builder.line "end)"
+          builder.indent do
+            builder.line "writer.push_json(raw, #{key_lit})"
+          end
+          builder.line "else"
+          builder.indent do
+            builder.line "writer.push_value(record._read_attribute(#{source_lit}), #{key_lit})"
+          end
+          builder.line "end"
+        end
+        builder.line "end"
+      end
+
+      def datetime_column_attribute(attribute, index, builder)
+        source_lit = %("#{attribute.source}")
+        builder.line "unless filters.drops?(#{index})"
+        builder.indent do
+          builder.line "value = Panko::CodeGen::DateTimeFormat.format_raw(record.read_attribute_before_type_cast(#{source_lit}))"
+          builder.line %(writer.push_value(value || record._read_attribute(#{source_lit}), "#{attribute.name}"))
+        end
+        builder.line "end"
+      end
+    end
+  end
+end

data/lib/panko/code_gen/generators/record_access/generic.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Panko::CodeGen
+  module Generators
+    module RecordAccess
+      # Both field bodies are inlined under one +is_a?(Hash)+ branch: this saves a call per record,
+      # and each arm owns its call sites, so a Hash and an object never share one inline cache.
+      module Generic
+        # Above this field count the two bodies go into separate helper methods, which halves each
+        # method's size for JITs that compile whole methods (ZJIT).
+        FUSED_DISPATCH_MAX_FIELDS = 64
+
+        def self.emit(descriptor, config, field_index, builder, sink, method_name: sink.entry_name)
+          return emit_split(descriptor, config, field_index, builder, sink, method_name: method_name) if split_dispatch?(descriptor)
+
+          builder.line "def #{method_name}(#{sink.entry_params})"
+          builder.indent do
+            emit_parent_class_ivar_writes(descriptor, builder)
+            builder.line "if record.is_a?(Hash)"
+            builder.indent do
+              FieldWalk.emit_fields(
+                descriptor, config, field_index, builder, sink,
+                read_expr: ->(source) { hash_read_expr(source, config) }
+              )
+            end
+            builder.line "else"
+            builder.indent do
+              FieldWalk.emit_fields(
+                descriptor, config, field_index, builder, sink,
+                read_expr: ->(source) { "record.#{source}" }
+              )
+            end
+            builder.line "end"
+          end
+          builder.line "end"
+        end
+
+        def self.emit_split(descriptor, config, field_index, builder, sink, method_name: sink.entry_name)
+          builder.line "def #{method_name}(#{sink.entry_params})"
+          builder.indent do
+            emit_parent_class_ivar_writes(descriptor, builder)
+            builder.line "if record.is_a?(Hash)"
+            builder.indent { builder.line "#{sink.split_hash_helper}(#{sink.entry_params})" }
+            builder.line "else"
+            builder.indent { builder.line "#{sink.split_object_helper}(#{sink.entry_params})" }
+            builder.line "end"
+          end
+          builder.line "end"
+          builder.blank
+          builder.line "def #{sink.split_hash_helper}(#{sink.entry_params})"
+          builder.indent do
+            FieldWalk.emit_fields(
+              descriptor, config, field_index, builder, sink,
+              read_expr: ->(source) { hash_read_expr(source, config) }
+            )
+          end
+          builder.line "end"
+          builder.blank
+          builder.line "def #{sink.split_object_helper}(#{sink.entry_params})"
+          builder.indent do
+            FieldWalk.emit_fields(
+              descriptor, config, field_index, builder, sink,
+              read_expr: ->(source) { "record.#{source}" }
+            )
+          end
+          builder.line "end"
+        end
+
+        def self.split_dispatch?(descriptor)
+          descriptor.attributes.size + descriptor.method_attributes.size + descriptor.associations.size >
+            FUSED_DISPATCH_MAX_FIELDS
+        end
+
+        # Only a Symbol-body Method Attribute reads +@object+ / +@context+ / +@scope+ on +self+;
+        # Callable bodies get them as arguments, so without one the writes are wasted work per record.
+        def self.emit_parent_class_ivar_writes(descriptor, builder)
+          return if descriptor.method_attributes.none? { |method_attribute| method_attribute.body.is_a?(Symbol) }
+          builder.line "@object = record"
+          builder.line "@context = context"
+          builder.line "@scope = scope"
+        end
+
+        def self.hash_read_expr(source_name, config)
+          case config.hash_record_key_type
+          when :symbol then "record[:#{source_name}]"
+          else %(record["#{source_name}"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panko/code_gen/generators/record_access/specialized.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Panko::CodeGen
+  module Generators
+    module RecordAccess
+      # Records are assumed to be instances of the Descriptor's Model, so there is no Hash branch.
+      module Specialized
+        def self.emit(descriptor, config, field_index, builder, sink)
+          ar_model = ar_model(descriptor)
+          builder.line "def #{sink.entry_name}(#{sink.entry_params})"
+          builder.indent do
+            emit_model_guard(descriptor, config, "#{sink.generic_entry_name}(#{sink.entry_params})", builder)
+            Generic.emit_parent_class_ivar_writes(descriptor, builder)
+            FieldWalk.emit_fields(
+              descriptor, config, field_index, builder, sink,
+              read_expr: ->(source) { "record.#{source}" },
+              attribute_emit: ->(attribute, index) { sink.specialized_attribute(attribute, ar_model, config, index, builder) }
+            )
+          end
+          builder.line "end"
+          emit_generic_twin(config, builder) do
+            Generic.emit(descriptor, config, field_index, builder, sink, method_name: sink.generic_entry_name)
+          end
+        end
+
+        # Under auto-specialization nothing promises every record has the Model's class, so a record of
+        # another class (Hash, STI sibling, mixed array) goes to the generic twin instead of wrong output.
+        def self.emit_model_guard(descriptor, config, fallback_call, builder)
+          return unless config.guarded_model
+          model_name = descriptor.model.name
+          if model_name.nil?
+            raise CompileError,
+              "#{descriptor.name}: guarded_model requires a named Model class; got anonymous #{descriptor.model.inspect}"
+          end
+          builder.line "return #{fallback_call} unless record.instance_of?(::#{model_name})"
+        end
+
+        def self.emit_generic_twin(config, builder)
+          return unless config.guarded_model
+          builder.blank
+          yield
+        end
+
+        # A method the Model does not declare as an attribute reads the loaded attribute first, so a
+        # SELECT alias named like a method (+thing_ids+ next to +has_many :things+) returns the selected value.
+        def self.attribute_read_expr(attribute, ar_model)
+          source = attribute.source
+          return "record.#{source}" if ar_model.nil?
+          return %(record._read_attribute("#{source}")) if ActiveRecord::AccessClassifier.classify(ar_model, source) == :column
+          return "record.#{source}" if declared_attribute?(ar_model, source)
+          %((record._has_attribute?("#{source}") ? record._read_attribute("#{source}") : record.#{source}))
+        end
+
+        def self.declared_attribute?(ar_model, source)
+          ar_model.attribute_types.key?(source.to_s) || ar_model.attribute_aliases.key?(source.to_s)
+        end
+
+        # Called here too so the Generator works without the validators; repeating +ensure!+ is safe.
+        def self.ar_model(descriptor)
+          model = descriptor.model
+          return nil unless model.respond_to?(:columns_hash) && model.respond_to?(:attribute_methods_generated?)
+          ActiveRecord::DefineAttributeMethods.ensure!(model)
+          model
+        end
+
+        # Requires a +:column+ result because the column fast paths read past a user-overridden reader.
+        def self.json_column_attribute?(attribute, ar_model)
+          return false if ar_model.nil?
+          return false unless ActiveRecord::AccessClassifier.json_typed?(ar_model, attribute.source)
+          ActiveRecord::AccessClassifier.classify(ar_model, attribute.source) == :column
+        end
+
+        # Only under +:utc+ is the zoneless raw DB string really UTC, so the fast path's trailing "Z" is true.
+        # The +::+ matters: bare +ActiveRecord+ here resolves to +Panko::CodeGen::ActiveRecord+.
+        def self.datetime_column_attribute?(attribute, ar_model)
+          return false if ar_model.nil?
+          return false unless ::ActiveRecord.default_timezone == :utc
+          return false unless ActiveRecord::AccessClassifier.datetime_typed?(ar_model, attribute.source)
+          ActiveRecord::AccessClassifier.classify(ar_model, attribute.source) == :column
+        end
+
+        def self.plain_column_attribute?(attribute, ar_model)
+          return false if ar_model.nil?
+          return false unless ActiveRecord::AccessClassifier.plain_typed?(ar_model, attribute.source)
+          ActiveRecord::AccessClassifier.classify(ar_model, attribute.source) == :column
+        end
+      end
+    end
+  end
+end

data/lib/panko/code_gen/generators/release.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Panko::CodeGen
+  module Generators
+    # A pooled instance that kept +@object+ / +@context+ / +@scope+ after
+    # checkin would keep the last record graph alive in fiber-local storage.
+    module Release
+      module_function
+
+      # Must match the gate in +RecordAccess::Generic.emit_parent_class_ivar_writes+.
+      def ivar_writes?(descriptor)
+        descriptor.method_attributes.any? { |method_attribute| method_attribute.body.is_a?(Symbol) }
+      end
+
+      # Must follow the same edges as {emit} so the answer matches the
+      # emitted code.
+      def subtree_releases?(descriptor, cyclic_ids, seen = {})
+        return false if seen[descriptor.__id__]
+        seen[descriptor.__id__] = true
+        return true if ivar_writes?(descriptor)
+        descriptor.associations.flat_map(&:descriptors).any? do |child|
+          next false if child.equal?(descriptor)
+          next false if cyclic_ids[descriptor.__id__] && cyclic_ids[child.__id__]
+          subtree_releases?(child, cyclic_ids, seen)
+        end
+      end
+
+      def child_ivars(assoc)
+        variants = assoc.variants.each_with_index.map do |variant, index|
+          [GeneratedNames.variant_serializer_ivar(assoc, index), variant]
+        end
+        [[GeneratedNames.serializer_ivar(assoc), assoc.descriptor], *variants]
+      end
+
+      # Every class defines +_release+, even an empty one: the serializers call it
+      # on every checkin without checking.
+      def emit(descriptor, builder, cyclic_ids)
+        builder.line "def _release"
+        builder.indent do
+          if ivar_writes?(descriptor)
+            builder.line "@object = nil"
+            builder.line "@context = nil"
+            builder.line "@scope = nil"
+          end
+          descriptor.associations.each do |assoc|
+            child_ivars(assoc).each do |ivar, child|
+              next if child.equal?(descriptor)
+              # Ends the chain without per-call visited state; such serializers keep their last record until the next call.
+              next if cyclic_ids[descriptor.__id__] && cyclic_ids[child.__id__]
+              next unless subtree_releases?(child, cyclic_ids)
+              builder.line "#{ivar}._release"
+            end
+          end
+          builder.line "nil"
+        end
+        builder.line "end"
+      end
+    end
+  end
+end

data/lib/panko/code_gen/generators/sink.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Panko::CodeGen
+  module Generators
+    class Sink
+      # The child's +FIELD_INDEX+ is read through its class name when the method runs, so
+      # self-recursive Descriptors resolve it.
+      def child_filter_expr(association)
+        "filters.child(:#{GeneratedNames.filter_key(association)}, " \
+          "#{GeneratedNames.class_name(association.descriptor, suffix)}::#{GeneratedNames.field_index_const})"
+      end
+
+      # +case+/+when+, not an +if+/+elsif+ chain of +instance_of?+: under YJIT the chain gets
+      # slower once the call site has warmed on one class. HashSink uses the +case+ as an expression.
+      def child_write(association, record_expr, builder, &call_for)
+        base_call = call_for.call(GeneratedNames.serializer_ivar(association))
+        if association.variants.empty?
+          builder.line base_call
+          return
+        end
+        builder.line "case #{record_expr}"
+        subclass_first(association.variants).each do |variant, index|
+          model = "::#{variant.model.name}"
+          builder.line "when #{model}"
+          builder.indent do
+            builder.line "if #{record_expr}.instance_of?(#{model})"
+            builder.indent { builder.line call_for.call(GeneratedNames.variant_serializer_ivar(association, index)) }
+            builder.line "else"
+            builder.indent { builder.line base_call }
+            builder.line "end"
+          end
+        end
+        builder.line "else"
+        builder.indent { builder.line base_call }
+        builder.line "end"
+      end
+
+      # Each subclass before its ancestors, so a parent's +when+ arm does not take a declared
+      # subclass.
+      def subclass_first(variants)
+        variants.each_with_index.sort_by { |variant, index| [-variant.model.ancestors.size, index] }
+      end
+
+      # The guard wraps the Source read too, so a falsy +if:+ skips the read.
+      def with_if_guard(association, builder)
+        if association.if
+          builder.line "if #{if_guard_call_expression(GeneratedNames.if_guard_ivar(association), association.if.arity)}"
+          builder.indent { yield }
+          builder.line "end"
+        else
+          yield
+        end
+      end
+
+      # The +callable_arity+ rule limits arity to +0..3+, so +else+ is arity 3.
+      def if_guard_call_expression(ivar, arity)
+        case arity
+        when 0 then "#{ivar}.call"
+        when 1 then "#{ivar}.call(record)"
+        when 2 then "#{ivar}.call(record, context)"
+        else "#{ivar}.call(record, context, scope)"
+        end
+      end
+
+      # Symbol bodies need the explicit +self.+: a bare name such as +record+ or +value+ would
+      # resolve to a local of the generated method.
+      def method_attribute_call_expression(method_attribute)
+        body = method_attribute.body
+        return "self.#{body}" if body.is_a?(Symbol)
+        ivar = GeneratedNames.callable_ivar(method_attribute)
+        case body.arity
+        when 0 then "#{ivar}.call"
+        when 1 then "#{ivar}.call(record)"
+        when 2 then "#{ivar}.call(record, context)"
+        else "#{ivar}.call(record, context, scope)"
+        end
+      end
+    end
+  end
+end

data/lib/panko/code_gen/instance_pool.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Panko::CodeGen
+  # Fiber-local stack of Generated Class instances. An instance cannot be shared: writing a record
+  # can set +@object+/+@context+/+@scope+, so a nested serialize of the same class needs its own.
+  #
+  # After a code reload or SerializerCache.reset!, each fiber keeps its old stack (and the old
+  # class) until it ends. Accepted: reloads are a development feature and reset! is for tests.
+  class InstancePool
+    def initialize(key, compiled, descriptor)
+      # The pool's own object_id keeps a pool rebuilt after SerializerCache.reset! off the old
+      # pool's stacks, which hold instances of the old compiled class.
+      @key = :"#{key}_#{object_id}"
+      @compiled = compiled
+      @descriptor = descriptor
+    end
+
+    # Returns the stack itself so a checkout and checkin cost one +Thread.current+ lookup.
+    def stack
+      Thread.current[@key] ||= []
+    end
+
+    def build
+      @compiled.new(descriptor: @descriptor)
+    end
+  end
+end

data/lib/panko/code_gen/runtime.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../code_gen"
+require_relative "serializer_cache"
+require_relative "filter_adapter"
+
+module Panko
+  module CodeGen
+    module Runtime
+      module_function
+
+      def runtime_filters(serializer_class, context, scope, only, except)
+        if serializer_class.respond_to?(:filters_for)
+          overrides = serializer_class.filters_for(context, scope) || {}
+          only = overrides.fetch(:only, only)
+          except = overrides.fetch(:except, except)
+        end
+        return nil if blank?(only) && blank?(except)
+        FilterAdapter.to_engine_filters(blank?(only) ? nil : only, blank?(except) ? nil : except)
+      end
+
+      def blank?(filter)
+        filter.nil? || (filter.respond_to?(:empty?) && filter.empty?)
+      end
+    end
+  end
+end