protostar 0.1.0.beta1

data/lib/protostar/codec/decoder.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Codec
+    # Decodes the binary wire format into message objects, eagerly.
+    # @api private
+    module Decoder
+      RECURSION_LIMIT = 100
+
+      F = Message::FieldInfo
+      UTF_8 = Encoding::UTF_8
+      BINARY = Encoding::BINARY
+      # unpack directive of a packed run of fixed-width values
+      PACKED = F::FIXED.transform_values { |(_, d)| "#{d}*".freeze }.freeze
+
+      module_function
+
+      # @return [Message]
+      def decode(klass, bytes, recursion_limit: RECURSION_LIMIT, frozen: false)
+        r = Wire::Reader.new(bytes)
+        msg = klass.__empty
+        msg.__decode_fields(r, recursion_limit, 0, frozen)
+        msg.freeze if frozen
+        msg
+      end
+
+      # @return [Message, nil]
+      def decode_delimited(klass, source, **options)
+        if source.is_a?(String) || (defined?(IO::Buffer) && source.is_a?(IO::Buffer))
+          r = Wire::Reader.new(source)
+          length = r.read_varint
+          r.skip(length)
+          return decode(klass, r.buffer.byteslice(r.pos - length, length), **options)
+        end
+        length = read_io_varint(source)
+        return nil if length.nil?
+        data = length.zero? ? +"" : source.read(length)
+        if data.nil? || data.bytesize < length
+          raise DecodeError, "truncated delimited message: expected #{length} bytes, got #{data ? data.bytesize : 0}"
+        end
+        decode(klass, data, **options)
+      end
+
+      # A varint from an IO, byte by byte; nil at a clean end of input
+      def read_io_varint(io)
+        result = 0
+        shift = 0
+        loop do
+          byte = io.getbyte
+          if byte.nil?
+            return nil if shift == 0
+            raise DecodeError, "truncated length prefix"
+          end
+          result |= (byte & 0x7F) << shift
+          return result & Wire::MASK64 if byte < 0x80
+          shift += 7
+          raise DecodeError, "length prefix longer than 10 bytes" if shift >= 70
+        end
+      end
+
+      # Decodes one field whose tag was just read from offset `at`. The
+      # decoders generated for each class ({DecodeGenerator}) handle a class's
+      # own fields inline and come here for everything else.
+      # @return [Boolean] true when the tag ends the group being read
+      def field(msg, r, tag, at, depth, end_group, frozen)
+        number = tag >> 3
+        wt = tag & 7
+        if wt == Wire::END_GROUP
+          return true if number == end_group && end_group != 0
+          raise DecodeError.new("unmatched end of group #{number}", offset: at)
+        end
+        Wire::Reader.check_tag(tag, at)
+        info = msg.class.__by_number[number]
+        values = msg.__values
+        if info.nil?
+          unknown(msg, r, number, wt, depth)
+        elsif wt == info.wire_type
+          if info.map
+            map_entry(msg, values, info, r, depth, frozen)
+          elsif info.message?
+            if info.repeated
+              repeated_message(values, info, r, depth, frozen, at)
+            else
+              singular_message(values, info, r, depth, frozen, at)
+            end
+          elsif info.kind == F::ENUM
+            enum(msg, values, info, r)
+          elsif info.repeated
+            (values[info.index] ||= []) << scalar(r, info)
+          else
+            siblings = info.siblings
+            siblings&.each { |s| values[s] = nil }
+            values[info.index] = scalar(r, info)
+          end
+        elsif wt == Wire::LENGTH_DELIMITED && info.packable
+          packed(msg, values, info, r)
+        else
+          # a wire type that does not match the field makes it unknown, as in protoc
+          unknown(msg, r, number, wt, depth)
+        end
+        false
+      end
+
+      # Checks the end of a message's fields: a group must have seen its end tag
+      def finish(msg, r, end_group)
+        raise DecodeError.new("missing end of group #{end_group}", offset: r.pos) if end_group != 0
+        msg.__seal_unknown
+      end
+
+      def repeated_message(values, info, r, depth, frozen, at)
+        sub = info.message_class.__empty
+        nested(sub, info, r, depth, frozen, at)
+        (values[info.index] ||= []) << sub
+      end
+
+      def singular_message(values, info, r, depth, frozen, at)
+        i = info.index
+        sub = values[i]
+        if sub.nil?
+          siblings = info.siblings
+          siblings&.each { |s| values[s] = nil }
+          sub = values[i] = info.message_class.__empty
+        elsif sub.frozen?
+          sub = values[i] = sub.dup
+        end
+        nested(sub, info, r, depth, frozen, at)
+      end
+
+      # Reads a message or group value into `sub`
+      def nested(sub, info, r, depth, frozen, at)
+        raise DecodeError.new("recursion limit exceeded", offset: at) if depth <= 0
+        if info.kind == F::GROUP
+          sub.__decode_fields(r, depth - 1, info.number, frozen)
+        else
+          old = r.push_limit(r.read_varint)
+          sub.__decode_fields(r, depth - 1, 0, frozen)
+          r.pop_limit(old)
+        end
+        sub.freeze if frozen
+      end
+
+      def unknown(msg, r, number, wt, depth)
+        start = r.pos
+        r.skip_field(number, wt, depth)
+        bytes = r.buffer.byteslice(start, r.pos - start).force_encoding(BINARY).freeze
+        msg.__add_unknown(UnknownField.new(number, wt, bytes))
+      end
+
+      def enum(msg, values, info, r)
+        start = r.pos
+        n = r.read_int32
+        v = info.enum_names[n]
+        if v.nil?
+          if info.closed_enum
+            bytes = r.buffer.byteslice(start, r.pos - start).force_encoding(BINARY).freeze
+            msg.__add_unknown(UnknownField.new(info.number, Wire::VARINT, bytes))
+            return
+          end
+          v = n
+        end
+        if info.repeated
+          (values[info.index] ||= []) << v
+        else
+          siblings = info.siblings
+          siblings&.each { |s| values[s] = nil }
+          values[info.index] = v
+        end
+      end
+
+      # One value of a scalar field other than an enum
+      def scalar(r, info)
+        case info.kind
+        when F::INT32 then r.read_int32
+        when F::INT64 then r.read_int64
+        when F::UINT32 then r.read_uint32
+        when F::UINT64 then r.read_varint
+        when F::SINT32 then r.read_sint32
+        when F::SINT64 then r.read_sint64
+        when F::BOOL then r.read_varint != 0
+        when F::STRING then string(r, info)
+        when F::BYTES then r.read_bytes.freeze
+        when F::DOUBLE then r.read_double
+        when F::FLOAT then r.read_float
+        when F::FIXED32 then r.read_fixed32
+        when F::FIXED64 then r.read_fixed64
+        when F::SFIXED32 then r.read_sfixed32
+        when F::SFIXED64 then r.read_sfixed64
+        when F::ENUM then r.read_int32
+        else raise DecodeError, "#{info.descriptor.full_name} is not a scalar field"
+        end
+      end
+
+      def string(r, info)
+        s = r.read_bytes.force_encoding(UTF_8)
+        if info.utf8_validation && !s.valid_encoding?
+          raise DecodeError.new("invalid UTF-8 in #{info.descriptor.full_name}", offset: r.pos - s.bytesize)
+        end
+        s.freeze
+      end
+
+      # Keeps a closed enum's number that has no name as an unknown varint field
+      def closed_enum_value(msg, number, buf, start, pos)
+        bytes = buf.byteslice(start, pos - start).force_encoding(BINARY).freeze
+        msg.__add_unknown(UnknownField.new(number, Wire::VARINT, bytes))
+      end
+
+      def packed(msg, values, info, r)
+        old = r.push_limit(r.read_varint)
+        list = (values[info.index] ||= [])
+        kind = info.kind
+        if (fixed = F::FIXED[kind])
+          width = fixed[0]
+          length = r.limit - r.pos
+          raise DecodeError.new("packed #{info.descriptor.type} length #{length} is not a multiple of #{width}", offset: r.pos) unless (length % width).zero?
+          # one unpack for the whole run instead of a read per element
+          list.concat(r.read_raw(length).unpack(PACKED.fetch(kind)))
+        elsif kind == F::ENUM
+          names = info.enum_names
+          closed = info.closed_enum
+          while r.pos < r.limit
+            start = r.pos
+            n = r.read_int32
+            v = names[n]
+            if v
+              list << v
+            elsif closed
+              bytes = r.buffer.byteslice(start, r.pos - start).force_encoding(BINARY).freeze
+              msg.__add_unknown(UnknownField.new(info.number, Wire::VARINT, bytes))
+            else
+              list << n
+            end
+          end
+        else
+          list << scalar(r, info) while r.pos < r.limit
+        end
+        r.pop_limit(old)
+      end
+
+      def map_entry(msg, values, info, r, depth, frozen)
+        start = r.pos
+        old = r.push_limit(r.read_varint)
+        key_info = info.key
+        value_info = info.value
+        key = nil
+        value = nil
+        unknown_enum = false
+        while r.pos < r.limit
+          at = r.pos
+          tag = r.read_tag_varint
+          Wire::Reader.check_tag(tag, at)
+          number = tag >> 3
+          wt = tag & 7
+          if number == 1 && wt == key_info.wire_type
+            key = scalar(r, key_info)
+          elsif number == 2 && wt == value_info.wire_type
+            if value_info.message?
+              if value.nil?
+                value = value_info.message_class.__empty
+              elsif value.frozen?
+                value = value.dup
+              end
+              nested(value, value_info, r, depth, frozen, at)
+            elsif value_info.kind == F::ENUM
+              n = r.read_int32
+              value = value_info.enum_names[n]
+              if value.nil?
+                unknown_enum = value_info.closed_enum
+                value = n
+              else
+                unknown_enum = false
+              end
+            else
+              value = scalar(r, value_info)
+            end
+          else
+            raise DecodeError.new("unmatched end of group #{number}", offset: at) if wt == Wire::END_GROUP
+            r.skip_field(number, wt, depth)
+          end
+        end
+        r.pop_limit(old)
+        if unknown_enum
+          # protoc keeps the whole entry as an unknown field of the map
+          bytes = r.buffer.byteslice(start, r.pos - start).force_encoding(BINARY).freeze
+          msg.__add_unknown(UnknownField.new(info.number, Wire::LENGTH_DELIMITED, bytes))
+          return
+        end
+        key = key_info.default if key.nil?
+        if value.nil?
+          value = value_info.message? ? value_info.message_class.__empty : value_info.default
+        end
+        value.freeze if frozen
+        (values[info.index] ||= {})[key] = value
+      end
+    end
+  end
+end

data/lib/protostar/codec/encode_generator.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Codec
+    # Writes the two encoding passes of one message class as Ruby source and
+    # evals them into the class: `__size(sizes)`, which returns the encoded
+    # size and records it (and every packed run's) in `sizes`, and
+    # `__write(w, buf, sizes)`, which appends the fields to the Writer's
+    # buffer. Fields come in ascending number order, tags are literal bytes,
+    # one-byte varints are appended inline, and enum names map to numbers
+    # through a literal `case`. Maps, packed runs and unknown fields go to
+    # {Sizer} and {Encoder}.
+    #
+    # The generic loop over field descriptors this replaces spent most of
+    # its time on method calls into the field table.
+    # @api private
+    module EncodeGenerator
+      F = Message::FieldInfo
+
+      INT_BOUNDS = {
+        F::INT32 => [-0x8000_0000, 0x7FFF_FFFF], F::SINT32 => [-0x8000_0000, 0x7FFF_FFFF],
+        F::SFIXED32 => [-0x8000_0000, 0x7FFF_FFFF], F::UINT32 => [0, 0xFFFF_FFFF], F::FIXED32 => [0, 0xFFFF_FFFF],
+        F::INT64 => [-0x8000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF],
+        F::SINT64 => [-0x8000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF],
+        F::SFIXED64 => [-0x8000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF],
+        F::UINT64 => [0, 0xFFFF_FFFF_FFFF_FFFF], F::FIXED64 => [0, 0xFFFF_FFFF_FFFF_FFFF]
+      }.freeze
+
+      VARINT_KINDS = [F::INT32, F::INT64, F::UINT32, F::UINT64].freeze
+
+      module_function
+
+      # @param klass [Class]
+      # @param fields [Array<Message::FieldInfo>]
+      def install(klass, fields)
+        ordered = fields.sort_by(&:number)
+        klass.class_eval(source(ordered), "(protostar encoder #{klass.descriptor.full_name})", 1)
+      end
+
+      def source(fields)
+        <<~RUBY
+          # frozen_string_literal: true
+          def __size(sizes)
+            #{"values = @values" unless fields.empty?}
+            total = 0
+            #{fields.map { |f| size_field(f) }.join}
+            total += Protostar::Codec::Sizer.unknown(@unknown) if @unknown
+            sizes[self] = total
+          end
+
+          def __write(w, buf, sizes)
+            #{"values = @values" unless fields.empty?}
+            #{fields.map { |f| write_field(f) }.join}
+            Protostar::Codec::Encoder.unknown(w, @unknown) if @unknown
+            w.flush_if_full
+          end
+        RUBY
+      end
+
+      def info(f)
+        "self.class.__fields[#{f.index}]"
+      end
+
+      # The condition under which a field is written, with its value in `v`
+      def present(f)
+        i = f.index
+        if f.repeated || f.map
+          "unless (v = values[#{i}]).nil? || v.empty?"
+        elsif f.presence
+          "unless (v = values[#{i}]).nil?"
+        else
+          "v = values[#{i}]\nif #{nonzero(f)}"
+        end
+      end
+
+      # Negative zero is written, as protoc compares the bits
+      def nonzero(f)
+        case f.kind
+        when F::DOUBLE, F::FLOAT then "v != 0 || (1.0 / v) < 0"
+        when F::BOOL then "v"
+        when F::STRING, F::BYTES then "!v.empty?"
+        when F::ENUM
+          zero = f.enum_names[0]
+          zero ? "!v.equal?(#{zero.inspect}) && v != 0" : "v != 0"
+        else "v != 0"
+        end
+      end
+
+      def tag_bytes(f, wire_type = f.wire_type)
+        Wire.tag_bytes(f.number, wire_type).bytes
+      end
+
+      def size_field(f)
+        tag = tag_bytes(f).size
+        body = if f.map
+          "total += Protostar::Codec::Sizer.map(#{info(f)}, v, sizes)\n"
+        elsif f.packed
+          "#{packed_size(f)}sizes[v] = run\n" \
+            "total += #{tag_bytes(f, Wire::LENGTH_DELIMITED).size} + #{varint_size("run")} + run\n"
+        elsif f.repeated
+          repeated_size(f, tag)
+        else
+          tags = (f.kind == F::GROUP) ? tag * 2 : tag
+          "#{value_size(f, "v", "n")}total += #{tags} + n\n"
+        end
+        "# #{f.name}\n#{present(f)}\n#{body}end\n"
+      end
+
+      # Statements leaving the payload size of packed run `v` in `run`,
+      # checking each element as {Sizer.packed} does, without a call per element
+      def packed_size(f)
+        check = (f.kind == F::ENUM) ? "" : "Protostar::Codec::Sizer.invalid(#{info(f)}, e) unless #{valid(f, "e")}\n"
+        case f.kind
+        when *VARINT_KINDS, F::SINT32, F::SINT64, F::ENUM
+          "run = 0\n#{each_element("#{check}#{value_size(f, "e", "n")}run += n\n")}"
+        else
+          width = (f.kind == F::BOOL) ? 1 : F::FIXED.fetch(f.kind).first
+          "#{each_element(check)}run = #{width} * v.size\n"
+        end
+      end
+
+      # Statements appending packed run `v`'s payload
+      def packed_write(f)
+        case f.kind
+        when *VARINT_KINDS, F::SINT32, F::SINT64, F::ENUM then each_element(write_value(f, "e"))
+        when F::BOOL then each_element("buf << (e ? 1 : 0)\n")
+        when F::FLOAT then "buf << Protostar::Wire.pack_floats(v)\n"
+        else "v.pack(#{"#{F::FIXED.fetch(f.kind).last}*".inspect}, buffer: buf)\n"
+        end
+      end
+
+      def repeated_size(f, tag)
+        tag *= 2 if f.kind == F::GROUP
+        src = "total += #{tag} * v.size\n"
+        src << "k = #{info(f)}.message_class\n" if f.message?
+        check = (f.kind == F::ENUM) ? "" : "Protostar::Codec::Sizer.invalid(#{info(f)}, e) unless #{valid(f, "e")}\n"
+        src << each_element("#{check}#{value_size(f, "e", "n")}total += n\n")
+      end
+
+      # A loop running `body` with each element of `v` in `e`
+      def each_element(body)
+        "v.each do |e|\n#{body}end\n"
+      end
+
+      # Whether an element of a repeated field can be written; elements may
+      # have been pushed into the plain Array past the writers' checks
+      def valid(f, var)
+        case f.kind
+        when F::DOUBLE, F::FLOAT then "(#{var}.is_a?(Float) || #{var}.is_a?(Integer))"
+        when F::BOOL then "(#{var} == true || #{var} == false)"
+        when F::STRING, F::BYTES then "#{var}.is_a?(String)"
+        when F::MESSAGE, F::GROUP then "#{var}.instance_of?(k)"
+        else
+          min, max = INT_BOUNDS.fetch(f.kind)
+          "(#{var}.is_a?(Integer) && #{var} >= #{min} && #{var} <= #{max})"
+        end
+      end
+
+      def varint_size(var)
+        "(#{var} < 0x80 && #{var} >= 0 ? 1 : (#{var} < 0x4000 && #{var} >= 0 ? 2 : Protostar::Wire.varint_size(#{var})))"
+      end
+
+      # Statements leaving the size of value `var`, tag excluded, in `out`
+      def value_size(f, var, out)
+        case f.kind
+        when *VARINT_KINDS then "#{out} = #{varint_size(var)}\n"
+        when F::SINT32, F::SINT64 then "z = (#{var} << 1) ^ (#{var} >> 63)\n#{out} = #{varint_size("z")}\n"
+        when F::BOOL then "#{out} = 1\n"
+        when F::ENUM then "z = #{enum_number(f, var)}\n#{out} = #{varint_size("z")}\n"
+        when F::STRING, F::BYTES then "#{out} = #{var}.bytesize\n#{out} += #{varint_size(out)}\n"
+        when F::MESSAGE then "#{out} = #{var}.__size(sizes)\n#{out} += #{varint_size(out)}\n"
+        when F::GROUP then "#{out} = #{var}.__size(sizes)\n"
+        else "#{out} = #{F::FIXED.fetch(f.kind).first}\n"
+        end
+      end
+
+      # An expression for the number of enum value `var`
+      def enum_number(f, var)
+        src = "case #{var}\n"
+        f.enum_numbers.each { |name, number| src << "when #{name.inspect} then #{number}\n" }
+        src << "when Integer then (#{var} >= -0x8000_0000 && #{var} <= 0x7FFF_FFFF) ? #{var} : " \
+          "Protostar::Codec::Encoder.enum_number(#{info(f)}, #{var})\n"
+        src << "else Protostar::Codec::Encoder.enum_number(#{info(f)}, #{var})\nend"
+      end
+
+      def write_field(f)
+        body = if f.map
+          "Protostar::Codec::Encoder.map(#{info(f)}, v, w, sizes)\n"
+        elsif f.packed
+          "#{append(tag_bytes(f, Wire::LENGTH_DELIMITED))}#{write_varint("sizes[v]")}#{packed_write(f)}"
+        elsif f.repeated
+          each_element("#{append(tag_bytes(f))}#{write_value(f, "e")}")
+        else
+          "#{append(tag_bytes(f))}#{write_value(f, "v")}"
+        end
+        "# #{f.name}\n#{present(f)}\n#{body}end\n"
+      end
+
+      # Appending an Integer to a binary String appends that byte
+      def append(bytes)
+        "buf#{bytes.map { |b| " << #{b}" }.join}\n"
+      end
+
+      def write_varint(expr)
+        "if (x = #{expr}) < 0x80 && x >= 0\nbuf << x\nelsif x < 0x4000 && x >= 0\nbuf << ((x & 0x7F) | 0x80) << (x >> 7)\nelse\nw.write_varint(x)\nend\n"
+      end
+
+      def write_value(f, var)
+        case f.kind
+        when *VARINT_KINDS then write_varint(var)
+        when F::SINT32, F::SINT64 then write_varint("(#{var} << 1) ^ (#{var} >> 63)")
+        when F::BOOL then "buf << (#{var} ? 1 : 0)\n"
+        when F::ENUM then write_varint(enum_number(f, var))
+        when F::STRING, F::BYTES then "#{write_varint("#{var}.bytesize")}w.write_raw(#{var})\n"
+        when F::MESSAGE then "#{write_varint("sizes[#{var}]")}#{var}.__write(w, buf, sizes)\n"
+        when F::GROUP then "#{var}.__write(w, buf, sizes)\n#{append(tag_bytes(f, Wire::END_GROUP))}"
+        when F::FLOAT
+          "if #{var} == #{var}\n[#{var}].pack(\"e\", buffer: buf)\nelse\nbuf << Protostar::Wire.float_nan(#{var})\nend\n"
+        else "[#{var}].pack(#{F::FIXED.fetch(f.kind).last.inspect}, buffer: buf)\n"
+        end
+      end
+    end
+  end
+end

data/lib/protostar/codec/encoder.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Codec
+    # The second encoding pass writes fields in ascending number order, then
+    # unknown fields verbatim, using the sizes the first pass recorded. The
+    # per-class `__write` methods ({EncodeGenerator}) do the work; this
+    # module has the entry points and the parts they share.
+    # @api private
+    module Encoder
+      F = Message::FieldInfo
+      BINARY = Encoding::BINARY
+
+      module_function
+
+      # @return [String] binary
+      def encode(msg)
+        sizes = {}.compare_by_identity
+        size = msg.__size(sizes)
+        w = Wire::Writer.new(String.new(capacity: size, encoding: BINARY))
+        msg.__write(w, w.string, sizes)
+        w.string
+      end
+
+      def encode_to(msg, io)
+        sizes = {}.compare_by_identity
+        msg.__size(sizes)
+        w = Wire::Writer.new(io)
+        msg.__write(w, w.string, sizes)
+        w.flush
+      end
+
+      # @return [String, IO]
+      def encode_delimited(msg, io)
+        sizes = {}.compare_by_identity
+        size = msg.__size(sizes)
+        w = Wire::Writer.new(io || String.new(capacity: size + 10, encoding: BINARY))
+        w.write_varint(size)
+        msg.__write(w, w.string, sizes)
+        return w.string unless io
+        w.flush
+        io
+      end
+
+      # @return [Integer] the number of an enum value as stored (Symbol or Integer)
+      # @raise [EncodeError] for a name the enum does not have or an Integer out of int32 range
+      def enum_number(info, v)
+        if v.is_a?(Integer)
+          return v if Message::Coercion::ENUM_RANGE.cover?(v)
+        elsif (n = info.enum_numbers[v])
+          return n
+        end
+        raise EncodeError, "#{info.descriptor.full_name} holds #{v.inspect[0, 64]}, which is not a value of its enum"
+      end
+
+      # One value, without its tag; a group's end tag is written here
+      def value(info, v, w, sizes)
+        case info.kind
+        when F::INT32, F::INT64, F::UINT32, F::UINT64 then w.write_varint(v)
+        when F::ENUM then w.write_varint(enum_number(info, v))
+        when F::SINT32, F::SINT64 then w.write_varint((v << 1) ^ (v >> 63))
+        when F::BOOL then w.write_varint(v ? 1 : 0)
+        when F::STRING, F::BYTES then w.write_bytes(v)
+        when F::MESSAGE
+          w.write_varint(sizes.fetch(v))
+          v.__write(w, w.string, sizes)
+        when F::GROUP
+          v.__write(w, w.string, sizes)
+          w.write_raw(info.end_tag)
+        when F::DOUBLE then w.write_double(v)
+        when F::FLOAT then w.write_float(v)
+        when F::FIXED64 then w.write_fixed64(v)
+        when F::FIXED32 then w.write_fixed32(v)
+        when F::SFIXED64 then w.write_sfixed64(v)
+        when F::SFIXED32 then w.write_sfixed32(v)
+        end
+      end
+
+      # The payload of a packed run; tag and length are already written
+      def packed(info, list, w)
+        kind = info.kind
+        if kind == F::FLOAT
+          w.write_raw(Wire.pack_floats(list))
+        elsif (fixed = F::FIXED[kind])
+          # one pack for the whole run
+          w.write_raw(list.pack("#{fixed[1]}*"))
+        elsif kind == F::ENUM
+          list.each { |v| w.write_varint(enum_number(info, v)) }
+        elsif kind == F::BOOL
+          list.each { |v| w.write_varint(v ? 1 : 0) }
+        elsif kind == F::SINT32 || kind == F::SINT64
+          list.each { |v| w.write_varint((v << 1) ^ (v >> 63)) }
+        else
+          list.each { |v| w.write_varint(v) }
+        end
+      end
+
+      # Every entry of a map field, in insertion order, key then value
+      def map(info, hash, w, sizes)
+        key_info = info.key
+        value_info = info.value
+        hash.each do |key, val|
+          w.write_raw(info.tag)
+          w.write_varint(Sizer.entry(info, key, val, sizes))
+          w.write_raw(key_info.tag)
+          value(key_info, key, w, sizes)
+          w.write_raw(value_info.tag)
+          value(value_info, val, w, sizes)
+        end
+      end
+
+      # @param list [Array<UnknownField>]
+      def unknown(w, list)
+        list.each do |u|
+          w.write_varint((u.number << 3) | u.wire_type)
+          w.write_raw(u.bytes)
+        end
+      end
+    end
+  end
+end