google-protobuf 3.25.0 → 4.28.3

data/lib/google/protobuf/ffi/map.rb

@@ -9,18 +9,20 @@ module Google
   module Protobuf
     class FFI
       # Map
-      attach_function :map_clear,  :upb_Map_Clear,                    [:Map], :void
-      attach_function :map_delete, :upb_Map_Delete,                   [:Map, MessageValue.by_value, MessageValue.by_ref], :bool
-      attach_function :map_get,    :upb_Map_Get,                      [:Map, MessageValue.by_value, MessageValue.by_ref], :bool
-      attach_function :create_map, :upb_Map_New,                      [Internal::Arena, CType, CType], :Map
-      attach_function :map_size,   :upb_Map_Size,                     [:Map], :size_t
-      attach_function :map_set,    :upb_Map_Set,                      [:Map, MessageValue.by_value, MessageValue.by_value, Internal::Arena], :bool
+      attach_function :map_clear,   :upb_Map_Clear,         [:Map], :void
+      attach_function :map_delete,  :upb_Map_Delete,        [:Map, MessageValue.by_value, MessageValue.by_ref], :bool
+      attach_function :map_get,     :upb_Map_Get,           [:Map, MessageValue.by_value, MessageValue.by_ref], :bool
+      attach_function :create_map,  :upb_Map_New,           [Internal::Arena, CType, CType], :Map
+      attach_function :map_size,    :upb_Map_Size,          [:Map], :size_t
+      attach_function :map_set,     :upb_Map_Set,           [:Map, MessageValue.by_value, MessageValue.by_value, Internal::Arena], :bool
+      attach_function :map_freeze,  :upb_Map_Freeze,        [:Map, MiniTable.by_ref], :void
+      attach_function :map_frozen?, :upb_Map_IsFrozen,      [:Map], :bool
 
       # MapIterator
-      attach_function :map_next,   :upb_MapIterator_Next,             [:Map, :pointer], :bool
-      attach_function :map_done,   :upb_MapIterator_Done,             [:Map, :size_t], :bool
-      attach_function :map_key,    :upb_MapIterator_Key,              [:Map, :size_t], MessageValue.by_value
-      attach_function :map_value,  :upb_MapIterator_Value,            [:Map, :size_t], MessageValue.by_value
+      attach_function :map_next,    :upb_MapIterator_Next,  [:Map, :pointer], :bool
+      attach_function :map_done,    :upb_MapIterator_Done,  [:Map, :size_t], :bool
+      attach_function :map_key,     :upb_MapIterator_Key,   [:Map, :size_t], MessageValue.by_value
+      attach_function :map_value,   :upb_MapIterator_Value, [:Map, :size_t], MessageValue.by_value
     end
     class Map
       include Enumerable
@@ -155,6 +157,37 @@ module Google
       end
       alias size length
 
+      ##
+      # Is this object frozen?
+      # Returns true if either this Ruby wrapper or the underlying
+      # representation are frozen. Freezes the wrapper if the underlying
+      # representation is already frozen but this wrapper isn't.
+      def frozen?
+        unless Google::Protobuf::FFI.map_frozen? @map_ptr
+          raise RuntimeError.new "Ruby frozen Map with mutable representation" if super
+          return false
+        end
+        method(:freeze).super_method.call unless super
+        true
+      end
+
+      ##
+      # Freezes the map object. We have to intercept this so we can freeze the
+      # underlying representation, not just the Ruby wrapper. Returns self.
+      def freeze
+        if method(:frozen?).super_method.call
+          unless Google::Protobuf::FFI.map_frozen? @map_ptr
+            raise RuntimeError.new "Underlying representation of map still mutable despite frozen wrapper"
+          end
+          return self
+        end
+        unless Google::Protobuf::FFI.map_frozen? @map_ptr
+          mini_table = (value_type == :message) ? Google::Protobuf::FFI.get_mini_table(@descriptor) : nil
+          Google::Protobuf::FFI.map_freeze(@map_ptr, mini_table)
+        end
+        super
+      end
+
       ##
       # call-seq:
       #    Map.dup => new_map
@@ -358,10 +391,14 @@ module Google
         OBJECT_CACHE.try_add(@map_ptr.address, self)
       end
 
-      # @param field [FieldDescriptor] Descriptor of the field where the RepeatedField will be assigned
-      # @param values [Hash|Map] Initial value; may be nil or empty
+      ##
+      # Constructor that uses the type information from the given
+      # FieldDescriptor to configure the new Map instance.
+      # @param field [FieldDescriptor] Type information for the new Map
       # @param arena [Arena] Owning message's arena
-      def self.construct_for_field(field, arena, value: nil, map: nil)
+      # @param value [Hash|Map] Initial value
+      # @param map [::FFI::Pointer] Existing upb_Map
+      def self.construct_for_field(field, arena: nil, value: nil, map: nil)
         raise ArgumentError.new "Expected Hash object as initializer value for map field '#{field.name}' (given #{value.class})." unless value.nil? or value.is_a? Hash
         instance = allocate
         raise ArgumentError.new "Expected field with type :message, instead got #{field.class}" unless field.type == :message

data/lib/google/protobuf/ffi/message.rb

@@ -19,10 +19,14 @@ module Google
       attach_function :encode_message,          :upb_Encode,                  [:Message, MiniTable.by_ref, :size_t, Internal::Arena, :pointer, :pointer], EncodeStatus
       attach_function :json_decode_message,     :upb_JsonDecode,              [:binary_string, :size_t, :Message, Descriptor, :DefPool, :int, Internal::Arena, Status.by_ref], :bool
       attach_function :json_encode_message,     :upb_JsonEncode,              [:Message, Descriptor, :DefPool, :int, :binary_string, :size_t, Status.by_ref], :size_t
-      attach_function :decode_message,          :upb_Decode,                              [:binary_string, :size_t, :Message, MiniTable.by_ref, :ExtensionRegistry, :int, Internal::Arena], DecodeStatus
+      attach_function :decode_message,          :upb_Decode,                  [:binary_string, :size_t, :Message, MiniTable.by_ref, :ExtensionRegistry, :int, Internal::Arena], DecodeStatus
       attach_function :get_mutable_message,     :upb_Message_Mutable,         [:Message, FieldDescriptor, Internal::Arena], MutableMessageValue.by_value
-      attach_function :get_message_which_oneof, :upb_Message_WhichOneof,      [:Message, OneofDescriptor], FieldDescriptor
+      attach_function :get_message_which_oneof, :upb_Message_WhichOneofByDef, [:Message, OneofDescriptor], FieldDescriptor
       attach_function :message_discard_unknown, :upb_Message_DiscardUnknown,  [:Message, Descriptor, :int], :bool
+      attach_function :message_next,            :upb_Message_Next,            [:Message, Descriptor, :DefPool, :FieldDefPointer, MessageValue.by_ref, :pointer], :bool
+      attach_function :message_freeze,          :upb_Message_Freeze,          [:Message, MiniTable.by_ref], :void
+      attach_function :message_frozen?,         :upb_Message_IsFrozen,        [:Message], :bool
+
       # MessageValue
       attach_function :message_value_equal,     :shared_Msgval_IsEqual,       [MessageValue.by_value, MessageValue.by_value, CType, Descriptor], :bool
       attach_function :message_value_hash,      :shared_Msgval_GetHash,       [MessageValue.by_value, CType, Descriptor, :uint64_t], :uint64_t
@@ -57,11 +61,35 @@ module Google
             instance
           end
 
+          ##
+          # Is this object frozen?
+          # Returns true if either this Ruby wrapper or the underlying
+          # representation are frozen. Freezes the wrapper if the underlying
+          # representation is already frozen but this wrapper isn't.
+          def frozen?
+            unless Google::Protobuf::FFI.message_frozen? @msg
+              raise RuntimeError.new "Ruby frozen Message with mutable representation" if super
+              return false
+            end
+            method(:freeze).super_method.call unless super
+            true
+          end
+
+          ##
+          # Freezes the map object. We have to intercept this so we can freeze the
+          # underlying representation, not just the Ruby wrapper. Returns self.
           def freeze
+            if method(:frozen?).super_method.call
+              unless Google::Protobuf::FFI.message_frozen? @msg
+                raise RuntimeError.new "Underlying representation of message still mutable despite frozen wrapper"
+              end
+              return self
+            end
+            unless Google::Protobuf::FFI.message_frozen? @msg
+              Google::Protobuf::FFI.message_freeze(@msg, Google::Protobuf::FFI.get_mini_table(self.class.descriptor))
+            end
             super
-            @arena.pin self
-            self
-          end
+         end
 
           def dup
             duplicate = self.class.private_constructor(@arena)
@@ -170,7 +198,15 @@ module Google
 
             message = new
             mini_table_ptr = Google::Protobuf::FFI.get_mini_table(message.class.descriptor)
-            status = Google::Protobuf::FFI.decode_message(data, data.bytesize, message.instance_variable_get(:@msg), mini_table_ptr, nil, decoding_options, message.instance_variable_get(:@arena))
+            status = Google::Protobuf::FFI.decode_message(
+              data,
+              data.bytesize,
+              message.instance_variable_get(:@msg),
+              mini_table_ptr,
+              Google::Protobuf::FFI.get_extension_registry(message.class.descriptor.send(:pool).descriptor_pool),
+              decoding_options,
+              message.instance_variable_get(:@arena)
+            )
             raise ParseError.new "Error occurred during parsing" unless status == :Ok
             message
           end
@@ -293,42 +329,136 @@ module Google
 
           include Google::Protobuf::Internal::Convert
 
+          ##
+          # Checks ObjectCache for a sentinel empty frozen Map of the key and
+          # value types matching the field descriptor's MessageDef and returns
+          # the cache entry. If an entry is not found, one is created and added
+          # to the cache keyed by the MessageDef pointer first.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def empty_frozen_map(field_descriptor)
+            sub_message_def = Google::Protobuf::FFI.get_subtype_as_message field_descriptor
+            frozen_map = OBJECT_CACHE.get sub_message_def
+            if frozen_map.nil?
+              frozen_map = Google::Protobuf::Map.send(:construct_for_field, field_descriptor)
+              OBJECT_CACHE.try_add(sub_message_def, frozen_map.freeze)
+            end
+            raise "Empty Frozen Map is not frozen" unless frozen_map.frozen?
+            frozen_map
+          end
+
+          ##
+          # Returns a frozen Map instance for the given field. If the message
+          # already has a value for that field, it is used. If not, a sentinel
+          # (per FieldDescriptor) empty frozen Map is returned instead.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def frozen_map_from_field_descriptor(field_descriptor)
+            message_value = Google::Protobuf::FFI.get_message_value @msg, field_descriptor
+            return empty_frozen_map field_descriptor if message_value[:map_val].null?
+            get_map_field(message_value[:map_val], field_descriptor).freeze
+          end
+
+          ##
+          # Returns a Map instance for the given field. If the message is frozen
+          # the return value is also frozen. If not, a mutable instance is
+          # returned instead.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def map_from_field_descriptor(field_descriptor)
+            return frozen_map_from_field_descriptor field_descriptor if frozen?
+            mutable_message_value = Google::Protobuf::FFI.get_mutable_message @msg, field_descriptor, @arena
+            get_map_field(mutable_message_value[:map], field_descriptor)
+          end
+
+          ##
+          # Checks ObjectCache for a sentinel empty frozen RepeatedField of the
+          # value type matching the field descriptor's MessageDef and returns
+          # the cache entry. If an entry is not found, one is created and added
+          # to the cache keyed by the MessageDef pointer first.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def empty_frozen_repeated_field(field_descriptor)
+            sub_message_def = Google::Protobuf::FFI.get_subtype_as_message field_descriptor
+            frozen_repeated_field = OBJECT_CACHE.get sub_message_def
+            if frozen_repeated_field.nil?
+              frozen_repeated_field = Google::Protobuf::RepeatedField.send(:construct_for_field, field_descriptor)
+              OBJECT_CACHE.try_add(sub_message_def, frozen_repeated_field.freeze)
+            end
+            raise "Empty frozen RepeatedField is not frozen" unless frozen_repeated_field.frozen?
+            frozen_repeated_field
+          end
+
+          ##
+          # Returns a frozen RepeatedField instance for the given field. If the
+          # message already has a value for that field, it is used. If not, a
+          # sentinel (per FieldDescriptor) empty frozen RepeatedField is
+          # returned instead.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def frozen_repeated_field_from_field_descriptor(field_descriptor)
+            message_value = Google::Protobuf::FFI.get_message_value @msg, field_descriptor
+            return empty_frozen_repeated_field field_descriptor if message_value[:array_val].null?
+            get_repeated_field(message_value[:array_val], field_descriptor).freeze
+          end
+
+          ##
+          # Returns a RepeatedField instance for the given field. If the message
+          # is frozen the return value is also frozen. If not, a mutable
+          # instance is returned instead.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def repeated_field_from_field_descriptor(field_descriptor)
+            return frozen_repeated_field_from_field_descriptor field_descriptor if frozen?
+            mutable_message_value = Google::Protobuf::FFI.get_mutable_message @msg, field_descriptor, @arena
+            get_repeated_field(mutable_message_value[:array], field_descriptor)
+          end
+
+          ##
+          # Returns a Message instance for the given field. If the message
+          # is frozen nil is always returned. Otherwise, a mutable instance is
+          # returned instead.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def message_from_field_descriptor(field_descriptor)
+            return nil if frozen?
+            return nil unless Google::Protobuf::FFI.get_message_has @msg, field_descriptor
+            mutable_message = Google::Protobuf::FFI.get_mutable_message @msg, field_descriptor, @arena
+            sub_message = mutable_message[:msg]
+            sub_message_def = Google::Protobuf::FFI.get_subtype_as_message field_descriptor
+            Descriptor.send(:get_message, sub_message, sub_message_def, @arena)
+          end
+
+          ##
+          # Returns a scalar value for the given field. If the message
+          # is frozen the return value is also frozen.
+          # @param field_descriptor [FieldDescriptor] Field to retrieve.
+          def scalar_from_field_descriptor(field_descriptor)
+            c_type = field_descriptor.send(:c_type)
+            message_value = Google::Protobuf::FFI.get_message_value @msg, field_descriptor
+            msg_or_enum_def = c_type == :enum ? Google::Protobuf::FFI.get_subtype_as_enum(field_descriptor) : nil
+            return_value = convert_upb_to_ruby message_value, c_type, msg_or_enum_def
+            frozen? ? return_value.freeze : return_value
+          end
+
+          ##
+          # Dynamically define accessors methods for every field of @descriptor.
+          # Methods with names that conflict with existing methods are skipped.
           def self.setup_accessors!
             @descriptor.each do |field_descriptor|
               field_name = field_descriptor.name
               unless instance_methods(true).include?(field_name.to_sym)
-                #TODO - at a high level, dispatching to either
-                # index_internal or get_field would be logically correct, but slightly slower.
+                # Dispatching to either index_internal or get_field is logically
+                # correct, but slightly slower due to having to perform extra
+                # lookups on each invocation rather than doing it once here.
                 if field_descriptor.map?
                   define_method(field_name) do
-                    mutable_message_value = Google::Protobuf::FFI.get_mutable_message @msg, field_descriptor, @arena
-                    get_map_field(mutable_message_value[:map], field_descriptor)
+                    map_from_field_descriptor field_descriptor
                   end
                 elsif field_descriptor.repeated?
                   define_method(field_name) do
-                    mutable_message_value = Google::Protobuf::FFI.get_mutable_message @msg, field_descriptor, @arena
-                    get_repeated_field(mutable_message_value[:array], field_descriptor)
+                    repeated_field_from_field_descriptor field_descriptor
                   end
                 elsif field_descriptor.sub_message?
                   define_method(field_name) do
-                    return nil unless Google::Protobuf::FFI.get_message_has @msg, field_descriptor
-                    mutable_message = Google::Protobuf::FFI.get_mutable_message @msg, field_descriptor, @arena
-                    sub_message = mutable_message[:msg]
-                    sub_message_def = Google::Protobuf::FFI.get_subtype_as_message(field_descriptor)
-                    Descriptor.send(:get_message, sub_message, sub_message_def, @arena)
+                    message_from_field_descriptor field_descriptor
                   end
                 else
-                  c_type = field_descriptor.send(:c_type)
-                  if c_type == :enum
-                    define_method(field_name) do
-                      message_value = Google::Protobuf::FFI.get_message_value @msg, field_descriptor
-                      convert_upb_to_ruby message_value, c_type, Google::Protobuf::FFI.get_subtype_as_enum(field_descriptor)
-                    end
-                  else
-                    define_method(field_name) do
-                      message_value = Google::Protobuf::FFI.get_message_value @msg, field_descriptor
-                      convert_upb_to_ruby message_value, c_type
-                    end
+                  define_method(field_name) do
+                    scalar_from_field_descriptor field_descriptor
                   end
                 end
                 define_method("#{field_name}=") do |value|
@@ -338,14 +468,16 @@ module Google
                   clear_internal(field_descriptor)
                 end
                 if field_descriptor.type == :enum
-                  define_method("#{field_name}_const") do
-                    if field_descriptor.repeated?
+                  if field_descriptor.repeated?
+                    define_method("#{field_name}_const") do
                       return_value = []
-                      get_field(field_descriptor).send(:each_msg_val) do |msg_val|
+                      repeated_field_from_field_descriptor(field_descriptor).send(:each_msg_val) do |msg_val|
                         return_value << msg_val[:int32_val]
                       end
                       return_value
-                    else
+                    end
+                  else
+                    define_method("#{field_name}_const") do
                       message_value = Google::Protobuf::FFI.get_message_value @msg, field_descriptor
                       message_value[:int32_val]
                     end
@@ -372,12 +504,21 @@ module Google
             end
           end
 
+          ##
+          # Dynamically define accessors methods for every OneOf field of
+          # @descriptor.
           def self.setup_oneof_accessors!
             @oneof_field_names = []
             @descriptor.each_oneof do |oneof_descriptor|
               self.add_oneof_accessors_for! oneof_descriptor
             end
           end
+
+          ##
+          # Dynamically define accessors methods for the given OneOf field.
+          # Methods with names that conflict with existing methods are skipped.
+          # @param oneof_descriptor [OneofDescriptor] Field to create accessors
+          # for.
           def self.add_oneof_accessors_for!(oneof_descriptor)
             field_name = oneof_descriptor.name.to_sym
             @oneof_field_names << field_name
@@ -508,6 +649,10 @@ module Google
             Google::Protobuf::FFI.clear_message_field(@msg, field_def)
           end
 
+          # Accessor for field by name. Does not delegate to methods setup by
+          # self.setup_accessors! in order to avoid conflicts with bad field
+          # names e.g. `dup` or `class` which are perfectly valid for proto
+          # fields.
           def index_internal(name)
             field_descriptor = self.class.descriptor.lookup(name)
             get_field field_descriptor unless field_descriptor.nil?
@@ -535,7 +680,7 @@ module Google
           #   one if omitted or nil.
           def initialize(initial_value = nil, arena = nil, msg = nil)
             @arena = arena || Google::Protobuf::FFI.create_arena
-            @msg = msg || Google::Protobuf::FFI.new_message_from_def(self.class.descriptor, @arena)
+            @msg = msg || Google::Protobuf::FFI.new_message_from_def(Google::Protobuf::FFI.get_mini_table(self.class.descriptor), @arena)
 
             unless initial_value.nil?
               raise ArgumentError.new "Expected hash arguments or message, not #{initial_value.class}" unless initial_value.respond_to? :each
@@ -556,9 +701,9 @@ module Google
 
                 next if value.nil?
                 if field_descriptor.map?
-                  index_assign_internal(Google::Protobuf::Map.send(:construct_for_field, field_descriptor, @arena, value: value), name: key.to_s)
+                  index_assign_internal(Google::Protobuf::Map.send(:construct_for_field, field_descriptor, arena: @arena, value: value), name: key.to_s)
                 elsif field_descriptor.repeated?
-                  index_assign_internal(RepeatedField.send(:construct_for_field, field_descriptor, @arena, values: value), name: key.to_s)
+                  index_assign_internal(RepeatedField.send(:construct_for_field, field_descriptor, arena: @arena, values: value), name: key.to_s)
                 else
                   index_assign_internal(value, name: key.to_s)
                 end
@@ -571,21 +716,20 @@ module Google
           end
 
           ##
-          # Gets a field of this message identified by the argument definition.
+          # Gets a field of this message identified by FieldDescriptor.
           #
-          # @param field [FieldDescriptor] Descriptor of the field to get
+          # @param field [FieldDescriptor] Field to retrieve.
+          # @param unwrap [Boolean](false) If true, unwraps wrappers.
           def get_field(field, unwrap: false)
             if field.map?
-              mutable_message_value = Google::Protobuf::FFI.get_mutable_message @msg, field, @arena
-              get_map_field(mutable_message_value[:map], field)
+              map_from_field_descriptor field
             elsif field.repeated?
-              mutable_message_value = Google::Protobuf::FFI.get_mutable_message @msg, field, @arena
-              get_repeated_field(mutable_message_value[:array], field)
+              repeated_field_from_field_descriptor field
             elsif field.sub_message?
               return nil unless Google::Protobuf::FFI.get_message_has @msg, field
-              sub_message_def = Google::Protobuf::FFI.get_subtype_as_message(field)
               if unwrap
                 if field.has?(self)
+                  sub_message_def = Google::Protobuf::FFI.get_subtype_as_message field
                   wrapper_message_value = Google::Protobuf::FFI.get_message_value @msg, field
                   fields = Google::Protobuf::FFI.field_count(sub_message_def)
                   raise "Sub message has #{fields} fields! Expected exactly 1." unless fields == 1
@@ -596,41 +740,37 @@ module Google
                   nil
                 end
               else
-                mutable_message = Google::Protobuf::FFI.get_mutable_message @msg, field, @arena
-                sub_message = mutable_message[:msg]
-                Descriptor.send(:get_message, sub_message, sub_message_def, @arena)
+                message_from_field_descriptor field
               end
             else
-              c_type = field.send(:c_type)
-              message_value = Google::Protobuf::FFI.get_message_value @msg, field
-              if c_type == :enum
-                convert_upb_to_ruby message_value, c_type, Google::Protobuf::FFI.get_subtype_as_enum(field)
-              else
-                convert_upb_to_ruby message_value, c_type
-              end
+              scalar_from_field_descriptor field
             end
           end
 
           ##
-          # @param array [::FFI::Pointer] Pointer to the Array
+          # Gets a RepeatedField from the ObjectCache or creates a new one.
+          # @param array [::FFI::Pointer] Pointer to the upb_Array
           # @param field [Google::Protobuf::FieldDescriptor] Type of the repeated field
           def get_repeated_field(array, field)
             return nil if array.nil? or array.null?
             repeated_field = OBJECT_CACHE.get(array.address)
             if repeated_field.nil?
-              repeated_field = RepeatedField.send(:construct_for_field, field, @arena, array: array)
+              repeated_field = RepeatedField.send(:construct_for_field, field, arena: @arena, array: array)
+              repeated_field.freeze if frozen?
             end
             repeated_field
           end
 
           ##
-          # @param map [::FFI::Pointer] Pointer to the Map
+          # Gets a Map from the ObjectCache or creates a new one.
+          # @param map [::FFI::Pointer] Pointer to the upb_Map
           # @param field [Google::Protobuf::FieldDescriptor] Type of the map field
           def get_map_field(map, field)
             return nil if map.nil? or map.null?
             map_field = OBJECT_CACHE.get(map.address)
             if map_field.nil?
-              map_field = Google::Protobuf::Map.send(:construct_for_field, field, @arena, map: map)
+              map_field = Google::Protobuf::Map.send(:construct_for_field, field, arena: @arena, map: map)
+              map_field.freeze if frozen?
             end
             map_field
           end

data/lib/google/protobuf/ffi/method_descriptor.rb

@@ -0,0 +1,114 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2024 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    class MethodDescriptor 
+      attr :method_def, :descriptor_pool
+
+      include Google::Protobuf::Internal::Convert
+
+      # FFI Interface methods and setup
+      extend ::FFI::DataConverter
+      native_type ::FFI::Type::POINTER
+
+      class << self
+        prepend Google::Protobuf::Internal::TypeSafety
+        include Google::Protobuf::Internal::PointerHelper
+
+        # @param value [MethodDescriptor] MethodDescriptor to convert to an FFI native type
+        # @param _ [Object] Unused
+        def to_native(value, _)
+          method_def_ptr = value.nil? ? nil : value.instance_variable_get(:@method_def)
+          return ::FFI::Pointer::NULL if method_def_ptr.nil?
+          raise "Underlying method_def was null!" if method_def_ptr.null?
+          method_def_ptr
+        end
+
+        ##
+        # @param service_def [::FFI::Pointer] MethodDef pointer to be wrapped
+        # @param _ [Object] Unused
+        def from_native(method_def, _ = nil)
+          return nil if method_def.nil? or method_def.null?
+          service_def = Google::Protobuf::FFI.raw_service_def_by_raw_method_def(method_def)
+          file_def = Google::Protobuf::FFI.file_def_by_raw_service_def(service_def)
+          descriptor_from_file_def(file_def, method_def)
+        end
+      end
+
+      def self.new(*arguments, &block)
+        raise "Descriptor objects may not be created from Ruby."
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        "#{self.class.name}: #{name}"
+      end
+
+      def name
+        @name ||= Google::Protobuf::FFI.get_method_name(self)
+      end
+
+      def options
+        @options ||= begin
+          size_ptr = ::FFI::MemoryPointer.new(:size_t, 1)
+          temporary_arena = Google::Protobuf::FFI.create_arena
+          buffer = Google::Protobuf::FFI.method_options(self, size_ptr, temporary_arena)
+          Google::Protobuf::MethodOptions.decode(buffer.read_string_length(size_ptr.read(:size_t)).force_encoding("ASCII-8BIT").freeze).freeze
+        end
+      end
+
+      def input_type
+        @input_type ||= Google::Protobuf::FFI.method_input_type(self)
+      end
+
+      def output_type
+        @output_type ||= Google::Protobuf::FFI.method_output_type(self)
+      end
+
+      def client_streaming
+        @client_streaming ||= Google::Protobuf::FFI.method_client_streaming(self)
+      end
+
+      def server_streaming
+        @server_streaming ||= Google::Protobuf::FFI.method_server_streaming(self)
+      end
+
+      private
+
+      def initialize(method_def, descriptor_pool)
+        @method_def = method_def
+        @descriptor_pool = descriptor_pool
+      end
+
+      def self.private_constructor(method_def, descriptor_pool)
+        instance = allocate
+        instance.send(:initialize, method_def, descriptor_pool)
+        instance
+      end
+
+      def c_type
+        @c_type ||= Google::Protobuf::FFI.get_c_type(self)
+      end
+    end
+
+    class FFI
+      # MethodDef
+      attach_function :raw_service_def_by_raw_method_def, :upb_MethodDef_Service,                 [:pointer], :pointer
+      attach_function :get_method_name,                   :upb_MethodDef_Name,                    [MethodDescriptor], :string
+      attach_function :method_options,                    :MethodDescriptor_serialized_options,   [MethodDescriptor, :pointer, Internal::Arena], :pointer
+      attach_function :method_input_type,                 :upb_MethodDef_InputType,               [MethodDescriptor], Descriptor
+      attach_function :method_output_type,                :upb_MethodDef_OutputType,              [MethodDescriptor], Descriptor
+      attach_function :method_client_streaming,           :upb_MethodDef_ClientStreaming,         [MethodDescriptor], :bool
+      attach_function :method_server_streaming,           :upb_MethodDef_ServerStreaming,         [MethodDescriptor], :bool
+    end
+  end
+end
+

data/lib/google/protobuf/ffi/object_cache.rb

@@ -18,13 +18,13 @@ module Google
 
     def self.cache_implementation
       if interpreter_supports_non_finalized_keys_in_weak_map? and SIZEOF_LONG >= SIZEOF_VALUE
-        Google::Protobuf::ObjectCache
+        Google::Protobuf::Internal::ObjectCache
       else
-        Google::Protobuf::LegacyObjectCache
+        Google::Protobuf::Internal::LegacyObjectCache
       end
     end
 
     public
     OBJECT_CACHE = cache_implementation.new
   end
-end
+end

data/lib/google/protobuf/ffi/oneof_descriptor.rb

@@ -22,10 +22,7 @@ module Google
         # @param value [OneofDescriptor] FieldDescriptor to convert to an FFI native type
         # @param _ [Object] Unused
         def to_native(value, _ = nil)
-          oneof_def_ptr = value.instance_variable_get(:@oneof_def)
-          warn "Underlying oneof_def was nil!" if oneof_def_ptr.nil?
-          raise "Underlying oneof_def was null!" if !oneof_def_ptr.nil? and oneof_def_ptr.null?
-          oneof_def_ptr
+          value.instance_variable_get(:@oneof_def) || ::FFI::Pointer::NULL
         end
 
         ##
@@ -56,6 +53,17 @@ module Google
         nil
       end
 
+      def options
+        @options ||= begin
+          size_ptr = ::FFI::MemoryPointer.new(:size_t, 1)
+          temporary_arena = Google::Protobuf::FFI.create_arena
+          buffer = Google::Protobuf::FFI.oneof_options(self, size_ptr, temporary_arena)
+          opts = Google::Protobuf::OneofOptions.decode(buffer.read_string_length(size_ptr.read(:size_t)).force_encoding("ASCII-8BIT").freeze)
+          opts.clear_features()
+          opts.freeze
+       end
+      end
+
       private
 
       def initialize(oneof_def, descriptor_pool)
@@ -72,17 +80,18 @@ module Google
 
     class FFI
       # MessageDef
-      attach_function :get_oneof_by_name,    :upb_MessageDef_FindOneofByNameWithSize, [Descriptor, :string, :size_t], OneofDescriptor
-      attach_function :get_oneof_by_index,   :upb_MessageDef_Oneof,                   [Descriptor, :int], OneofDescriptor
+      attach_function :get_oneof_by_name,        :upb_MessageDef_FindOneofByNameWithSize, [Descriptor, :string, :size_t], OneofDescriptor
+      attach_function :get_oneof_by_index,       :upb_MessageDef_Oneof,                   [Descriptor, :int], OneofDescriptor
 
       # OneofDescriptor
-      attach_function :get_oneof_name,           :upb_OneofDef_Name,          [OneofDescriptor], :string
-      attach_function :get_oneof_field_count,    :upb_OneofDef_FieldCount,    [OneofDescriptor], :int
-      attach_function :get_oneof_field_by_index, :upb_OneofDef_Field,         [OneofDescriptor, :int], FieldDescriptor
-      attach_function :get_oneof_containing_type,:upb_OneofDef_ContainingType,[:pointer], Descriptor
+      attach_function :get_oneof_name,           :upb_OneofDef_Name,                      [OneofDescriptor], :string
+      attach_function :get_oneof_field_count,    :upb_OneofDef_FieldCount,                [OneofDescriptor], :int
+      attach_function :get_oneof_field_by_index, :upb_OneofDef_Field,                     [OneofDescriptor, :int], FieldDescriptor
+      attach_function :get_oneof_containing_type,:upb_OneofDef_ContainingType,            [:pointer], Descriptor
+      attach_function :oneof_options,            :OneOfDescriptor_serialized_options,     [OneofDescriptor, :pointer, Internal::Arena], :pointer
 
       # FieldDescriptor
-      attach_function :real_containing_oneof,      :upb_FieldDef_RealContainingOneof,[FieldDescriptor], OneofDescriptor
+      attach_function :real_containing_oneof,    :upb_FieldDef_RealContainingOneof,       [FieldDescriptor], OneofDescriptor
     end
   end
 end