Alpha 1 drop of Google's Objective C plugin and runtime support for protobufs.

1 files changed, 4735 insertions, 0 deletions

diff --git a/objectivec/GPBMessage.m b/objectivec/GPBMessage.m
new file mode 100644
index 00000000..63ffc3bc
--- /dev/null
+++ b/objectivec/GPBMessage.m
@@ -0,0 +1,4735 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#import "GPBMessage_PackagePrivate.h"
+
+#import <objc/runtime.h>
+#import <objc/message.h>
+
+#import "GPBArray_PackagePrivate.h"
+#import "GPBCodedInputStream_PackagePrivate.h"
+#import "GPBCodedOutputStream.h"
+#import "GPBDescriptor_PackagePrivate.h"
+#import "GPBDictionary_PackagePrivate.h"
+#import "GPBExtensionField_PackagePrivate.h"
+#import "GPBExtensionRegistry_PackagePrivate.h"
+#import "GPBUnknownFieldSet_PackagePrivate.h"
+#import "GPBUtilities_PackagePrivate.h"
+
+#ifdef DEBUG
+NSString *const GPBExceptionMessageKey =
+    GPBNSStringifySymbol(GPBExceptionMessage);
+#endif  // DEBUG
+
+//
+// PLEASE REMEMBER:
+//
+// This is the base class for *all* messages generated, so any selector defined,
+// *public* or *private* could end up colliding with a proto message field. So
+// avoid using selectors that could match a property, use C functions to hide
+// them, etc.
+//
+
+@interface GPBMessage () {
+ @package
+  GPBUnknownFieldSet *unknownFields_;
+  NSMutableDictionary *extensionMap_;
+  NSMutableDictionary *autocreatedExtensionMap_;
+
+  // If the object was autocreated, we remember the creator so that if we get
+  // mutated, we can inform the creator to make our field visible.
+  GPBMessage *autocreator_;
+  GPBFieldDescriptor *autocreatorField_;
+  GPBExtensionField *autocreatorExtension_;
+}
+@end
+
+static id CreateArrayForField(GPBFieldDescriptor *field,
+                              GPBMessage *autocreator)
+    __attribute__((ns_returns_retained));
+static id GetOrCreateArrayIvarWithField(GPBMessage *self,
+                                        GPBFieldDescriptor *field,
+                                        GPBFileSyntax syntax);
+static id GetArrayIvarWithField(GPBMessage *self, GPBFieldDescriptor *field);
+static id GetOrCreateMapIvarWithField(GPBMessage *self,
+                                      GPBFieldDescriptor *field,
+                                      GPBFileSyntax syntax);
+static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
+                                              NSZone *zone)
+    __attribute__((ns_returns_retained));
+
+static void CheckExtension(GPBMessage *self, GPBExtensionField *extension) {
+  if ([[self class] descriptor] != [extension containingType]) {
+    [NSException
+         raise:NSInvalidArgumentException
+        format:@"Extension %@ used on wrong class (%@ instead of %@)",
+               extension.descriptor.singletonName,
+               [[self class] descriptor].name, [extension containingType].name];
+  }
+}
+
+static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
+                                              NSZone *zone) {
+  if (extensionMap.count == 0) {
+    return nil;
+  }
+  NSMutableDictionary *result = [[NSMutableDictionary allocWithZone:zone]
+      initWithCapacity:extensionMap.count];
+
+  for (GPBExtensionField *field in extensionMap) {
+    id value = [extensionMap objectForKey:field];
+    GPBExtensionDescriptor *fieldDescriptor = field.descriptor;
+    BOOL isMessageExtension = GPBExtensionIsMessage(fieldDescriptor);
+
+    if ([field isRepeated]) {
+      if (isMessageExtension) {
+        NSMutableArray *list =
+            [[NSMutableArray alloc] initWithCapacity:[value count]];
+        for (GPBMessage *listValue in value) {
+          GPBMessage *copiedValue = [listValue copyWithZone:zone];
+          [list addObject:copiedValue];
+          [copiedValue release];
+        }
+        [result setObject:list forKey:field];
+        [list release];
+      } else {
+        NSMutableArray *copiedValue = [value mutableCopyWithZone:zone];
+        [result setObject:copiedValue forKey:field];
+        [copiedValue release];
+      }
+    } else {
+      if (isMessageExtension) {
+        GPBMessage *copiedValue = [value copyWithZone:zone];
+        [result setObject:copiedValue forKey:field];
+        [copiedValue release];
+      } else {
+        [result setObject:value forKey:field];
+      }
+    }
+  }
+
+  return result;
+}
+
+static id CreateArrayForField(GPBFieldDescriptor *field,
+                              GPBMessage *autocreator) {
+  id result;
+  GPBType fieldDataType = GPBGetFieldType(field);
+  switch (fieldDataType) {
+    case GPBTypeBool:
+      result = [[GPBBoolArray alloc] init];
+      break;
+    case GPBTypeFixed32:
+    case GPBTypeUInt32:
+      result = [[GPBUInt32Array alloc] init];
+      break;
+    case GPBTypeInt32:
+    case GPBTypeSFixed32:
+    case GPBTypeSInt32:
+      result = [[GPBInt32Array alloc] init];
+      break;
+    case GPBTypeFixed64:
+    case GPBTypeUInt64:
+      result = [[GPBUInt64Array alloc] init];
+      break;
+    case GPBTypeInt64:
+    case GPBTypeSFixed64:
+    case GPBTypeSInt64:
+      result = [[GPBInt64Array alloc] init];
+      break;
+    case GPBTypeFloat:
+      result = [[GPBFloatArray alloc] init];
+      break;
+    case GPBTypeDouble:
+      result = [[GPBDoubleArray alloc] init];
+      break;
+
+    case GPBTypeEnum:
+      result = [[GPBEnumArray alloc]
+                  initWithValidationFunction:field.enumDescriptor.enumVerifier];
+      break;
+
+    case GPBTypeData:
+    case GPBTypeGroup:
+    case GPBTypeMessage:
+    case GPBTypeString:
+      if (autocreator) {
+        result = [[GPBAutocreatedArray alloc] init];
+      } else {
+        result = [[NSMutableArray alloc] init];
+      }
+      break;
+  }
+
+  if (autocreator) {
+    if (GPBTypeIsObject(fieldDataType)) {
+      GPBAutocreatedArray *autoArray = result;
+      autoArray->_autocreator =  autocreator;
+    } else {
+      GPBInt32Array *gpbArray = result;
+      gpbArray->_autocreator = autocreator;
+    }
+  }
+
+  return result;
+}
+
+
+#if !defined(__clang_analyzer__)
+// These functions are blocked from the analyzer because the analyzer sees the
+// GPBSetRetainedObjectIvarWithFieldInternal() call as consuming the array/map,
+// so use of the array/map after the call returns is flagged as a use after
+// free.
+// But GPBSetRetainedObjectIvarWithFieldInternal() is "consuming" the retain
+// count be holding onto the object (it is transfering it), the object is
+// still valid after returning from the call.  The other way to avoid this
+// would be to add a -retain/-autorelease, but that would force every
+// repeated/map field parsed into the autorelease pool which is both a memory
+// and performance hit.
+
+static id GetOrCreateArrayIvarWithField(GPBMessage *self,
+                                        GPBFieldDescriptor *field,
+                                        GPBFileSyntax syntax) {
+  id array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+  if (!array) {
+    // No lock needed, this is called from places expecting to mutate
+    // so no threading protection is needed.
+    array = CreateArrayForField(field, nil);
+    GPBSetRetainedObjectIvarWithFieldInternal(self, field, array, syntax);
+  }
+  return array;
+}
+
+// This is like GPBGetObjectIvarWithField(), but for arrays, it should
+// only be used to wire the method into the class.
+static id GetArrayIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
+  id array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+  if (!array) {
+    // Check again after getting the lock.
+    OSSpinLockLock(&self->readOnlyMutex_);
+    array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+    if (!array) {
+      array = CreateArrayForField(field, self);
+      GPBSetAutocreatedRetainedObjectIvarWithField(self, field, array);
+    }
+    OSSpinLockUnlock(&self->readOnlyMutex_);
+  }
+  return array;
+}
+
+static id GetOrCreateMapIvarWithField(GPBMessage *self,
+                                      GPBFieldDescriptor *field,
+                                      GPBFileSyntax syntax) {
+  id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+  if (!dict) {
+    GPBType keyType = field.mapKeyType;
+    GPBType valueType = GPBGetFieldType(field);
+    switch (keyType) {
+      case GPBTypeBool:
+        switch (valueType) {
+          case GPBTypeBool:
+            dict = [[GPBBoolBoolDictionary alloc] init];
+            break;
+          case GPBTypeFixed32:
+          case GPBTypeUInt32:
+            dict = [[GPBBoolUInt32Dictionary alloc] init];
+            break;
+          case GPBTypeInt32:
+          case GPBTypeSFixed32:
+          case GPBTypeSInt32:
+            dict = [[GPBBoolInt32Dictionary alloc] init];
+            break;
+          case GPBTypeFixed64:
+          case GPBTypeUInt64:
+            dict = [[GPBBoolUInt64Dictionary alloc] init];
+            break;
+          case GPBTypeInt64:
+          case GPBTypeSFixed64:
+          case GPBTypeSInt64:
+            dict = [[GPBBoolInt64Dictionary alloc] init];
+            break;
+          case GPBTypeFloat:
+            dict = [[GPBBoolFloatDictionary alloc] init];
+            break;
+          case GPBTypeDouble:
+            dict = [[GPBBoolDoubleDictionary alloc] init];
+            break;
+          case GPBTypeEnum:
+            dict = [[GPBBoolEnumDictionary alloc]
+                initWithValidationFunction:field.enumDescriptor.enumVerifier];
+            break;
+          case GPBTypeData:
+          case GPBTypeMessage:
+          case GPBTypeString:
+            dict = [[GPBBoolObjectDictionary alloc] init];
+            break;
+          case GPBTypeGroup:
+            NSCAssert(NO, @"shouldn't happen");
+            return nil;
+        }
+        break;
+      case GPBTypeFixed32:
+      case GPBTypeUInt32:
+        switch (valueType) {
+          case GPBTypeBool:
+            dict = [[GPBUInt32BoolDictionary alloc] init];
+            break;
+          case GPBTypeFixed32:
+          case GPBTypeUInt32:
+            dict = [[GPBUInt32UInt32Dictionary alloc] init];
+            break;
+          case GPBTypeInt32:
+          case GPBTypeSFixed32:
+          case GPBTypeSInt32:
+            dict = [[GPBUInt32Int32Dictionary alloc] init];
+            break;
+          case GPBTypeFixed64:
+          case GPBTypeUInt64:
+            dict = [[GPBUInt32UInt64Dictionary alloc] init];
+            break;
+          case GPBTypeInt64:
+          case GPBTypeSFixed64:
+          case GPBTypeSInt64:
+            dict = [[GPBUInt32Int64Dictionary alloc] init];
+            break;
+          case GPBTypeFloat:
+            dict = [[GPBUInt32FloatDictionary alloc] init];
+            break;
+          case GPBTypeDouble:
+            dict = [[GPBUInt32DoubleDictionary alloc] init];
+            break;
+          case GPBTypeEnum:
+            dict = [[GPBUInt32EnumDictionary alloc]
+                initWithValidationFunction:field.enumDescriptor.enumVerifier];
+            break;
+          case GPBTypeData:
+          case GPBTypeMessage:
+          case GPBTypeString:
+            dict = [[GPBUInt32ObjectDictionary alloc] init];
+            break;
+          case GPBTypeGroup:
+            NSCAssert(NO, @"shouldn't happen");
+            return nil;
+        }
+        break;
+      case GPBTypeInt32:
+      case GPBTypeSFixed32:
+      case GPBTypeSInt32:
+        switch (valueType) {
+          case GPBTypeBool:
+            dict = [[GPBInt32BoolDictionary alloc] init];
+            break;
+          case GPBTypeFixed32:
+          case GPBTypeUInt32:
+            dict = [[GPBInt32UInt32Dictionary alloc] init];
+            break;
+          case GPBTypeInt32:
+          case GPBTypeSFixed32:
+          case GPBTypeSInt32:
+            dict = [[GPBInt32Int32Dictionary alloc] init];
+            break;
+          case GPBTypeFixed64:
+          case GPBTypeUInt64:
+            dict = [[GPBInt32UInt64Dictionary alloc] init];
+            break;
+          case GPBTypeInt64:
+          case GPBTypeSFixed64:
+          case GPBTypeSInt64:
+            dict = [[GPBInt32Int64Dictionary alloc] init];
+            break;
+          case GPBTypeFloat:
+            dict = [[GPBInt32FloatDictionary alloc] init];
+            break;
+          case GPBTypeDouble:
+            dict = [[GPBInt32DoubleDictionary alloc] init];
+            break;
+          case GPBTypeEnum:
+            dict = [[GPBInt32EnumDictionary alloc]
+                initWithValidationFunction:field.enumDescriptor.enumVerifier];
+            break;
+          case GPBTypeData:
+          case GPBTypeMessage:
+          case GPBTypeString:
+            dict = [[GPBInt32ObjectDictionary alloc] init];
+            break;
+          case GPBTypeGroup:
+            NSCAssert(NO, @"shouldn't happen");
+            return nil;
+        }
+        break;
+      case GPBTypeFixed64:
+      case GPBTypeUInt64:
+        switch (valueType) {
+          case GPBTypeBool:
+            dict = [[GPBUInt64BoolDictionary alloc] init];
+            break;
+          case GPBTypeFixed32:
+          case GPBTypeUInt32:
+            dict = [[GPBUInt64UInt32Dictionary alloc] init];
+            break;
+          case GPBTypeInt32:
+          case GPBTypeSFixed32:
+          case GPBTypeSInt32:
+            dict = [[GPBUInt64Int32Dictionary alloc] init];
+            break;
+          case GPBTypeFixed64:
+          case GPBTypeUInt64:
+            dict = [[GPBUInt64UInt64Dictionary alloc] init];
+            break;
+          case GPBTypeInt64:
+          case GPBTypeSFixed64:
+          case GPBTypeSInt64:
+            dict = [[GPBUInt64Int64Dictionary alloc] init];
+            break;
+          case GPBTypeFloat:
+            dict = [[GPBUInt64FloatDictionary alloc] init];
+            break;
+          case GPBTypeDouble:
+            dict = [[GPBUInt64DoubleDictionary alloc] init];
+            break;
+          case GPBTypeEnum:
+            dict = [[GPBUInt64EnumDictionary alloc]
+                initWithValidationFunction:field.enumDescriptor.enumVerifier];
+            break;
+          case GPBTypeData:
+          case GPBTypeMessage:
+          case GPBTypeString:
+            dict = [[GPBUInt64ObjectDictionary alloc] init];
+            break;
+          case GPBTypeGroup:
+            NSCAssert(NO, @"shouldn't happen");
+            return nil;
+        }
+        break;
+      case GPBTypeInt64:
+      case GPBTypeSFixed64:
+      case GPBTypeSInt64:
+        switch (valueType) {
+          case GPBTypeBool:
+            dict = [[GPBInt64BoolDictionary alloc] init];
+            break;
+          case GPBTypeFixed32:
+          case GPBTypeUInt32:
+            dict = [[GPBInt64UInt32Dictionary alloc] init];
+            break;
+          case GPBTypeInt32:
+          case GPBTypeSFixed32:
+          case GPBTypeSInt32:
+            dict = [[GPBInt64Int32Dictionary alloc] init];
+            break;
+          case GPBTypeFixed64:
+          case GPBTypeUInt64:
+            dict = [[GPBInt64UInt64Dictionary alloc] init];
+            break;
+          case GPBTypeInt64:
+          case GPBTypeSFixed64:
+          case GPBTypeSInt64:
+            dict = [[GPBInt64Int64Dictionary alloc] init];
+            break;
+          case GPBTypeFloat:
+            dict = [[GPBInt64FloatDictionary alloc] init];
+            break;
+          case GPBTypeDouble:
+            dict = [[GPBInt64DoubleDictionary alloc] init];
+            break;
+          case GPBTypeEnum:
+            dict = [[GPBInt64EnumDictionary alloc]
+                initWithValidationFunction:field.enumDescriptor.enumVerifier];
+            break;
+          case GPBTypeData:
+          case GPBTypeMessage:
+          case GPBTypeString:
+            dict = [[GPBInt64ObjectDictionary alloc] init];
+            break;
+          case GPBTypeGroup:
+            NSCAssert(NO, @"shouldn't happen");
+            return nil;
+        }
+        break;
+      case GPBTypeString:
+        switch (valueType) {
+          case GPBTypeBool:
+            dict = [[GPBStringBoolDictionary alloc] init];
+            break;
+          case GPBTypeFixed32:
+          case GPBTypeUInt32:
+            dict = [[GPBStringUInt32Dictionary alloc] init];
+            break;
+          case GPBTypeInt32:
+          case GPBTypeSFixed32:
+          case GPBTypeSInt32:
+            dict = [[GPBStringInt32Dictionary alloc] init];
+            break;
+          case GPBTypeFixed64:
+          case GPBTypeUInt64:
+            dict = [[GPBStringUInt64Dictionary alloc] init];
+            break;
+          case GPBTypeInt64:
+          case GPBTypeSFixed64:
+          case GPBTypeSInt64:
+            dict = [[GPBStringInt64Dictionary alloc] init];
+            break;
+          case GPBTypeFloat:
+            dict = [[GPBStringFloatDictionary alloc] init];
+            break;
+          case GPBTypeDouble:
+            dict = [[GPBStringDoubleDictionary alloc] init];
+            break;
+          case GPBTypeEnum:
+            dict = [[GPBStringEnumDictionary alloc]
+                initWithValidationFunction:field.enumDescriptor.enumVerifier];
+            break;
+          case GPBTypeData:
+          case GPBTypeMessage:
+          case GPBTypeString:
+            dict = [[NSMutableDictionary alloc] init];
+            break;
+          case GPBTypeGroup:
+            NSCAssert(NO, @"shouldn't happen");
+            return nil;
+        }
+        break;
+
+      case GPBTypeFloat:
+      case GPBTypeDouble:
+      case GPBTypeEnum:
+      case GPBTypeData:
+      case GPBTypeGroup:
+      case GPBTypeMessage:
+        NSCAssert(NO, @"shouldn't happen");
+        return nil;
+    }
+
+    GPBSetRetainedObjectIvarWithFieldInternal(self, field, dict, syntax);
+  }
+  return dict;
+}
+
+#endif  // !defined(__clang_analyzer__)
+
+GPBMessage *GPBCreateMessageWithAutocreator(Class msgClass,
+                                            GPBMessage *autocreator,
+                                            GPBFieldDescriptor *field) {
+  GPBMessage *message = [[msgClass alloc] init];
+  message->autocreator_ = autocreator;
+  message->autocreatorField_ = [field retain];
+  return message;
+}
+
+static GPBMessage *CreateMessageWithAutocreatorForExtension(
+    Class msgClass, GPBMessage *autocreator, GPBExtensionField *extension)
+    __attribute__((ns_returns_retained));
+
+static GPBMessage *CreateMessageWithAutocreatorForExtension(
+    Class msgClass, GPBMessage *autocreator, GPBExtensionField *extension) {
+  GPBMessage *message = [[msgClass alloc] init];
+  message->autocreator_ = autocreator;
+  message->autocreatorExtension_ = [extension retain];
+  return message;
+}
+
+BOOL GPBWasMessageAutocreatedBy(GPBMessage *message, GPBMessage *parent) {
+  return (message->autocreator_ == parent);
+}
+
+void GPBBecomeVisibleToAutocreator(GPBMessage *self) {
+  // Message objects that are implicitly created by accessing a message field
+  // are initially not visible via the hasX selector. This method makes them
+  // visible.
+  if (self->autocreator_) {
+    // This will recursively make all parent messages visible until it reaches a
+    // super-creator that's visible.
+    if (self->autocreatorField_) {
+      GPBFileSyntax syntax = [self->autocreator_ descriptor].file.syntax;
+      GPBSetObjectIvarWithFieldInternal(self->autocreator_,
+                                        self->autocreatorField_, self, syntax);
+    } else {
+      [self->autocreator_ setExtension:self->autocreatorExtension_ value:self];
+    }
+  }
+}
+
+void GPBAutocreatedArrayModified(GPBMessage *self, id array) {
+  // When one of our autocreated arrays adds elements, make it visible.
+  GPBDescriptor *descriptor = [[self class] descriptor];
+  for (GPBFieldDescriptor *field in descriptor->fields_) {
+    if (field.fieldType == GPBFieldTypeRepeated) {
+      id curArray = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+      if (curArray == array) {
+        if (GPBFieldTypeIsObject(field)) {
+          GPBAutocreatedArray *autoArray = array;
+          autoArray->_autocreator = nil;
+        } else {
+          GPBInt32Array *gpbArray = array;
+          gpbArray->_autocreator = nil;
+        }
+        GPBBecomeVisibleToAutocreator(self);
+        return;
+      }
+    }
+  }
+  NSCAssert(NO, @"Unknown array.");
+}
+
+void GPBClearMessageAutocreator(GPBMessage *self) {
+  if ((self == nil) || !self->autocreator_) {
+    return;
+  }
+
+#if DEBUG && !defined(NS_BLOCK_ASSERTIONS)
+  // Either the autocreator must have its "has" flag set to YES, or it must be
+  // NO and not equal to ourselves.
+  BOOL autocreatorHas =
+      (self->autocreatorField_
+           ? GPBGetHasIvarField(self->autocreator_, self->autocreatorField_)
+           : [self->autocreator_ hasExtension:self->autocreatorExtension_]);
+  GPBMessage *autocreatorFieldValue =
+      (self->autocreatorField_
+           ? GPBGetObjectIvarWithFieldNoAutocreate(self->autocreator_,
+                                                   self->autocreatorField_)
+           : [self->autocreator_->autocreatedExtensionMap_
+                 objectForKey:self->autocreatorExtension_]);
+  NSCAssert(autocreatorHas || autocreatorFieldValue != self,
+            @"Cannot clear autocreator because it still refers to self.");
+
+#endif  // DEBUG && !defined(NS_BLOCK_ASSERTIONS)
+
+  self->autocreator_ = nil;
+  [self->autocreatorField_ release];
+  self->autocreatorField_ = nil;
+  [self->autocreatorExtension_ release];
+  self->autocreatorExtension_ = nil;
+}
+
+static GPBUnknownFieldSet *GetOrMakeUnknownFields(GPBMessage *self) {
+  if (!self->unknownFields_) {
+    self->unknownFields_ = [[GPBUnknownFieldSet alloc] init];
+    GPBBecomeVisibleToAutocreator(self);
+  }
+  return self->unknownFields_;
+}
+
+#ifdef DEBUG
+static void DebugRaiseExceptionIfNotInitialized(GPBMessage *message) {
+  if (!message.initialized) {
+    NSString *reason =
+        [NSString stringWithFormat:@"Uninitialized Message %@", message];
+    NSDictionary *userInfo =
+        message ? @{GPBExceptionMessageKey : message} : nil;
+    NSException *exception =
+        [NSException exceptionWithName:NSInternalInconsistencyException
+                                reason:reason
+                              userInfo:userInfo];
+    [exception raise];
+  }
+}
+#else
+GPB_INLINE void DebugRaiseExceptionIfNotInitialized(GPBMessage *message) {
+#pragma unused(message)
+}
+#endif  // DEBUG
+
+@implementation GPBMessage
+
++ (void)initialize {
+  Class pbMessageClass = [GPBMessage class];
+  if ([self class] == pbMessageClass) {
+    // This is here to start up the "base" class descriptor.
+    [self descriptor];
+  } else if ([self superclass] == pbMessageClass) {
+    // This is here to start up all the "message" subclasses. Just needs to be
+    // done for the messages, not any of the subclasses.
+    // This must be done in initialize to enforce thread safety of start up of
+    // the protocol buffer library. All of the extension registries must be
+    // created in either "+load" or "+initialize".
+    [self descriptor];
+    [self extensionRegistry];
+  }
+}
+
++ (instancetype)allocWithZone:(NSZone *)zone {
+  // Override alloc to allocate our classes with the additional storage
+  // required for the instance variables.
+  GPBDescriptor *descriptor = [self descriptor];
+  return NSAllocateObject(self, descriptor->storageSize_, zone);
+}
+
++ (instancetype)alloc {
+  return [self allocWithZone:nil];
+}
+
++ (GPBDescriptor *)descriptor {
+  // This is thread safe because it is called from +initialize.
+  static GPBDescriptor *descriptor = NULL;
+  static GPBFileDescriptor *fileDescriptor = NULL;
+  if (!descriptor) {
+    // Use a dummy file that marks it as proto2 syntax so when used generically
+    // it supports unknowns/etc.
+    fileDescriptor =
+        [[GPBFileDescriptor alloc] initWithPackage:@"internal"
+                                            syntax:GPBFileSyntaxProto2];
+
+    descriptor = [GPBDescriptor allocDescriptorForClass:[GPBMessage class]
+                                              rootClass:Nil
+                                                   file:fileDescriptor
+                                                 fields:NULL
+                                             fieldCount:0
+                                                 oneofs:NULL
+                                             oneofCount:0
+                                                  enums:NULL
+                                              enumCount:0
+                                                 ranges:NULL
+                                             rangeCount:0
+                                            storageSize:0
+                                             wireFormat:NO];
+  }
+  return descriptor;
+}
+
++ (instancetype)message {
+  return [[[self alloc] init] autorelease];
+}
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    messageStorage_ = (GPBMessage_StoragePtr)(
+        ((uint8_t *)self) + class_getInstanceSize([self class]));
+
+    readOnlyMutex_ = OS_SPINLOCK_INIT;
+  }
+
+  return self;
+}
+
+- (instancetype)initWithData:(NSData *)data {
+  return [self initWithData:data extensionRegistry:nil];
+}
+
+- (instancetype)initWithData:(NSData *)data
+           extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
+  if ((self = [self init])) {
+    [self mergeFromData:data extensionRegistry:extensionRegistry];
+    DebugRaiseExceptionIfNotInitialized(self);
+  }
+  return self;
+}
+
+- (instancetype)initWithCodedInputStream:(GPBCodedInputStream *)input
+                       extensionRegistry:
+                           (GPBExtensionRegistry *)extensionRegistry {
+  if ((self = [self init])) {
+    [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry];
+    DebugRaiseExceptionIfNotInitialized(self);
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [self internalClear:NO];
+  NSCAssert(!autocreator_, @"Autocreator was not cleared before dealloc.");
+  [super dealloc];
+}
+
+- (void)copyFieldsInto:(GPBMessage *)message
+                  zone:(NSZone *)zone
+            descriptor:(GPBDescriptor *)descriptor {
+  // Copy all the storage...
+  memcpy(message->messageStorage_, messageStorage_, descriptor->storageSize_);
+
+  GPBFileSyntax syntax = descriptor.file.syntax;
+
+  // Loop over the fields doing fixup...
+  for (GPBFieldDescriptor *field in descriptor->fields_) {
+    if (GPBFieldIsMapOrArray(field)) {
+      id value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+      if (value) {
+        // We need to copy the array/map, but the catch is for message fields,
+        // we also need to ensure all the messages as those need copying also.
+        id newValue;
+        if (GPBFieldTypeIsMessage(field)) {
+          if (field.fieldType == GPBFieldTypeRepeated) {
+            NSArray *existingArray = (NSArray *)value;
+            NSMutableArray *newArray =
+                [[NSMutableArray alloc] initWithCapacity:existingArray.count];
+            newValue = newArray;
+            for (GPBMessage *msg in existingArray) {
+              GPBMessage *copiedMsg = [msg copyWithZone:zone];
+              [newArray addObject:copiedMsg];
+              [copiedMsg release];
+            }
+          } else {
+            if (field.mapKeyType == GPBTypeString) {
+              // Map is an NSDictionary.
+              NSDictionary *existingDict = value;
+              NSMutableDictionary *newDict = [[NSMutableDictionary alloc]
+                  initWithCapacity:existingDict.count];
+              newValue = newDict;
+              [existingDict enumerateKeysAndObjectsUsingBlock:^(NSString *key,
+                                                                GPBMessage *msg,
+                                                                BOOL *stop) {
+#pragma unused(stop)
+                GPBMessage *copiedMsg = [msg copyWithZone:zone];
+                [newDict setObject:copiedMsg forKey:key];
+                [copiedMsg release];
+              }];
+            } else {
+              // Is one of the GPB*ObjectDictionary classes.  Type doesn't
+              // matter, just need one to invoke the selector.
+              GPBInt32ObjectDictionary *existingDict = value;
+              newValue = [existingDict deepCopyWithZone:zone];
+            }
+          }
+        } else {
+          // Not messages (but is a map/array)...
+          if (field.fieldType == GPBFieldTypeRepeated) {
+            if (GPBFieldTypeIsObject(field)) {
+              // NSArray
+              newValue = [value mutableCopyWithZone:zone];
+            } else {
+              // GPB*Array
+              newValue = [value copyWithZone:zone];
+            }
+          } else {
+            if (field.mapKeyType == GPBTypeString) {
+              // NSDictionary
+              newValue = [value mutableCopyWithZone:zone];
+            } else {
+              // Is one of the GPB*Dictionary classes.  Type doesn't matter,
+              // just need one to invoke the selector.
+              GPBInt32Int32Dictionary *existingDict = value;
+              newValue = [existingDict copyWithZone:zone];
+            }
+          }
+        }
+        // We retain here because the memcpy picked up the pointer value and
+        // the next call to SetRetainedObject... will release the current value.
+        [value retain];
+        GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue,
+                                                  syntax);
+      }
+    } else if (GPBFieldTypeIsMessage(field)) {
+      // For object types, if we have a value, copy it.  If we don't,
+      // zero it to remove the pointer to something that was autocreated
+      // (and the ptr just got memcpyed).
+      if (GPBGetHasIvarField(self, field)) {
+        GPBMessage *value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        GPBMessage *newValue = [value copyWithZone:zone];
+        // We retain here because the memcpy picked up the pointer value and
+        // the next call to SetRetainedObject... will release the current value.
+        [value retain];
+        GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue,
+                                                  syntax);
+      } else {
+        uint8_t *storage = (uint8_t *)message->messageStorage_;
+        id *typePtr = (id *)&storage[field->description_->offset];
+        *typePtr = NULL;
+      }
+    } else if (GPBFieldTypeIsObject(field) && GPBGetHasIvarField(self, field)) {
+      // A set string/data value (message picked off above), copy it.
+      id value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+      id newValue = [value copyWithZone:zone];
+      // We retain here because the memcpy picked up the pointer value and
+      // the next call to SetRetainedObject... will release the current value.
+      [value retain];
+      GPBSetRetainedObjectIvarWithFieldInternal(message, field, newValue,
+                                                syntax);
+    } else {
+      // memcpy took care of the rest of the primative fields if they were set.
+    }
+  }  // for (field in descriptor->fields_)
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+  GPBDescriptor *descriptor = [self descriptor];
+  GPBMessage *result = [[descriptor.messageClass allocWithZone:zone] init];
+
+  [self copyFieldsInto:result zone:zone descriptor:descriptor];
+  // Make immutable copies of the extra bits.
+  result->unknownFields_ = [unknownFields_ copyWithZone:zone];
+  result->extensionMap_ = CloneExtensionMap(extensionMap_, zone);
+  return result;
+}
+
+- (void)clear {
+  [self internalClear:YES];
+}
+
+- (void)internalClear:(BOOL)zeroStorage {
+  GPBDescriptor *descriptor = [self descriptor];
+  for (GPBFieldDescriptor *field in descriptor->fields_) {
+    if (GPBFieldIsMapOrArray(field)) {
+      id arrayOrMap = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+      if (arrayOrMap) {
+        if (field.fieldType == GPBFieldTypeRepeated) {
+          if (GPBFieldTypeIsObject(field)) {
+            GPBAutocreatedArray *autoArray = arrayOrMap;
+            if (autoArray->_autocreator == self) {
+              autoArray->_autocreator = nil;
+            }
+          } else {
+            // Type doesn't matter, it is a GPB*Array.
+            GPBInt32Array *gpbArray = arrayOrMap;
+            if (gpbArray->_autocreator == self) {
+              gpbArray->_autocreator = nil;
+            }
+          }
+        }
+        [arrayOrMap release];
+      }
+    } else if (GPBFieldTypeIsMessage(field)) {
+      GPBClearAutocreatedMessageIvarWithField(self, field);
+      GPBMessage *value = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+      [value release];
+    } else if (GPBFieldTypeIsObject(field) && GPBGetHasIvarField(self, field)) {
+      id value = GPBGetObjectIvarWithField(self, field);
+      [value release];
+    }
+  }
+
+  // GPBClearMessageAutocreator() expects that its caller has already been
+  // removed from autocreatedExtensionMap_ so we set to nil first.
+  NSArray *autocreatedValues = [autocreatedExtensionMap_ allValues];
+  [autocreatedExtensionMap_ release];
+  autocreatedExtensionMap_ = nil;
+
+  // Since we're clearing all of our extensions, make sure that we clear the
+  // autocreator on any that we've created so they no longer refer to us.
+  for (GPBMessage *value in autocreatedValues) {
+    NSCAssert(GPBWasMessageAutocreatedBy(value, self),
+              @"Autocreated extension does not refer back to self.");
+    GPBClearMessageAutocreator(value);
+  }
+
+  [extensionMap_ release];
+  extensionMap_ = nil;
+  [unknownFields_ release];
+  unknownFields_ = nil;
+
+  // Note that clearing does not affect autocreator_. If we are being cleared
+  // because of a dealloc, then autocreator_ should be nil anyway. If we are
+  // being cleared because someone explicitly clears us, we don't want to
+  // sever our relationship with our autocreator.
+
+  if (zeroStorage) {
+    memset(messageStorage_, 0, descriptor->storageSize_);
+  }
+}
+
+- (BOOL)isInitialized {
+  GPBDescriptor *descriptor = [self descriptor];
+  for (GPBFieldDescriptor *field in descriptor->fields_) {
+    if (field.isRequired) {
+      if (!GPBGetHasIvarField(self, field)) {
+        return NO;
+      }
+    }
+    if (GPBFieldTypeIsMessage(field)) {
+      GPBFieldType fieldType = field.fieldType;
+      if (fieldType == GPBFieldTypeSingle) {
+        if (field.isRequired) {
+          GPBMessage *message = GPBGetMessageIvarWithField(self, field);
+          if (!message.initialized) {
+            return NO;
+          }
+        } else {
+          NSAssert(field.isOptional,
+                   @"If not required or optional, what was it?");
+          if (GPBGetHasIvarField(self, field)) {
+            GPBMessage *message = GPBGetMessageIvarWithField(self, field);
+            if (!message.initialized) {
+              return NO;
+            }
+          }
+        }
+      } else if (fieldType == GPBFieldTypeRepeated) {
+        NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        for (GPBMessage *message in array) {
+          if (!message.initialized) {
+            return NO;
+          }
+        }
+      } else {  // fieldType == GPBFieldTypeMap
+        if (field.mapKeyType == GPBTypeString) {
+          NSDictionary *map =
+              GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+          if (map && !GPBDictionaryIsInitializedInternalHelper(map, field)) {
+            return NO;
+          }
+        } else {
+          // Real type is GPB*ObjectDictionary, exact type doesn't matter.
+          GPBInt32ObjectDictionary *map =
+              GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+          if (map && ![map isInitialized]) {
+            return NO;
+          }
+        }
+      }
+    }
+  }
+
+  __block BOOL result = YES;
+  [extensionMap_
+      enumerateKeysAndObjectsUsingBlock:^(GPBExtensionField *extension, id obj,
+                                          BOOL *stop) {
+        GPBExtensionDescriptor *extDesc = extension.descriptor;
+        if (GPBExtensionIsMessage(extDesc)) {
+          if (extDesc.isRepeated) {
+            for (GPBMessage *msg in obj) {
+              if (!msg.initialized) {
+                result = NO;
+                *stop = YES;
+                break;
+              }
+            }
+          } else {
+            GPBMessage *asMsg = obj;
+            if (!asMsg.initialized) {
+              result = NO;
+              *stop = YES;
+            }
+          }
+        }
+      }];
+  return result;
+}
+
+- (GPBDescriptor *)descriptor {
+  return [[self class] descriptor];
+}
+
+- (NSData *)data {
+  DebugRaiseExceptionIfNotInitialized(self);
+  NSMutableData *data = [NSMutableData dataWithLength:[self serializedSize]];
+  GPBCodedOutputStream *stream =
+      [[GPBCodedOutputStream alloc] initWithData:data];
+  [self writeToCodedOutputStream:stream];
+  [stream release];
+  return data;
+}
+
+- (NSData *)delimitedData {
+  size_t serializedSize = [self serializedSize];
+  size_t varintSize = GPBComputeRawVarint32SizeForInteger(serializedSize);
+  NSMutableData *data =
+      [NSMutableData dataWithLength:(serializedSize + varintSize)];
+  GPBCodedOutputStream *stream =
+      [[GPBCodedOutputStream alloc] initWithData:data];
+  [self writeDelimitedToCodedOutputStream:stream];
+  [stream release];
+  return data;
+}
+
+- (void)writeToOutputStream:(NSOutputStream *)output {
+  GPBCodedOutputStream *stream =
+      [[GPBCodedOutputStream alloc] initWithOutputStream:output];
+  [self writeToCodedOutputStream:stream];
+  [stream release];
+}
+
+- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)output {
+  GPBDescriptor *descriptor = [self descriptor];
+  NSArray *fieldsArray = descriptor->fields_;
+  NSUInteger fieldCount = fieldsArray.count;
+  const GPBExtensionRange *extensionRanges = descriptor.extensionRanges;
+  NSUInteger extensionRangesCount = descriptor.extensionRangesCount;
+  for (NSUInteger i = 0, j = 0; i < fieldCount || j < extensionRangesCount;) {
+    if (i == fieldCount) {
+      [self writeExtensionsToCodedOutputStream:output
+                                         range:extensionRanges[j++]];
+    } else if (j == extensionRangesCount ||
+               GPBFieldNumber(fieldsArray[i]) < extensionRanges[j].start) {
+      [self writeField:fieldsArray[i++] toCodedOutputStream:output];
+    } else {
+      [self writeExtensionsToCodedOutputStream:output
+                                         range:extensionRanges[j++]];
+    }
+  }
+  if (descriptor.isWireFormat) {
+    [unknownFields_ writeAsMessageSetTo:output];
+  } else {
+    [unknownFields_ writeToCodedOutputStream:output];
+  }
+}
+
+- (void)writeDelimitedToOutputStream:(NSOutputStream *)output {
+  GPBCodedOutputStream *codedOutput =
+      [[GPBCodedOutputStream alloc] initWithOutputStream:output];
+  [self writeDelimitedToCodedOutputStream:codedOutput];
+  [codedOutput release];
+}
+
+- (void)writeDelimitedToCodedOutputStream:(GPBCodedOutputStream *)output {
+  [output writeRawVarintSizeTAs32:[self serializedSize]];
+  [self writeToCodedOutputStream:output];
+}
+
+- (void)writeField:(GPBFieldDescriptor *)field
+    toCodedOutputStream:(GPBCodedOutputStream *)output {
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeSingle) {
+    BOOL has = GPBGetHasIvarField(self, field);
+    if (!has) {
+      return;
+    }
+  }
+  uint32_t fieldNumber = GPBFieldNumber(field);
+
+//%PDDM-DEFINE FIELD_CASE(TYPE, REAL_TYPE)
+//%FIELD_CASE_FULL(TYPE, REAL_TYPE, REAL_TYPE)
+//%PDDM-DEFINE FIELD_CASE_FULL(TYPE, REAL_TYPE, ARRAY_TYPE)
+//%    case GPBType##TYPE:
+//%      if (fieldType == GPBFieldTypeRepeated) {
+//%        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+//%        GPB##ARRAY_TYPE##Array *array =
+//%            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+//%        [output write##TYPE##s:fieldNumber values:array tag:tag];
+//%      } else if (fieldType == GPBFieldTypeSingle) {
+//%        [output write##TYPE:fieldNumber
+//%              TYPE$S  value:GPBGet##REAL_TYPE##IvarWithField(self, field)];
+//%      } else {  // fieldType == GPBFieldTypeMap
+//%        // Exact type here doesn't matter.
+//%        GPBInt32##ARRAY_TYPE##Dictionary *dict =
+//%            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+//%        [dict writeToCodedOutputStream:output asField:field];
+//%      }
+//%      break;
+//%
+//%PDDM-DEFINE FIELD_CASE2(TYPE)
+//%    case GPBType##TYPE:
+//%      if (fieldType == GPBFieldTypeRepeated) {
+//%        NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+//%        [output write##TYPE##s:fieldNumber values:array];
+//%      } else if (fieldType == GPBFieldTypeSingle) {
+//%        // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+//%        // again.
+//%        [output write##TYPE:fieldNumber
+//%              TYPE$S  value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
+//%      } else {  // fieldType == GPBFieldTypeMap
+//%        // Exact type here doesn't matter.
+//%        id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+//%        GPBType mapKeyType = field.mapKeyType;
+//%        if (mapKeyType == GPBTypeString) {
+//%          GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
+//%        } else {
+//%          [dict writeToCodedOutputStream:output asField:field];
+//%        }
+//%      }
+//%      break;
+//%
+
+  switch (GPBGetFieldType(field)) {
+
+//%PDDM-EXPAND FIELD_CASE(Bool, Bool)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeBool:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBBoolArray *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeBools:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeBool:fieldNumber
+                    value:GPBGetBoolIvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32BoolDictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(Fixed32, UInt32)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeFixed32:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBUInt32Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeFixed32s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeFixed32:fieldNumber
+                       value:GPBGetUInt32IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32UInt32Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(SFixed32, Int32)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeSFixed32:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBInt32Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeSFixed32s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeSFixed32:fieldNumber
+                        value:GPBGetInt32IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32Int32Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(Float, Float)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeFloat:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBFloatArray *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeFloats:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeFloat:fieldNumber
+                     value:GPBGetFloatIvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32FloatDictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(Fixed64, UInt64)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeFixed64:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBUInt64Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeFixed64s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeFixed64:fieldNumber
+                       value:GPBGetUInt64IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32UInt64Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(SFixed64, Int64)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeSFixed64:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBInt64Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeSFixed64s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeSFixed64:fieldNumber
+                        value:GPBGetInt64IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32Int64Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(Double, Double)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeDouble:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBDoubleArray *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeDoubles:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeDouble:fieldNumber
+                      value:GPBGetDoubleIvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32DoubleDictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(Int32, Int32)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeInt32:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBInt32Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeInt32s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeInt32:fieldNumber
+                     value:GPBGetInt32IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32Int32Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(Int64, Int64)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeInt64:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBInt64Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeInt64s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeInt64:fieldNumber
+                     value:GPBGetInt64IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32Int64Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(SInt32, Int32)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeSInt32:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBInt32Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeSInt32s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeSInt32:fieldNumber
+                      value:GPBGetInt32IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32Int32Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(SInt64, Int64)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeSInt64:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBInt64Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeSInt64s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeSInt64:fieldNumber
+                      value:GPBGetInt64IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32Int64Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(UInt32, UInt32)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeUInt32:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBUInt32Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeUInt32s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeUInt32:fieldNumber
+                      value:GPBGetUInt32IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32UInt32Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE(UInt64, UInt64)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeUInt64:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBUInt64Array *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeUInt64s:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeUInt64:fieldNumber
+                      value:GPBGetUInt64IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32UInt64Dictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE_FULL(Enum, Int32, Enum)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeEnum:
+      if (fieldType == GPBFieldTypeRepeated) {
+        uint32_t tag = field.isPackable ? GPBFieldTag(field) : 0;
+        GPBEnumArray *array =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeEnums:fieldNumber values:array tag:tag];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        [output writeEnum:fieldNumber
+                    value:GPBGetInt32IvarWithField(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        GPBInt32EnumDictionary *dict =
+            GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [dict writeToCodedOutputStream:output asField:field];
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE2(Data)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeData:
+      if (fieldType == GPBFieldTypeRepeated) {
+        NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeDatas:fieldNumber values:array];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+        // again.
+        [output writeData:fieldNumber
+                    value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        GPBType mapKeyType = field.mapKeyType;
+        if (mapKeyType == GPBTypeString) {
+          GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
+        } else {
+          [dict writeToCodedOutputStream:output asField:field];
+        }
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE2(String)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeString:
+      if (fieldType == GPBFieldTypeRepeated) {
+        NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeStrings:fieldNumber values:array];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+        // again.
+        [output writeString:fieldNumber
+                      value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        GPBType mapKeyType = field.mapKeyType;
+        if (mapKeyType == GPBTypeString) {
+          GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
+        } else {
+          [dict writeToCodedOutputStream:output asField:field];
+        }
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE2(Message)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeMessage:
+      if (fieldType == GPBFieldTypeRepeated) {
+        NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeMessages:fieldNumber values:array];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+        // again.
+        [output writeMessage:fieldNumber
+                       value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        GPBType mapKeyType = field.mapKeyType;
+        if (mapKeyType == GPBTypeString) {
+          GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
+        } else {
+          [dict writeToCodedOutputStream:output asField:field];
+        }
+      }
+      break;
+
+//%PDDM-EXPAND FIELD_CASE2(Group)
+// This block of code is generated, do not edit it directly.
+
+    case GPBTypeGroup:
+      if (fieldType == GPBFieldTypeRepeated) {
+        NSArray *array = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        [output writeGroups:fieldNumber values:array];
+      } else if (fieldType == GPBFieldTypeSingle) {
+        // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+        // again.
+        [output writeGroup:fieldNumber
+                     value:GPBGetObjectIvarWithFieldNoAutocreate(self, field)];
+      } else {  // fieldType == GPBFieldTypeMap
+        // Exact type here doesn't matter.
+        id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+        GPBType mapKeyType = field.mapKeyType;
+        if (mapKeyType == GPBTypeString) {
+          GPBDictionaryWriteToStreamInternalHelper(output, dict, field);
+        } else {
+          [dict writeToCodedOutputStream:output asField:field];
+        }
+      }
+      break;
+
+//%PDDM-EXPAND-END (18 expansions)
+  }
+}
+
+#pragma mark - Extensions
+
+- (id)getExtension:(GPBExtensionField *)extension {
+  CheckExtension(self, extension);
+  id value = [extensionMap_ objectForKey:extension];
+  if (value != nil) {
+    return value;
+  }
+
+  GPBExtensionDescriptor *extDesc = extension.descriptor;
+
+  // No default for repeated.
+  if (extDesc.isRepeated) {
+    return nil;
+  }
+  // Non messages get their default.
+  if (!GPBExtensionIsMessage(extDesc)) {
+    return [extension defaultValue];
+  }
+
+  // Check for an autocreated value.
+  OSSpinLockLock(&readOnlyMutex_);
+  value = [autocreatedExtensionMap_ objectForKey:extension];
+  if (!value) {
+    // Auto create the message extensions to match normal fields.
+    value = CreateMessageWithAutocreatorForExtension(extDesc.msgClass, self,
+                                                     extension);
+
+    if (autocreatedExtensionMap_ == nil) {
+      autocreatedExtensionMap_ = [[NSMutableDictionary alloc] init];
+    }
+
+    // We can't simply call setExtension here because that would clear the new
+    // value's autocreator.
+    [autocreatedExtensionMap_ setObject:value forKey:extension];
+    [value release];
+  }
+
+  OSSpinLockUnlock(&readOnlyMutex_);
+  return value;
+}
+
+- (id)getExistingExtension:(GPBExtensionField *)extension {
+  // This is an internal method so we don't need to call CheckExtension().
+  return [extensionMap_ objectForKey:extension];
+}
+
+- (BOOL)hasExtension:(GPBExtensionField *)extension {
+#if DEBUG
+  CheckExtension(self, extension);
+#endif  // DEBUG
+  return nil != [extensionMap_ objectForKey:extension];
+}
+
+- (NSArray *)extensionsCurrentlySet {
+  return [extensionMap_ allKeys];
+}
+
+- (void)writeExtensionsToCodedOutputStream:(GPBCodedOutputStream *)output
+                                     range:(GPBExtensionRange)range {
+  NSArray *sortedExtensions = [[extensionMap_ allKeys]
+      sortedArrayUsingSelector:@selector(compareByFieldNumber:)];
+  uint32_t start = range.start;
+  uint32_t end = range.end;
+  for (GPBExtensionField *extension in sortedExtensions) {
+    uint32_t fieldNumber = [extension fieldNumber];
+    if (fieldNumber >= start && fieldNumber < end) {
+      id value = [extensionMap_ objectForKey:extension];
+      [extension writeValue:value includingTagToCodedOutputStream:output];
+    }
+  }
+}
+
+- (NSArray *)sortedExtensionsInUse {
+  return [[extensionMap_ allKeys]
+      sortedArrayUsingSelector:@selector(compareByFieldNumber:)];
+}
+
+- (void)setExtension:(GPBExtensionField *)extension value:(id)value {
+  if (!value) {
+    [self clearExtension:extension];
+    return;
+  }
+
+  CheckExtension(self, extension);
+
+  if ([extension isRepeated]) {
+    [NSException raise:NSInvalidArgumentException
+                format:@"Must call addExtension() for repeated types."];
+  }
+
+  if (extensionMap_ == nil) {
+    extensionMap_ = [[NSMutableDictionary alloc] init];
+  }
+
+  [extensionMap_ setObject:value forKey:extension];
+
+  GPBExtensionDescriptor *descriptor = extension.descriptor;
+
+  if (GPBExtensionIsMessage(descriptor) && !descriptor.isRepeated) {
+    GPBMessage *autocreatedValue =
+        [[autocreatedExtensionMap_ objectForKey:extension] retain];
+    // Must remove from the map before calling GPBClearMessageAutocreator() so
+    // that GPBClearMessageAutocreator() knows its safe to clear.
+    [autocreatedExtensionMap_ removeObjectForKey:extension];
+    GPBClearMessageAutocreator(autocreatedValue);
+    [autocreatedValue release];
+  }
+
+  GPBBecomeVisibleToAutocreator(self);
+}
+
+- (void)addExtension:(GPBExtensionField *)extension value:(id)value {
+  CheckExtension(self, extension);
+
+  if (![extension isRepeated]) {
+    [NSException raise:NSInvalidArgumentException
+                format:@"Must call setExtension() for singular types."];
+  }
+
+  if (extensionMap_ == nil) {
+    extensionMap_ = [[NSMutableDictionary alloc] init];
+  }
+  NSMutableArray *list = [extensionMap_ objectForKey:extension];
+  if (list == nil) {
+    list = [NSMutableArray array];
+    [extensionMap_ setObject:list forKey:extension];
+  }
+
+  [list addObject:value];
+  GPBBecomeVisibleToAutocreator(self);
+}
+
+- (void)setExtension:(GPBExtensionField *)extension
+               index:(NSUInteger)idx
+               value:(id)value {
+  CheckExtension(self, extension);
+
+  if (![extension isRepeated]) {
+    [NSException raise:NSInvalidArgumentException
+                format:@"Must call setExtension() for singular types."];
+  }
+
+  if (extensionMap_ == nil) {
+    extensionMap_ = [[NSMutableDictionary alloc] init];
+  }
+
+  NSMutableArray *list = [extensionMap_ objectForKey:extension];
+
+  [list replaceObjectAtIndex:idx withObject:value];
+  GPBBecomeVisibleToAutocreator(self);
+}
+
+- (void)clearExtension:(GPBExtensionField *)extension {
+  CheckExtension(self, extension);
+
+  // Only become visible if there was actually a value to clear.
+  if ([extensionMap_ objectForKey:extension]) {
+    [extensionMap_ removeObjectForKey:extension];
+    GPBBecomeVisibleToAutocreator(self);
+  }
+}
+
+#pragma mark - mergeFrom
+
+- (void)mergeFromData:(NSData *)data
+    extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
+  GPBCodedInputStream *input = [[GPBCodedInputStream alloc] initWithData:data];
+  [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry];
+  [input checkLastTagWas:0];
+  [input release];
+}
+
+#pragma mark - mergeDelimitedFrom
+
+- (void)mergeDelimitedFromCodedInputStream:(GPBCodedInputStream *)input
+                         extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
+  GPBCodedInputStreamState *state = &input->state_;
+  if (GPBCodedInputStreamIsAtEnd(state)) {
+    return;
+  }
+  NSData *data = GPBCodedInputStreamReadRetainedDataNoCopy(state);
+  if (data == nil) {
+    return;
+  }
+  [self mergeFromData:data extensionRegistry:extensionRegistry];
+  [data release];
+}
+
+#pragma mark - Parse From Data Support
+
++ (instancetype)parseFromData:(NSData *)data {
+  return [self parseFromData:data extensionRegistry:nil];
+}
+
++ (instancetype)parseFromData:(NSData *)data
+            extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
+  return [[[self alloc] initWithData:data
+                   extensionRegistry:extensionRegistry] autorelease];
+}
+
++ (instancetype)parseFromCodedInputStream:(GPBCodedInputStream *)input
+                        extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
+  return
+      [[[self alloc] initWithCodedInputStream:input
+                            extensionRegistry:extensionRegistry] autorelease];
+}
+
+#pragma mark - Parse Delimited From Data Support
+
++ (instancetype)parseDelimitedFromCodedInputStream:(GPBCodedInputStream *)input
+                                 extensionRegistry:
+                                     (GPBExtensionRegistry *)extensionRegistry {
+  GPBMessage *message = [[[self alloc] init] autorelease];
+  [message mergeDelimitedFromCodedInputStream:input
+                            extensionRegistry:extensionRegistry];
+  DebugRaiseExceptionIfNotInitialized(message);
+  return message;
+}
+
+#pragma mark - Unknown Field Support
+
+- (GPBUnknownFieldSet *)unknownFields {
+  return unknownFields_;
+}
+
+- (void)setUnknownFields:(GPBUnknownFieldSet *)unknownFields {
+  if (unknownFields != unknownFields_) {
+    [unknownFields_ release];
+    unknownFields_ = [unknownFields copy];
+    GPBBecomeVisibleToAutocreator(self);
+  }
+}
+
+- (void)parseMessageSet:(GPBCodedInputStream *)input
+      extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
+  uint32_t typeId = 0;
+  NSData *rawBytes = nil;
+  GPBExtensionField *extension = nil;
+  GPBCodedInputStreamState *state = &input->state_;
+  while (true) {
+    uint32_t tag = GPBCodedInputStreamReadTag(state);
+    if (tag == 0) {
+      break;
+    }
+
+    if (tag == GPBWireFormatMessageSetTypeIdTag) {
+      typeId = GPBCodedInputStreamReadUInt32(state);
+      if (typeId != 0) {
+        extension = [extensionRegistry getExtension:[self descriptor]
+                                        fieldNumber:typeId];
+      }
+    } else if (tag == GPBWireFormatMessageSetMessageTag) {
+      rawBytes = [GPBCodedInputStreamReadRetainedDataNoCopy(state) autorelease];
+    } else {
+      if (![input skipField:tag]) {
+        break;
+      }
+    }
+  }
+
+  [input checkLastTagWas:GPBWireFormatMessageSetItemEndTag];
+
+  if (rawBytes != nil && typeId != 0) {
+    if (extension != nil) {
+      GPBCodedInputStream *newInput =
+          [[GPBCodedInputStream alloc] initWithData:rawBytes];
+      [extension mergeFromCodedInputStream:newInput
+                         extensionRegistry:extensionRegistry
+                                   message:self];
+      [newInput release];
+    } else {
+      GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
+      [unknownFields mergeMessageSetMessage:typeId data:rawBytes];
+    }
+  }
+}
+
+- (BOOL)parseUnknownField:(GPBCodedInputStream *)input
+        extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
+                      tag:(uint32_t)tag {
+  GPBWireFormat wireType = GPBWireFormatGetTagWireType(tag);
+  int32_t fieldNumber = GPBWireFormatGetTagFieldNumber(tag);
+
+  GPBDescriptor *descriptor = [self descriptor];
+  GPBExtensionField *extension =
+      [extensionRegistry getExtension:descriptor fieldNumber:fieldNumber];
+
+  if (extension == nil) {
+    if (descriptor.wireFormat && GPBWireFormatMessageSetItemTag == tag) {
+      [self parseMessageSet:input extensionRegistry:extensionRegistry];
+      return YES;
+    }
+  } else {
+    if ([extension wireType] == wireType) {
+      [extension mergeFromCodedInputStream:input
+                         extensionRegistry:extensionRegistry
+                                   message:self];
+      return YES;
+    }
+  }
+  if ([GPBUnknownFieldSet isFieldTag:tag]) {
+    GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
+    return [unknownFields mergeFieldFrom:tag input:input];
+  } else {
+    return NO;
+  }
+}
+
+- (void)addUnknownMapEntry:(int32_t)fieldNum value:(NSData *)data {
+  GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(self);
+  [unknownFields addUnknownMapEntry:fieldNum value:data];
+}
+
+#pragma mark - MergeFromCodedInputStream Support
+
+typedef struct MergeFromCodedInputStreamContext {
+  GPBMessage *self;
+  GPBCodedInputStream *stream;
+  GPBMessage *result;
+  GPBExtensionRegistry *registry;
+  uint32_t tag;
+  GPBFileSyntax syntax;
+} MergeFromCodedInputStreamContext;
+
+//%PDDM-DEFINE MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(NAME, TYPE, ARRAY_TYPE)
+//%static BOOL DynamicMergeFromCodedInputStream##NAME(GPBFieldDescriptor *field,
+//%                                           NAME$S  void *voidContext) {
+//%  MergeFromCodedInputStreamContext *context =
+//%      (MergeFromCodedInputStreamContext *)voidContext;
+//%  GPBCodedInputStreamState *state = &context->stream->state_;
+//%  GPBFieldType fieldType = field.fieldType;
+//%  if (fieldType == GPBFieldTypeRepeated) {
+//%    GPB##ARRAY_TYPE##Array *array =
+//%        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+//%    if (field.isPackable) {
+//%      int32_t length = GPBCodedInputStreamReadInt32(state);
+//%      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+//%      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+//%        TYPE val = GPBCodedInputStreamRead##NAME(state);
+//%        [array addValue:val];
+//%      }
+//%      GPBCodedInputStreamPopLimit(state, limit);
+//%    } else {
+//%      TYPE val = GPBCodedInputStreamRead##NAME(state);
+//%      [array addValue:val];
+//%    }
+//%  } else if (fieldType == GPBFieldTypeSingle) {
+//%    TYPE val = GPBCodedInputStreamRead##NAME(state);
+//%    GPBSet##ARRAY_TYPE##IvarWithFieldInternal(context->result, field, val,
+//%           ARRAY_TYPE$S                     context->syntax);
+//%  } else {  // fieldType == GPBFieldTypeMap
+//%    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+//%    GPBInt32Int32Dictionary *map =
+//%        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+//%    [context->stream readMapEntry:map
+//%                extensionRegistry:nil
+//%                            field:field
+//%                    parentMessage:context->result];
+//%  }
+//%  return NO;
+//%}
+//%
+//%PDDM-DEFINE MERGE_FROM_CODED_INPUT_STREAM_OBJ_FUNC(NAME)
+//%static BOOL DynamicMergeFromCodedInputStream##NAME(GPBFieldDescriptor *field,
+//%                                           NAME$S  void *voidContext) {
+//%  MergeFromCodedInputStreamContext *context = voidContext;
+//%  GPBCodedInputStreamState *state = &context->stream->state_;
+//%  GPBFieldType fieldType = field.fieldType;
+//%  if (fieldType == GPBFieldTypeMap) {
+//%    // GPB*Dictionary or NSDictionary, exact type doesn't matter at this point.
+//%    id map =
+//%        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+//%    [context->stream readMapEntry:map
+//%                extensionRegistry:nil
+//%                            field:field
+//%                    parentMessage:context->result];
+//%  } else {
+//%    id val = GPBCodedInputStreamReadRetained##NAME(state);
+//%    if (fieldType == GPBFieldTypeRepeated) {
+//%      NSMutableArray *array =
+//%          GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+//%      [array addObject:val];
+//%      [val release];
+//%    } else {  // fieldType == GPBFieldTypeSingle
+//%      GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, val,
+//%                                                context->syntax);
+//%    }
+//%  }
+//%  return NO;
+//%}
+//%
+
+static BOOL DynamicMergeFromCodedInputStreamGroup(GPBFieldDescriptor *field,
+                                                  void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  int number = GPBFieldNumber(field);
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBMessage *message = [[field.msgClass alloc] init];
+    NSMutableArray *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    [context->stream readGroup:number
+                       message:message
+             extensionRegistry:context->registry];
+    [array addObject:message];
+    [message release];
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL has = GPBGetHasIvarField(context->result, field);
+    if (has) {
+      // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+      // again.
+      GPBMessage *message =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->result, field);
+      [context->stream readGroup:number
+                         message:message
+               extensionRegistry:context->registry];
+    } else {
+      GPBMessage *message = [[field.msgClass alloc] init];
+      [context->stream readGroup:number
+                         message:message
+               extensionRegistry:context->registry];
+      GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, message,
+                                                context->syntax);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    NSCAssert(NO, @"Shouldn't happen");
+    return YES;
+  }
+  return NO;
+}
+
+static BOOL DynamicMergeFromCodedInputStreamMessage(GPBFieldDescriptor *field,
+                                                    void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBMessage *message = [[field.msgClass alloc] init];
+    NSMutableArray *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    [context->stream readMessage:message extensionRegistry:context->registry];
+    [array addObject:message];
+    [message release];
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL has = GPBGetHasIvarField(context->result, field);
+    if (has) {
+      // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+      // again.
+      GPBMessage *message =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->result, field);
+      [context->stream readMessage:message extensionRegistry:context->registry];
+    } else {
+      GPBMessage *message = [[field.msgClass alloc] init];
+      [context->stream readMessage:message extensionRegistry:context->registry];
+      GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, message,
+                                                context->syntax);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // GPB*Dictionary or NSDictionary, exact type doesn't matter.
+    id map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:context->registry
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+static BOOL DynamicMergeFromCodedInputStreamEnum(GPBFieldDescriptor *field,
+                                                 void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  int number = GPBFieldNumber(field);
+  BOOL hasPreservingUnknownEnumSemantics =
+      GPBHasPreservingUnknownEnumSemantics(context->syntax);
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBEnumArray *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        int32_t val = GPBCodedInputStreamReadEnum(state);
+        if (hasPreservingUnknownEnumSemantics || [field isValidEnumValue:val]) {
+          [array addRawValue:val];
+        } else {
+          GPBUnknownFieldSet *unknownFields =
+              GetOrMakeUnknownFields(context->self);
+          [unknownFields mergeVarintField:number value:val];
+        }
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      int32_t val = GPBCodedInputStreamReadEnum(state);
+      if (hasPreservingUnknownEnumSemantics || [field isValidEnumValue:val]) {
+        [array addRawValue:val];
+      } else {
+        GPBUnknownFieldSet *unknownFields =
+            GetOrMakeUnknownFields(context->self);
+        [unknownFields mergeVarintField:number value:val];
+      }
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    int32_t val = GPBCodedInputStreamReadEnum(state);
+    if (hasPreservingUnknownEnumSemantics || [field isValidEnumValue:val]) {
+      GPBSetInt32IvarWithFieldInternal(context->result, field, val,
+                                       context->syntax);
+    } else {
+      GPBUnknownFieldSet *unknownFields = GetOrMakeUnknownFields(context->self);
+      [unknownFields mergeVarintField:number value:val];
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a
+    // GPB*EnumDictionary.
+    GPBInt32EnumDictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:context->registry
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Bool, BOOL, Bool)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamBool(GPBFieldDescriptor *field,
+                                                 void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBBoolArray *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        BOOL val = GPBCodedInputStreamReadBool(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      BOOL val = GPBCodedInputStreamReadBool(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL val = GPBCodedInputStreamReadBool(state);
+    GPBSetBoolIvarWithFieldInternal(context->result, field, val,
+                                    context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Int32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamInt32(GPBFieldDescriptor *field,
+                                                  void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt32Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        int32_t val = GPBCodedInputStreamReadInt32(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      int32_t val = GPBCodedInputStreamReadInt32(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    int32_t val = GPBCodedInputStreamReadInt32(state);
+    GPBSetInt32IvarWithFieldInternal(context->result, field, val,
+                                     context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SInt32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamSInt32(GPBFieldDescriptor *field,
+                                                   void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt32Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        int32_t val = GPBCodedInputStreamReadSInt32(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      int32_t val = GPBCodedInputStreamReadSInt32(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    int32_t val = GPBCodedInputStreamReadSInt32(state);
+    GPBSetInt32IvarWithFieldInternal(context->result, field, val,
+                                     context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SFixed32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamSFixed32(GPBFieldDescriptor *field,
+                                                     void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt32Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        int32_t val = GPBCodedInputStreamReadSFixed32(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      int32_t val = GPBCodedInputStreamReadSFixed32(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    int32_t val = GPBCodedInputStreamReadSFixed32(state);
+    GPBSetInt32IvarWithFieldInternal(context->result, field, val,
+                                     context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(UInt32, uint32_t, UInt32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamUInt32(GPBFieldDescriptor *field,
+                                                   void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt32Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        uint32_t val = GPBCodedInputStreamReadUInt32(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      uint32_t val = GPBCodedInputStreamReadUInt32(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    uint32_t val = GPBCodedInputStreamReadUInt32(state);
+    GPBSetUInt32IvarWithFieldInternal(context->result, field, val,
+                                      context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Fixed32, uint32_t, UInt32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamFixed32(GPBFieldDescriptor *field,
+                                                    void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt32Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        uint32_t val = GPBCodedInputStreamReadFixed32(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      uint32_t val = GPBCodedInputStreamReadFixed32(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    uint32_t val = GPBCodedInputStreamReadFixed32(state);
+    GPBSetUInt32IvarWithFieldInternal(context->result, field, val,
+                                      context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Int64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamInt64(GPBFieldDescriptor *field,
+                                                  void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt64Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        int64_t val = GPBCodedInputStreamReadInt64(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      int64_t val = GPBCodedInputStreamReadInt64(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    int64_t val = GPBCodedInputStreamReadInt64(state);
+    GPBSetInt64IvarWithFieldInternal(context->result, field, val,
+                                     context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SFixed64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamSFixed64(GPBFieldDescriptor *field,
+                                                     void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt64Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        int64_t val = GPBCodedInputStreamReadSFixed64(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      int64_t val = GPBCodedInputStreamReadSFixed64(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    int64_t val = GPBCodedInputStreamReadSFixed64(state);
+    GPBSetInt64IvarWithFieldInternal(context->result, field, val,
+                                     context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(SInt64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamSInt64(GPBFieldDescriptor *field,
+                                                   void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt64Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        int64_t val = GPBCodedInputStreamReadSInt64(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      int64_t val = GPBCodedInputStreamReadSInt64(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    int64_t val = GPBCodedInputStreamReadSInt64(state);
+    GPBSetInt64IvarWithFieldInternal(context->result, field, val,
+                                     context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(UInt64, uint64_t, UInt64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamUInt64(GPBFieldDescriptor *field,
+                                                   void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt64Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        uint64_t val = GPBCodedInputStreamReadUInt64(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      uint64_t val = GPBCodedInputStreamReadUInt64(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    uint64_t val = GPBCodedInputStreamReadUInt64(state);
+    GPBSetUInt64IvarWithFieldInternal(context->result, field, val,
+                                      context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Fixed64, uint64_t, UInt64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamFixed64(GPBFieldDescriptor *field,
+                                                    void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt64Array *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        uint64_t val = GPBCodedInputStreamReadFixed64(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      uint64_t val = GPBCodedInputStreamReadFixed64(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    uint64_t val = GPBCodedInputStreamReadFixed64(state);
+    GPBSetUInt64IvarWithFieldInternal(context->result, field, val,
+                                      context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Float, float, Float)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamFloat(GPBFieldDescriptor *field,
+                                                  void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBFloatArray *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        float val = GPBCodedInputStreamReadFloat(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      float val = GPBCodedInputStreamReadFloat(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    float val = GPBCodedInputStreamReadFloat(state);
+    GPBSetFloatIvarWithFieldInternal(context->result, field, val,
+                                     context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_POD_FUNC(Double, double, Double)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamDouble(GPBFieldDescriptor *field,
+                                                   void *voidContext) {
+  MergeFromCodedInputStreamContext *context =
+      (MergeFromCodedInputStreamContext *)voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBDoubleArray *array =
+        GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+    if (field.isPackable) {
+      int32_t length = GPBCodedInputStreamReadInt32(state);
+      size_t limit = GPBCodedInputStreamPushLimit(state, length);
+      while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
+        double val = GPBCodedInputStreamReadDouble(state);
+        [array addValue:val];
+      }
+      GPBCodedInputStreamPopLimit(state, limit);
+    } else {
+      double val = GPBCodedInputStreamReadDouble(state);
+      [array addValue:val];
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    double val = GPBCodedInputStreamReadDouble(state);
+    GPBSetDoubleIvarWithFieldInternal(context->result, field, val,
+                                      context->syntax);
+  } else {  // fieldType == GPBFieldTypeMap
+    // The exact type doesn't matter, just need to know it is a GPB*Dictionary.
+    GPBInt32Int32Dictionary *map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_OBJ_FUNC(String)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamString(GPBFieldDescriptor *field,
+                                                   void *voidContext) {
+  MergeFromCodedInputStreamContext *context = voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeMap) {
+    // GPB*Dictionary or NSDictionary, exact type doesn't matter at this point.
+    id map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  } else {
+    id val = GPBCodedInputStreamReadRetainedString(state);
+    if (fieldType == GPBFieldTypeRepeated) {
+      NSMutableArray *array =
+          GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+      [array addObject:val];
+      [val release];
+    } else {  // fieldType == GPBFieldTypeSingle
+      GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, val,
+                                                context->syntax);
+    }
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND MERGE_FROM_CODED_INPUT_STREAM_OBJ_FUNC(Data)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicMergeFromCodedInputStreamData(GPBFieldDescriptor *field,
+                                                 void *voidContext) {
+  MergeFromCodedInputStreamContext *context = voidContext;
+  GPBCodedInputStreamState *state = &context->stream->state_;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeMap) {
+    // GPB*Dictionary or NSDictionary, exact type doesn't matter at this point.
+    id map =
+        GetOrCreateMapIvarWithField(context->result, field, context->syntax);
+    [context->stream readMapEntry:map
+                extensionRegistry:nil
+                            field:field
+                    parentMessage:context->result];
+  } else {
+    id val = GPBCodedInputStreamReadRetainedData(state);
+    if (fieldType == GPBFieldTypeRepeated) {
+      NSMutableArray *array =
+          GetOrCreateArrayIvarWithField(context->result, field, context->syntax);
+      [array addObject:val];
+      [val release];
+    } else {  // fieldType == GPBFieldTypeSingle
+      GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, val,
+                                                context->syntax);
+    }
+  }
+  return NO;
+}
+
+//%PDDM-EXPAND-END (15 expansions)
+
+- (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input
+                extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
+  GPBDescriptor *descriptor = [self descriptor];
+  GPBFileSyntax syntax = descriptor.file.syntax;
+  MergeFromCodedInputStreamContext context = {
+    self, input, self, extensionRegistry, 0, syntax
+  };
+  GPBApplyStrictFunctions funcs =
+      GPBAPPLY_STRICT_FUNCTIONS_INIT(DynamicMergeFromCodedInputStream);
+  NSUInteger startingIndex = 0;
+  NSArray *fields = descriptor->fields_;
+  NSUInteger count = fields.count;
+  while (YES) {
+    BOOL merged = NO;
+    context.tag = GPBCodedInputStreamReadTag(&input->state_);
+    for (NSUInteger i = 0; i < count; ++i) {
+      if (startingIndex >= count) startingIndex = 0;
+      GPBFieldDescriptor *fieldDescriptor = fields[startingIndex];
+      if (GPBFieldTag(fieldDescriptor) == context.tag) {
+        GPBApplyFunction function = funcs[GPBGetFieldType(fieldDescriptor)];
+        function(fieldDescriptor, &context);
+        merged = YES;
+        break;
+      } else {
+        startingIndex += 1;
+      }
+    }
+    if (!merged) {
+      if (context.tag == 0) {
+        // zero signals EOF / limit reached
+        return;
+      } else {
+        if (GPBPreserveUnknownFields(syntax)) {
+          if (![self parseUnknownField:input
+                     extensionRegistry:extensionRegistry
+                                   tag:context.tag]) {
+            // it's an endgroup tag
+            return;
+          }
+        } else {
+          if (![input skipField:context.tag]) {
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+#pragma mark - MergeFrom Support
+
+typedef struct MergeFromContext {
+  GPBMessage *other;
+  GPBMessage *result;
+  GPBFileSyntax syntax;
+} MergeFromContext;
+
+//%PDDM-DEFINE GPB_MERGE_FROM_FUNC(NAME)
+//%static BOOL MergeFrom##NAME(GPBFieldDescriptor *field, void *voidContext) {
+//%  MergeFromContext *context = (MergeFromContext *)voidContext;
+//%  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+//%  if (otherHas) {
+//%    GPBSet##NAME##IvarWithFieldInternal(
+//%        context->result, field, GPBGet##NAME##IvarWithField(context->other, field),
+//%        context->syntax);
+//%  }
+//%  return YES;
+//%}
+//%
+//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Bool)
+// This block of code is generated, do not edit it directly.
+
+static BOOL MergeFromBool(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+  if (otherHas) {
+    GPBSetBoolIvarWithFieldInternal(
+        context->result, field, GPBGetBoolIvarWithField(context->other, field),
+        context->syntax);
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL MergeFromInt32(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+  if (otherHas) {
+    GPBSetInt32IvarWithFieldInternal(
+        context->result, field, GPBGetInt32IvarWithField(context->other, field),
+        context->syntax);
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(UInt32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL MergeFromUInt32(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+  if (otherHas) {
+    GPBSetUInt32IvarWithFieldInternal(
+        context->result, field, GPBGetUInt32IvarWithField(context->other, field),
+        context->syntax);
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL MergeFromInt64(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+  if (otherHas) {
+    GPBSetInt64IvarWithFieldInternal(
+        context->result, field, GPBGetInt64IvarWithField(context->other, field),
+        context->syntax);
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(UInt64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL MergeFromUInt64(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+  if (otherHas) {
+    GPBSetUInt64IvarWithFieldInternal(
+        context->result, field, GPBGetUInt64IvarWithField(context->other, field),
+        context->syntax);
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Float)
+// This block of code is generated, do not edit it directly.
+
+static BOOL MergeFromFloat(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+  if (otherHas) {
+    GPBSetFloatIvarWithFieldInternal(
+        context->result, field, GPBGetFloatIvarWithField(context->other, field),
+        context->syntax);
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND GPB_MERGE_FROM_FUNC(Double)
+// This block of code is generated, do not edit it directly.
+
+static BOOL MergeFromDouble(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  BOOL otherHas = GPBGetHasIvarField(context->other, field);
+  if (otherHas) {
+    GPBSetDoubleIvarWithFieldInternal(
+        context->result, field, GPBGetDoubleIvarWithField(context->other, field),
+        context->syntax);
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND-END (7 expansions)
+
+static BOOL MergeFromObject(GPBFieldDescriptor *field, void *voidContext) {
+  MergeFromContext *context = (MergeFromContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    // In the case of a list, they need to be appended, and there is no
+    // _hasIvar to worry about setting.
+    id otherArray =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->other, field);
+    if (otherArray) {
+      GPBType fieldDataType = field->description_->type;
+      if (GPBTypeIsObject(fieldDataType)) {
+        NSMutableArray *resultArray = GetOrCreateArrayIvarWithField(
+            context->result, field, context->syntax);
+        [resultArray addObjectsFromArray:otherArray];
+      } else if (fieldDataType == GPBTypeEnum) {
+        GPBEnumArray *resultArray = GetOrCreateArrayIvarWithField(
+            context->result, field, context->syntax);
+        [resultArray addRawValuesFromArray:otherArray];
+      } else {
+        // The array type doesn't matter, that all implment
+        // -addValuesFromArray:.
+        GPBInt32Array *resultArray = GetOrCreateArrayIvarWithField(
+            context->result, field, context->syntax);
+        [resultArray addValuesFromArray:otherArray];
+      }
+    }
+    return YES;
+  }
+  if (fieldType == GPBFieldTypeMap) {
+    // In the case of a map, they need to be merged, and there is no
+    // _hasIvar to worry about setting.
+    id otherDict = GPBGetObjectIvarWithFieldNoAutocreate(context->other, field);
+    if (otherDict) {
+      GPBType keyType = field.mapKeyType;
+      GPBType valueType = field->description_->type;
+      if (GPBTypeIsObject(keyType) && GPBTypeIsObject(valueType)) {
+        NSMutableDictionary *resultDict = GetOrCreateMapIvarWithField(
+            context->result, field, context->syntax);
+        [resultDict addEntriesFromDictionary:otherDict];
+      } else if (valueType == GPBTypeEnum) {
+        // The exact type doesn't matter, just need to know it is a
+        // GPB*EnumDictionary.
+        GPBInt32EnumDictionary *resultDict = GetOrCreateMapIvarWithField(
+            context->result, field, context->syntax);
+        [resultDict addRawEntriesFromDictionary:otherDict];
+      } else {
+        // The exact type doesn't matter, they all implement
+        // -addEntriesFromDictionary:.
+        GPBInt32Int32Dictionary *resultDict = GetOrCreateMapIvarWithField(
+            context->result, field, context->syntax);
+        [resultDict addEntriesFromDictionary:otherDict];
+      }
+    }
+    return YES;
+  }
+
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNumber = GPBFieldNumber(field);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNumber);
+  if (!otherHas) {
+    return YES;
+  }
+  // GPBGetObjectIvarWithFieldNoAutocreate skips the has check, faster.
+  id otherVal = GPBGetObjectIvarWithFieldNoAutocreate(context->other, field);
+  if (GPBFieldTypeIsMessage(field)) {
+    if (GPBGetHasIvar(context->result, hasIndex, fieldNumber)) {
+      GPBMessage *message =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->result, field);
+      [message mergeFrom:otherVal];
+    } else {
+      GPBMessage *message = [otherVal copy];
+      GPBSetRetainedObjectIvarWithFieldInternal(context->result, field, message,
+                                                context->syntax);
+    }
+  } else {
+    GPBSetObjectIvarWithFieldInternal(context->result, field, otherVal,
+                                      context->syntax);
+  }
+  return YES;
+}
+
+- (void)mergeFrom:(GPBMessage *)other {
+  Class selfClass = [self class];
+  Class otherClass = [other class];
+  if (!([selfClass isSubclassOfClass:otherClass] ||
+        [otherClass isSubclassOfClass:selfClass])) {
+    [NSException raise:NSInvalidArgumentException
+                format:@"Classes must match %@ != %@", selfClass, otherClass];
+  }
+
+  GPBApplyFunctions funcs = GPBAPPLY_FUNCTIONS_INIT(MergeFrom);
+  GPBFileSyntax syntax = [self descriptor].file.syntax;
+  MergeFromContext context = {other, self, syntax};
+  GPBApplyFunctionsToMessageFields(&funcs, self, &context);
+
+  // We assume someting got done, and become visible.
+  GPBBecomeVisibleToAutocreator(self);
+
+  // Unknown fields.
+  if (!unknownFields_) {
+    [self setUnknownFields:context.other.unknownFields];
+  } else {
+    [unknownFields_ mergeUnknownFields:context.other.unknownFields];
+  }
+
+  if (other->extensionMap_.count == 0) {
+    return;
+  }
+
+  if (extensionMap_ == nil) {
+    extensionMap_ =
+        CloneExtensionMap(other->extensionMap_, NSZoneFromPointer(self));
+  } else {
+    for (GPBExtensionField *thisField in other->extensionMap_) {
+      id otherValue = [other->extensionMap_ objectForKey:thisField];
+      id value = [extensionMap_ objectForKey:thisField];
+      GPBExtensionDescriptor *thisFieldDescriptor = thisField.descriptor;
+      BOOL isMessageExtension = GPBExtensionIsMessage(thisFieldDescriptor);
+
+      if ([thisField isRepeated]) {
+        NSMutableArray *list = value;
+        if (list == nil) {
+          list = [[NSMutableArray alloc] init];
+          [extensionMap_ setObject:list forKey:thisField];
+          [list release];
+        }
+        if (isMessageExtension) {
+          for (GPBMessage *otherListValue in otherValue) {
+            GPBMessage *copiedValue = [otherListValue copy];
+            [list addObject:copiedValue];
+            [copiedValue release];
+          }
+        } else {
+          [list addObjectsFromArray:otherValue];
+        }
+      } else {
+        if (isMessageExtension) {
+          if (value) {
+            [(GPBMessage *)value mergeFrom:(GPBMessage *)otherValue];
+          } else {
+            GPBMessage *copiedValue = [otherValue copy];
+            [extensionMap_ setObject:copiedValue forKey:thisField];
+            [copiedValue release];
+          }
+        } else {
+          [extensionMap_ setObject:otherValue forKey:thisField];
+        }
+      }
+
+      if (isMessageExtension && !thisFieldDescriptor.isRepeated) {
+        GPBMessage *autocreatedValue =
+            [[autocreatedExtensionMap_ objectForKey:thisField] retain];
+        // Must remove from the map before calling GPBClearMessageAutocreator()
+        // so that GPBClearMessageAutocreator() knows its safe to clear.
+        [autocreatedExtensionMap_ removeObjectForKey:thisField];
+        GPBClearMessageAutocreator(autocreatedValue);
+        [autocreatedValue release];
+      }
+    }
+  }
+}
+
+#pragma mark - IsEqual Support
+
+typedef struct IsEqualContext {
+  GPBMessage *other;
+  GPBMessage *self;
+  BOOL outIsEqual;
+} IsEqualContext;
+
+// If both self and other "has" a value then compare.
+//%PDDM-DEFINE IS_EQUAL_FUNC(NAME, TYPE)
+//%static BOOL IsEqual##NAME(GPBFieldDescriptor *field, void *voidContext) {
+//%  IsEqualContext *context = (IsEqualContext *)voidContext;
+//%  int32_t hasIndex = GPBFieldHasIndex(field);
+//%  uint32_t fieldNum = GPBFieldNumber(field);
+//%  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+//%  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+//%  if (selfHas != otherHas) {
+//%    context->outIsEqual = NO;
+//%    return NO;
+//%  }
+//%  if (!selfHas) {
+//%    return YES;
+//%  }
+//%  TYPE selfVal = GPBGet##NAME##IvarWithField(context->self, field);
+//%  TYPE otherVal = GPBGet##NAME##IvarWithField(context->other, field);
+//%  if (selfVal != otherVal) {
+//%    context->outIsEqual = NO;
+//%    return NO;
+//%  }
+//%  return YES;
+//%}
+//%
+//%PDDM-EXPAND IS_EQUAL_FUNC(Bool, BOOL)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IsEqualBool(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  BOOL selfVal = GPBGetBoolIvarWithField(context->self, field);
+  BOOL otherVal = GPBGetBoolIvarWithField(context->other, field);
+  if (selfVal != otherVal) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND IS_EQUAL_FUNC(Int32, int32_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IsEqualInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  int32_t selfVal = GPBGetInt32IvarWithField(context->self, field);
+  int32_t otherVal = GPBGetInt32IvarWithField(context->other, field);
+  if (selfVal != otherVal) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND IS_EQUAL_FUNC(UInt32, uint32_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IsEqualUInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  uint32_t selfVal = GPBGetUInt32IvarWithField(context->self, field);
+  uint32_t otherVal = GPBGetUInt32IvarWithField(context->other, field);
+  if (selfVal != otherVal) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND IS_EQUAL_FUNC(Int64, int64_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IsEqualInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  int64_t selfVal = GPBGetInt64IvarWithField(context->self, field);
+  int64_t otherVal = GPBGetInt64IvarWithField(context->other, field);
+  if (selfVal != otherVal) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND IS_EQUAL_FUNC(UInt64, uint64_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IsEqualUInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  uint64_t selfVal = GPBGetUInt64IvarWithField(context->self, field);
+  uint64_t otherVal = GPBGetUInt64IvarWithField(context->other, field);
+  if (selfVal != otherVal) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND IS_EQUAL_FUNC(Float, float)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IsEqualFloat(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  float selfVal = GPBGetFloatIvarWithField(context->self, field);
+  float otherVal = GPBGetFloatIvarWithField(context->other, field);
+  if (selfVal != otherVal) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND IS_EQUAL_FUNC(Double, double)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IsEqualDouble(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  double selfVal = GPBGetDoubleIvarWithField(context->self, field);
+  double otherVal = GPBGetDoubleIvarWithField(context->other, field);
+  if (selfVal != otherVal) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND-END (7 expansions)
+
+static BOOL IsEqualObject(GPBFieldDescriptor *field, void *voidContext) {
+  IsEqualContext *context = (IsEqualContext *)voidContext;
+  if (GPBFieldIsMapOrArray(field)) {
+    // In the case of a list/map, there is no _hasIvar to worry about checking.
+    // NOTE: These are NSArray/GPB*Array/NSDictionary/GPB*Dictionary, but the
+    // type doesn't really matter as the object just has to support
+    // -count/-isEqual:.
+    NSArray *resultMapOrArray =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSArray *otherMapOrArray =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->other, field);
+    context->outIsEqual =
+        (resultMapOrArray.count == 0 && otherMapOrArray.count == 0) ||
+        [resultMapOrArray isEqual:otherMapOrArray];
+    return context->outIsEqual;
+  }
+  int32_t hasIndex = GPBFieldHasIndex(field);
+  uint32_t fieldNum = GPBFieldNumber(field);
+  BOOL selfHas = GPBGetHasIvar(context->self, hasIndex, fieldNum);
+  BOOL otherHas = GPBGetHasIvar(context->other, hasIndex, fieldNum);
+  if (selfHas != otherHas) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  if (!selfHas) {
+    return YES;
+  }
+  // GPBGetObjectIvarWithFieldNoAutocreate skips the has check, faster.
+  NSObject *selfVal =
+      GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+  NSObject *otherVal =
+      GPBGetObjectIvarWithFieldNoAutocreate(context->other, field);
+
+  // This covers case where selfVal is set to nil, as well as shortcuts the call
+  // to isEqual: in common cases.
+  if (selfVal == otherVal) {
+    return YES;
+  }
+  if (![selfVal isEqual:otherVal]) {
+    context->outIsEqual = NO;
+    return NO;
+  }
+  return YES;
+}
+
+- (BOOL)isEqual:(GPBMessage *)other {
+  if (other == self) {
+    return YES;
+  }
+  if (![other isKindOfClass:[self class]] &&
+      ![self isKindOfClass:[other class]]) {
+    return NO;
+  }
+  GPBApplyFunctions funcs = GPBAPPLY_FUNCTIONS_INIT(IsEqual);
+  IsEqualContext context = {other, self, YES};
+  GPBApplyFunctionsToMessageFields(&funcs, self, &context);
+  if (!context.outIsEqual) {
+    return NO;
+  }
+
+  // nil and empty are equal
+  if (extensionMap_.count != 0 || other->extensionMap_.count != 0) {
+    if (![extensionMap_ isEqual:other->extensionMap_]) {
+      return NO;
+    }
+  }
+
+  // nil and empty are equal
+  GPBUnknownFieldSet *otherUnknowns = other.unknownFields;
+  if ([unknownFields_ countOfFields] != 0 ||
+      [otherUnknowns countOfFields] != 0) {
+    if (![unknownFields_ isEqual:otherUnknowns]) {
+      return NO;
+    }
+  }
+  return YES;
+}
+
+// It is very difficult to implement a generic hash for ProtoBuf messages that
+// will perform well. If you need hashing on your ProtoBufs (eg you are using
+// them as dictionary keys) you will probably want to implement a ProtoBuf
+// message specific hash as a category on your protobuf class. Do not make it a
+// category on GPBMessage as you will conflict with this hash, and will possibly
+// override hash for all generated protobufs. A good implementation of hash will
+// be really fast, so we would recommend only hashing protobufs that have an
+// identifier field of some kind that you can easily hash. If you implement
+// hash, we would strongly recommend overriding isEqual: in your category as
+// well, as the default implementation of isEqual: is extremely slow, and may
+// drastically affect performance in large sets.
+- (NSUInteger)hash {
+  GPBDescriptor *descriptor = [[self class] descriptor];
+  const NSUInteger prime = 19;
+
+  // Start with the descriptor and then mix it with the field numbers that
+  // are set.  Hopefully that will give a spread based on classes and what
+  // fields are set.
+  NSUInteger result = (NSUInteger)descriptor;
+  for (GPBFieldDescriptor *field in descriptor->fields_) {
+    if (GPBFieldIsMapOrArray(field)) {
+      // Exact type doesn't matter, just check if there are any elements.
+      NSArray *mapOrArray = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
+      if (mapOrArray.count) {
+        result = prime * result + GPBFieldNumber(field);
+      }
+    } else if (GPBGetHasIvarField(self, field)) {
+      result = prime * result + GPBFieldNumber(field);
+    }
+  }
+  return result;
+}
+
+#pragma mark - Description Support
+
+- (NSString *)description {
+  NSString *textFormat = GPBTextFormatForMessage(self, @"    ");
+  NSString *description = [NSString
+      stringWithFormat:@"<%@ %p>: {\n%@}", [self class], self, textFormat];
+  return description;
+}
+
+#if DEBUG
+
+// Xcode 5.1 added support for custom quick look info.
+// https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/CustomClassDisplay_in_QuickLook/CH01-quick_look_for_custom_objects/CH01-quick_look_for_custom_objects.html#//apple_ref/doc/uid/TP40014001-CH2-SW1
+- (id)debugQuickLookObject {
+  return GPBTextFormatForMessage(self, nil);
+}
+
+#endif  // DEBUG
+
+#pragma mark - SerializedSize Support
+
+// Serialized size is only calculated once, and then is stored into
+// memoizedSerializedSize.
+
+typedef struct SerializedSizeContext {
+  GPBMessage *self;
+  size_t outSize;
+} SerializedSizeContext;
+
+//%PDDM-DEFINE SERIALIZED_SIZE_POD_FUNC(NAME, TYPE, REAL_TYPE)
+//%SERIALIZED_SIZE_POD_FUNC_FULL(NAME, TYPE, REAL_TYPE, REAL_TYPE, )
+//%PDDM-DEFINE SERIALIZED_SIZE_POD_FUNC_FULL(NAME, TYPE, REAL_TYPE, ARRAY_TYPE, ARRAY_ACCESSOR_NAME)
+//%static BOOL DynamicSerializedSize##NAME(GPBFieldDescriptor *field,
+//%                                NAME$S  void *voidContext) {
+//%  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+//%  GPBFieldType fieldType = field.fieldType;
+//%  if (fieldType == GPBFieldTypeRepeated) {
+//%    GPB##ARRAY_TYPE##Array *array =
+//%        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+//%    NSUInteger count = array.count;
+//%    if (count == 0) return YES;
+//%    __block size_t dataSize = 0;
+//%    [array enumerate##ARRAY_ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
+//%      #pragma unused(idx, stop)
+//%      dataSize += GPBCompute##NAME##SizeNoTag(value);
+//%    }];
+//%    context->outSize += dataSize;
+//%    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+//%    if (field.isPackable) {
+//%      context->outSize += tagSize;
+//%      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+//%    } else {
+//%      context->outSize += count * tagSize;
+//%    }
+//%  } else if (fieldType == GPBFieldTypeSingle) {
+//%    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+//%    if (selfHas) {
+//%      TYPE selfVal = GPBGet##REAL_TYPE##IvarWithField(context->self, field);
+//%      context->outSize += GPBCompute##NAME##Size(GPBFieldNumber(field), selfVal);
+//%    }
+//%  } else {  // fieldType == GPBFieldTypeMap
+//%    // Type will be GPB*##REAL_TYPE##Dictionary, exact type doesn't matter.
+//%    GPBInt32##REAL_TYPE##Dictionary *map =
+//%        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+//%    context->outSize += [map computeSerializedSizeAsField:field];
+//%  }
+//%  return YES;
+//%}
+//%
+//%PDDM-DEFINE SERIALIZED_SIZE_OBJECT_FUNC(NAME)
+//%static BOOL DynamicSerializedSize##NAME(GPBFieldDescriptor *field,
+//%                                NAME$S  void *voidContext) {
+//%  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+//%  GPBFieldType fieldType = field.fieldType;
+//%  if (fieldType == GPBFieldTypeRepeated) {
+//%    NSArray *array =
+//%        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+//%    for (id value in array) {
+//%      context->outSize += GPBCompute##NAME##SizeNoTag(value);
+//%    }
+//%    size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field),
+//%                                                 GPBGetFieldType(field));
+//%    context->outSize += array.count * tagSize;
+//%  } else if (fieldType == GPBFieldTypeSingle) {
+//%    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+//%    if (selfHas) {
+//%      // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+//%      // again.
+//%      id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+//%      context->outSize += GPBCompute##NAME##Size(GPBFieldNumber(field), selfVal);
+//%    }
+//%  } else {  // fieldType == GPBFieldTypeMap
+//%    GPBType mapKeyType = field.mapKeyType;
+//%    if (mapKeyType == GPBTypeString) {
+//%      // If key type was string, then the map is an NSDictionary.
+//%      NSDictionary *map =
+//%          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+//%      context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field);
+//%    } else {
+//%      // Type will be GPB*##NAME##Dictionary, exact type doesn't matter.
+//%      GPBInt32ObjectDictionary *map =
+//%          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+//%      context->outSize += [map computeSerializedSizeAsField:field];
+//%    }
+//%  }
+//%  return YES;
+//%}
+//%
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Bool, BOOL, Bool)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeBool(GPBFieldDescriptor *field,
+                                      void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBBoolArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeBoolSizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      BOOL selfVal = GPBGetBoolIvarWithField(context->self, field);
+      context->outSize += GPBComputeBoolSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*BoolDictionary, exact type doesn't matter.
+    GPBInt32BoolDictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Int32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeInt32(GPBFieldDescriptor *field,
+                                       void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt32Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeInt32SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      int32_t selfVal = GPBGetInt32IvarWithField(context->self, field);
+      context->outSize += GPBComputeInt32Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*Int32Dictionary, exact type doesn't matter.
+    GPBInt32Int32Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SInt32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeSInt32(GPBFieldDescriptor *field,
+                                        void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt32Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeSInt32SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      int32_t selfVal = GPBGetInt32IvarWithField(context->self, field);
+      context->outSize += GPBComputeSInt32Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*Int32Dictionary, exact type doesn't matter.
+    GPBInt32Int32Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SFixed32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeSFixed32(GPBFieldDescriptor *field,
+                                          void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt32Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeSFixed32SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      int32_t selfVal = GPBGetInt32IvarWithField(context->self, field);
+      context->outSize += GPBComputeSFixed32Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*Int32Dictionary, exact type doesn't matter.
+    GPBInt32Int32Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC_FULL(Enum, int32_t, Int32, Enum, Raw)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeEnum(GPBFieldDescriptor *field,
+                                      void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBEnumArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeEnumSizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      int32_t selfVal = GPBGetInt32IvarWithField(context->self, field);
+      context->outSize += GPBComputeEnumSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*Int32Dictionary, exact type doesn't matter.
+    GPBInt32Int32Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(UInt32, uint32_t, UInt32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeUInt32(GPBFieldDescriptor *field,
+                                        void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt32Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeUInt32SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      uint32_t selfVal = GPBGetUInt32IvarWithField(context->self, field);
+      context->outSize += GPBComputeUInt32Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*UInt32Dictionary, exact type doesn't matter.
+    GPBInt32UInt32Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Fixed32, uint32_t, UInt32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeFixed32(GPBFieldDescriptor *field,
+                                         void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt32Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeFixed32SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      uint32_t selfVal = GPBGetUInt32IvarWithField(context->self, field);
+      context->outSize += GPBComputeFixed32Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*UInt32Dictionary, exact type doesn't matter.
+    GPBInt32UInt32Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Int64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeInt64(GPBFieldDescriptor *field,
+                                       void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt64Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeInt64SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      int64_t selfVal = GPBGetInt64IvarWithField(context->self, field);
+      context->outSize += GPBComputeInt64Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*Int64Dictionary, exact type doesn't matter.
+    GPBInt32Int64Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SFixed64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeSFixed64(GPBFieldDescriptor *field,
+                                          void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt64Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeSFixed64SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      int64_t selfVal = GPBGetInt64IvarWithField(context->self, field);
+      context->outSize += GPBComputeSFixed64Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*Int64Dictionary, exact type doesn't matter.
+    GPBInt32Int64Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(SInt64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeSInt64(GPBFieldDescriptor *field,
+                                        void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBInt64Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeSInt64SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      int64_t selfVal = GPBGetInt64IvarWithField(context->self, field);
+      context->outSize += GPBComputeSInt64Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*Int64Dictionary, exact type doesn't matter.
+    GPBInt32Int64Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(UInt64, uint64_t, UInt64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeUInt64(GPBFieldDescriptor *field,
+                                        void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt64Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeUInt64SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      uint64_t selfVal = GPBGetUInt64IvarWithField(context->self, field);
+      context->outSize += GPBComputeUInt64Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*UInt64Dictionary, exact type doesn't matter.
+    GPBInt32UInt64Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Fixed64, uint64_t, UInt64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeFixed64(GPBFieldDescriptor *field,
+                                         void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBUInt64Array *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeFixed64SizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      uint64_t selfVal = GPBGetUInt64IvarWithField(context->self, field);
+      context->outSize += GPBComputeFixed64Size(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*UInt64Dictionary, exact type doesn't matter.
+    GPBInt32UInt64Dictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Float, float, Float)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeFloat(GPBFieldDescriptor *field,
+                                       void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBFloatArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeFloatSizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      float selfVal = GPBGetFloatIvarWithField(context->self, field);
+      context->outSize += GPBComputeFloatSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*FloatDictionary, exact type doesn't matter.
+    GPBInt32FloatDictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_POD_FUNC(Double, double, Double)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeDouble(GPBFieldDescriptor *field,
+                                        void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    GPBDoubleArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    NSUInteger count = array.count;
+    if (count == 0) return YES;
+    __block size_t dataSize = 0;
+    [array enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
+      #pragma unused(idx, stop)
+      dataSize += GPBComputeDoubleSizeNoTag(value);
+    }];
+    context->outSize += dataSize;
+    size_t tagSize = GPBComputeTagSize(GPBFieldNumber(field));
+    if (field.isPackable) {
+      context->outSize += tagSize;
+      context->outSize += GPBComputeSizeTSizeAsInt32NoTag(dataSize);
+    } else {
+      context->outSize += count * tagSize;
+    }
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      double selfVal = GPBGetDoubleIvarWithField(context->self, field);
+      context->outSize += GPBComputeDoubleSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    // Type will be GPB*DoubleDictionary, exact type doesn't matter.
+    GPBInt32DoubleDictionary *map =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    context->outSize += [map computeSerializedSizeAsField:field];
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(String)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeString(GPBFieldDescriptor *field,
+                                        void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    NSArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    for (id value in array) {
+      context->outSize += GPBComputeStringSizeNoTag(value);
+    }
+    size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field),
+                                                 GPBGetFieldType(field));
+    context->outSize += array.count * tagSize;
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+      // again.
+      id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBComputeStringSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    GPBType mapKeyType = field.mapKeyType;
+    if (mapKeyType == GPBTypeString) {
+      // If key type was string, then the map is an NSDictionary.
+      NSDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field);
+    } else {
+      // Type will be GPB*StringDictionary, exact type doesn't matter.
+      GPBInt32ObjectDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += [map computeSerializedSizeAsField:field];
+    }
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(Data)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeData(GPBFieldDescriptor *field,
+                                      void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    NSArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    for (id value in array) {
+      context->outSize += GPBComputeDataSizeNoTag(value);
+    }
+    size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field),
+                                                 GPBGetFieldType(field));
+    context->outSize += array.count * tagSize;
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+      // again.
+      id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBComputeDataSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    GPBType mapKeyType = field.mapKeyType;
+    if (mapKeyType == GPBTypeString) {
+      // If key type was string, then the map is an NSDictionary.
+      NSDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field);
+    } else {
+      // Type will be GPB*DataDictionary, exact type doesn't matter.
+      GPBInt32ObjectDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += [map computeSerializedSizeAsField:field];
+    }
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(Message)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeMessage(GPBFieldDescriptor *field,
+                                         void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    NSArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    for (id value in array) {
+      context->outSize += GPBComputeMessageSizeNoTag(value);
+    }
+    size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field),
+                                                 GPBGetFieldType(field));
+    context->outSize += array.count * tagSize;
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+      // again.
+      id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBComputeMessageSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    GPBType mapKeyType = field.mapKeyType;
+    if (mapKeyType == GPBTypeString) {
+      // If key type was string, then the map is an NSDictionary.
+      NSDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field);
+    } else {
+      // Type will be GPB*MessageDictionary, exact type doesn't matter.
+      GPBInt32ObjectDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += [map computeSerializedSizeAsField:field];
+    }
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND SERIALIZED_SIZE_OBJECT_FUNC(Group)
+// This block of code is generated, do not edit it directly.
+
+static BOOL DynamicSerializedSizeGroup(GPBFieldDescriptor *field,
+                                       void *voidContext) {
+  SerializedSizeContext *context = (SerializedSizeContext *)voidContext;
+  GPBFieldType fieldType = field.fieldType;
+  if (fieldType == GPBFieldTypeRepeated) {
+    NSArray *array =
+        GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+    for (id value in array) {
+      context->outSize += GPBComputeGroupSizeNoTag(value);
+    }
+    size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field),
+                                                 GPBGetFieldType(field));
+    context->outSize += array.count * tagSize;
+  } else if (fieldType == GPBFieldTypeSingle) {
+    BOOL selfHas = GPBGetHasIvarField(context->self, field);
+    if (selfHas) {
+      // GPBGetObjectIvarWithFieldNoAutocreate() avoids doing the has check
+      // again.
+      id selfVal = GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBComputeGroupSize(GPBFieldNumber(field), selfVal);
+    }
+  } else {  // fieldType == GPBFieldTypeMap
+    GPBType mapKeyType = field.mapKeyType;
+    if (mapKeyType == GPBTypeString) {
+      // If key type was string, then the map is an NSDictionary.
+      NSDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += GPBDictionaryComputeSizeInternalHelper(map, field);
+    } else {
+      // Type will be GPB*GroupDictionary, exact type doesn't matter.
+      GPBInt32ObjectDictionary *map =
+          GPBGetObjectIvarWithFieldNoAutocreate(context->self, field);
+      context->outSize += [map computeSerializedSizeAsField:field];
+    }
+  }
+  return YES;
+}
+
+//%PDDM-EXPAND-END (18 expansions)
+
+- (size_t)serializedSize {
+  // Fields.
+  SerializedSizeContext context = {self, 0};
+  GPBApplyStrictFunctions funcs =
+      GPBAPPLY_STRICT_FUNCTIONS_INIT(DynamicSerializedSize);
+  GPBApplyStrictFunctionsToMessageFields(&funcs, self, &context);
+  // Add any unknown fields.
+  const GPBDescriptor *descriptor = [self descriptor];
+  if (descriptor.wireFormat) {
+    context.outSize += [unknownFields_ serializedSizeAsMessageSet];
+  } else {
+    context.outSize += [unknownFields_ serializedSize];
+  }
+  // Add any extensions.
+  for (GPBExtensionField *extension in extensionMap_) {
+    id value = [extensionMap_ objectForKey:extension];
+    context.outSize += [extension computeSerializedSizeIncludingTag:value];
+  }
+
+  return context.outSize;
+}
+
+#pragma mark - Resolve Methods Support
+
+typedef struct IvarAccessorMethodContext {
+  GPBFileSyntax syntax;
+  IMP impToAdd;
+  SEL encodingSelector;
+} IvarAccessorMethodContext;
+
+//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_COMMON(NAME, TYPE, TRUE_NAME)
+//%static BOOL IvarGet##NAME(GPBFieldDescriptor *field, void *voidContext) {
+//%  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+//%  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+//%    return GPBGet##TRUE_NAME##IvarWithField(obj, field);
+//%  });
+//%  context->encodingSelector = @selector(get##NAME);
+//%  return NO;
+//%}
+//%
+//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_OBJECT(NAME, TYPE)
+//%IVAR_ACCESSOR_FUNC_COMMON(NAME, TYPE, Object)
+//%static BOOL IvarSet##NAME(GPBFieldDescriptor *field, void *voidContext) {
+//%  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+//%  // Local for syntax so the block doesn't capture context and use random
+//%  // memory in the future.
+//%  const GPBFileSyntax syntax = context->syntax;
+//%  context->impToAdd = imp_implementationWithBlock(^(id obj, TYPE value) {
+//%    return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax);
+//%  });
+//%  context->encodingSelector = @selector(set##NAME:);
+//%  return NO;
+//%}
+//%
+//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_PER_VERSION(NAME, TYPE)
+//%IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(NAME, TYPE, NAME)
+//%PDDM-DEFINE IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(NAME, TYPE, TRUE_NAME)
+//%IVAR_ACCESSOR_FUNC_COMMON(NAME, TYPE, TRUE_NAME)
+//%static BOOL IvarSet##NAME(GPBFieldDescriptor *field, void *voidContext) {
+//%  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+//%  // Local for syntax so the block doesn't capture context and use random
+//%  // memory in the future.
+//%  const GPBFileSyntax syntax = context->syntax;
+//%  context->impToAdd = imp_implementationWithBlock(^(id obj, TYPE value) {
+//%    return GPBSet##TRUE_NAME##IvarWithFieldInternal(obj, field, value, syntax);
+//%  });
+//%  context->encodingSelector = @selector(set##NAME:);
+//%  return NO;
+//%}
+//%
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Bool, BOOL)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetBool(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetBoolIvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getBool);
+  return NO;
+}
+
+static BOOL IvarSetBool(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, BOOL value) {
+    return GPBSetBoolIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setBool:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Int32, int32_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetInt32IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getInt32);
+  return NO;
+}
+
+static BOOL IvarSetInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) {
+    return GPBSetInt32IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setInt32:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SInt32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetSInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetInt32IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getSInt32);
+  return NO;
+}
+
+static BOOL IvarSetSInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) {
+    return GPBSetInt32IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setSInt32:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SFixed32, int32_t, Int32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetSFixed32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetInt32IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getSFixed32);
+  return NO;
+}
+
+static BOOL IvarSetSFixed32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) {
+    return GPBSetInt32IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setSFixed32:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(UInt32, uint32_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetUInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetUInt32IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getUInt32);
+  return NO;
+}
+
+static BOOL IvarSetUInt32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, uint32_t value) {
+    return GPBSetUInt32IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setUInt32:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(Fixed32, uint32_t, UInt32)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetFixed32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetUInt32IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getFixed32);
+  return NO;
+}
+
+static BOOL IvarSetFixed32(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, uint32_t value) {
+    return GPBSetUInt32IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setFixed32:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Int64, int64_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetInt64IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getInt64);
+  return NO;
+}
+
+static BOOL IvarSetInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, int64_t value) {
+    return GPBSetInt64IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setInt64:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SFixed64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetSFixed64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetInt64IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getSFixed64);
+  return NO;
+}
+
+static BOOL IvarSetSFixed64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, int64_t value) {
+    return GPBSetInt64IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setSFixed64:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(SInt64, int64_t, Int64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetSInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetInt64IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getSInt64);
+  return NO;
+}
+
+static BOOL IvarSetSInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, int64_t value) {
+    return GPBSetInt64IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setSInt64:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(UInt64, uint64_t)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetUInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetUInt64IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getUInt64);
+  return NO;
+}
+
+static BOOL IvarSetUInt64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, uint64_t value) {
+    return GPBSetUInt64IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setUInt64:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION_ALIASED(Fixed64, uint64_t, UInt64)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetFixed64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetUInt64IvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getFixed64);
+  return NO;
+}
+
+static BOOL IvarSetFixed64(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, uint64_t value) {
+    return GPBSetUInt64IvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setFixed64:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Float, float)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetFloat(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetFloatIvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getFloat);
+  return NO;
+}
+
+static BOOL IvarSetFloat(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, float value) {
+    return GPBSetFloatIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setFloat:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_PER_VERSION(Double, double)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetDouble(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetDoubleIvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getDouble);
+  return NO;
+}
+
+static BOOL IvarSetDouble(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, double value) {
+    return GPBSetDoubleIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setDouble:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(String, id)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetString(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetObjectIvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getString);
+  return NO;
+}
+
+static BOOL IvarSetString(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, id value) {
+    return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setString:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(Data, id)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetData(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetObjectIvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getData);
+  return NO;
+}
+
+static BOOL IvarSetData(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, id value) {
+    return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setData:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(Message, id)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetMessage(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetObjectIvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getMessage);
+  return NO;
+}
+
+static BOOL IvarSetMessage(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, id value) {
+    return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setMessage:);
+  return NO;
+}
+
+//%PDDM-EXPAND IVAR_ACCESSOR_FUNC_OBJECT(Group, id)
+// This block of code is generated, do not edit it directly.
+
+static BOOL IvarGetGroup(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetObjectIvarWithField(obj, field);
+  });
+  context->encodingSelector = @selector(getGroup);
+  return NO;
+}
+
+static BOOL IvarSetGroup(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, id value) {
+    return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setGroup:);
+  return NO;
+}
+
+//%PDDM-EXPAND-END (17 expansions)
+
+// Enum gets custom hooks because get needs the syntax to Get.
+
+static BOOL IvarGetEnum(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj) {
+    return GPBGetEnumIvarWithFieldInternal(obj, field, syntax);
+  });
+  context->encodingSelector = @selector(getEnum);
+  return NO;
+}
+
+static BOOL IvarSetEnum(GPBFieldDescriptor *field, void *voidContext) {
+  IvarAccessorMethodContext *context = (IvarAccessorMethodContext *)voidContext;
+  // Local for syntax so the block doesn't capture context and use random
+  // memory in the future.
+  const GPBFileSyntax syntax = context->syntax;
+  context->impToAdd = imp_implementationWithBlock(^(id obj, int32_t value) {
+    return GPBSetEnumIvarWithFieldInternal(obj, field, value, syntax);
+  });
+  context->encodingSelector = @selector(setEnum:);
+  return NO;
+}
+
++ (BOOL)resolveInstanceMethod:(SEL)sel {
+  const GPBDescriptor *descriptor = [self descriptor];
+  if (!descriptor) {
+    return NO;
+  }
+
+  // NOTE: hasSel_/setHasSel_ will be NULL if the field for the given message
+  // should not have has support (done in GPBDescriptor.m), so there is no need
+  // for checks here to see if has*/setHas* are allowed.
+
+  IvarAccessorMethodContext context = {descriptor.file.syntax, NULL, NULL};
+  for (GPBFieldDescriptor *field in descriptor->fields_) {
+    BOOL isMapOrArray = GPBFieldIsMapOrArray(field);
+    if (!isMapOrArray) {
+      if (sel == field->getSel_) {
+        static const GPBApplyStrictFunctions funcs =
+            GPBAPPLY_STRICT_FUNCTIONS_INIT(IvarGet);
+        funcs[GPBGetFieldType(field)](field, &context);
+        break;
+      } else if (sel == field->hasSel_) {
+        int32_t index = GPBFieldHasIndex(field);
+        uint32_t fieldNum = GPBFieldNumber(field);
+        context.impToAdd = imp_implementationWithBlock(^(id obj) {
+          return GPBGetHasIvar(obj, index, fieldNum);
+        });
+        context.encodingSelector = @selector(getBool);
+        break;
+      } else if (sel == field->setHasSel_) {
+        context.impToAdd = imp_implementationWithBlock(^(id obj, BOOL value) {
+          if (value) {
+            [NSException raise:NSInvalidArgumentException
+                        format:@"has fields can only be set to NO"];
+          }
+          GPBClearMessageField(obj, field);
+        });
+        context.encodingSelector = @selector(setBool:);
+        break;
+      } else if (sel == field->setSel_) {
+        GPBApplyStrictFunctions funcs = GPBAPPLY_STRICT_FUNCTIONS_INIT(IvarSet);
+        funcs[GPBGetFieldType(field)](field, &context);
+        break;
+      } else {
+        GPBOneofDescriptor *oneof = field->containingOneof_;
+        if (oneof && (sel == oneof->caseSel_)) {
+          int32_t index = oneof->oneofDescription_->index;
+          context.impToAdd = imp_implementationWithBlock(^(id obj) {
+            return GPBGetHasOneof(obj, index);
+          });
+          context.encodingSelector = @selector(getEnum);
+          break;
+        }
+      }
+    } else {
+      if (sel == field->getSel_) {
+        context.impToAdd = imp_implementationWithBlock(^(id obj) {
+          return GetArrayIvarWithField(obj, field);
+        });
+        context.encodingSelector = @selector(getArray);
+        break;
+      } else if (sel == field->setSel_) {
+        // Local for syntax so the block doesn't capture context and use random
+        // memory in the future.
+        const GPBFileSyntax syntax = context.syntax;
+        context.impToAdd = imp_implementationWithBlock(^(id obj, id value) {
+          return GPBSetObjectIvarWithFieldInternal(obj, field, value, syntax);
+        });
+        context.encodingSelector = @selector(setArray:);
+        break;
+      }
+    }
+  }
+  if (context.impToAdd) {
+    const char *encoding =
+        GPBMessageEncodingForSelector(context.encodingSelector, YES);
+    BOOL methodAdded = class_addMethod(descriptor.messageClass, sel,
+                                       context.impToAdd, encoding);
+    return methodAdded;
+  }
+  return [super resolveInstanceMethod:sel];
+}
+
+#pragma mark - NSCoding Support
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  self = [self init];
+  if (self) {
+    [self mergeFromData:[aDecoder decodeDataObject] extensionRegistry:nil];
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeDataObject:[self data]];
+}
+
+#pragma mark - KVC Support
+
++ (BOOL)accessInstanceVariablesDirectly {
+  // Make sure KVC doesn't use instance variables.
+  return NO;
+}
+
+@end