// 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.h"
#import "GPBRootObject_PackagePrivate.h"
#import "GPBUnknownFieldSet_PackagePrivate.h"
#import "GPBUtilities_PackagePrivate.h"

NSString *const GPBMessageErrorDomain =
    GPBNSStringifySymbol(GPBMessageErrorDomain);

#ifdef DEBUG
NSString *const GPBExceptionMessageKey =
    GPBNSStringifySymbol(GPBExceptionMessage);
#endif  // DEBUG

static NSString *const kGPBDataCoderKey = @"GPBData";

//
// 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 CreateMapForField(GPBFieldDescriptor *field,
                            GPBMessage *autocreator)
    __attribute__((ns_returns_retained));
static id GetOrCreateMapIvarWithField(GPBMessage *self,
                                      GPBFieldDescriptor *field,
                                      GPBFileSyntax syntax);
static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field);
static NSMutableDictionary *CloneExtensionMap(NSDictionary *extensionMap,
                                              NSZone *zone)
    __attribute__((ns_returns_retained));

static NSError *MessageError(NSInteger code, NSDictionary *userInfo) {
  return [NSError errorWithDomain:GPBMessageErrorDomain
                             code:code
                         userInfo:userInfo];
}

static NSError *MessageErrorWithReason(NSInteger code, NSString *reason) {
  NSDictionary *userInfo = nil;
  if ([reason length]) {
    userInfo = @{ @"Reason" : reason };
  }
  return MessageError(code, userInfo);
}


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;
}

static id CreateMapForField(GPBFieldDescriptor *field,
                            GPBMessage *autocreator) {
  id result;
  GPBType keyType = field.mapKeyType;
  GPBType valueType = GPBGetFieldType(field);
  switch (keyType) {
    case GPBTypeBool:
      switch (valueType) {
        case GPBTypeBool:
          result = [[GPBBoolBoolDictionary alloc] init];
          break;
        case GPBTypeFixed32:
        case GPBTypeUInt32:
          result = [[GPBBoolUInt32Dictionary alloc] init];
          break;
        case GPBTypeInt32:
        case GPBTypeSFixed32:
        case GPBTypeSInt32:
          result = [[GPBBoolInt32Dictionary alloc] init];
          break;
        case GPBTypeFixed64:
        case GPBTypeUInt64:
          result = [[GPBBoolUInt64Dictionary alloc] init];
          break;
        case GPBTypeInt64:
        case GPBTypeSFixed64:
        case GPBTypeSInt64:
          result = [[GPBBoolInt64Dictionary alloc] init];
          break;
        case GPBTypeFloat:
          result = [[GPBBoolFloatDictionary alloc] init];
          break;
        case GPBTypeDouble:
          result = [[GPBBoolDoubleDictionary alloc] init];
          break;
        case GPBTypeEnum:
          result = [[GPBBoolEnumDictionary alloc]
              initWithValidationFunction:field.enumDescriptor.enumVerifier];
          break;
        case GPBTypeData:
        case GPBTypeMessage:
        case GPBTypeString:
          result = [[GPBBoolObjectDictionary alloc] init];
          break;
        case GPBTypeGroup:
          NSCAssert(NO, @"shouldn't happen");
          return nil;
      }
      break;
    case GPBTypeFixed32:
    case GPBTypeUInt32:
      switch (valueType) {
        case GPBTypeBool:
          result = [[GPBUInt32BoolDictionary alloc] init];
          break;
        case GPBTypeFixed32:
        case GPBTypeUInt32:
          result = [[GPBUInt32UInt32Dictionary alloc] init];
          break;
        case GPBTypeInt32:
        case GPBTypeSFixed32:
        case GPBTypeSInt32:
          result = [[GPBUInt32Int32Dictionary alloc] init];
          break;
        case GPBTypeFixed64:
        case GPBTypeUInt64:
          result = [[GPBUInt32UInt64Dictionary alloc] init];
          break;
        case GPBTypeInt64:
        case GPBTypeSFixed64:
        case GPBTypeSInt64:
          result = [[GPBUInt32Int64Dictionary alloc] init];
          break;
        case GPBTypeFloat:
          result = [[GPBUInt32FloatDictionary alloc] init];
          break;
        case GPBTypeDouble:
          result = [[GPBUInt32DoubleDictionary alloc] init];
          break;
        case GPBTypeEnum:
          result = [[GPBUInt32EnumDictionary alloc]
              initWithValidationFunction:field.enumDescriptor.enumVerifier];
          break;
        case GPBTypeData:
        case GPBTypeMessage:
        case GPBTypeString:
          result = [[GPBUInt32ObjectDictionary alloc] init];
          break;
        case GPBTypeGroup:
          NSCAssert(NO, @"shouldn't happen");
          return nil;
      }
      break;
    case GPBTypeInt32:
    case GPBTypeSFixed32:
    case GPBTypeSInt32:
      switch (valueType) {
        case GPBTypeBool:
          result = [[GPBInt32BoolDictionary alloc] init];
          break;
        case GPBTypeFixed32:
        case GPBTypeUInt32:
          result = [[GPBInt32UInt32Dictionary alloc] init];
          break;
        case GPBTypeInt32:
        case GPBTypeSFixed32:
        case GPBTypeSInt32:
          result = [[GPBInt32Int32Dictionary alloc] init];
          break;
        case GPBTypeFixed64:
        case GPBTypeUInt64:
          result = [[GPBInt32UInt64Dictionary alloc] init];
          break;
        case GPBTypeInt64:
        case GPBTypeSFixed64:
        case GPBTypeSInt64:
          result = [[GPBInt32Int64Dictionary alloc] init];
          break;
        case GPBTypeFloat:
          result = [[GPBInt32FloatDictionary alloc] init];
          break;
        case GPBTypeDouble:
          result = [[GPBInt32DoubleDictionary alloc] init];
          break;
        case GPBTypeEnum:
          result = [[GPBInt32EnumDictionary alloc]
              initWithValidationFunction:field.enumDescriptor.enumVerifier];
          break;
        case GPBTypeData:
        case GPBTypeMessage:
        case GPBTypeString:
          result = [[GPBInt32ObjectDictionary alloc] init];
          break;
        case GPBTypeGroup:
          NSCAssert(NO, @"shouldn't happen");
          return nil;
      }
      break;
    case GPBTypeFixed64:
    case GPBTypeUInt64:
      switch (valueType) {
        case GPBTypeBool:
          result = [[GPBUInt64BoolDictionary alloc] init];
          break;
        case GPBTypeFixed32:
        case GPBTypeUInt32:
          result = [[GPBUInt64UInt32Dictionary alloc] init];
          break;
        case GPBTypeInt32:
        case GPBTypeSFixed32:
        case GPBTypeSInt32:
          result = [[GPBUInt64Int32Dictionary alloc] init];
          break;
        case GPBTypeFixed64:
        case GPBTypeUInt64:
          result = [[GPBUInt64UInt64Dictionary alloc] init];
          break;
        case GPBTypeInt64:
        case GPBTypeSFixed64:
        case GPBTypeSInt64:
          result = [[GPBUInt64Int64Dictionary alloc] init];
          break;
        case GPBTypeFloat:
          result = [[GPBUInt64FloatDictionary alloc] init];
          break;
        case GPBTypeDouble:
          result = [[GPBUInt64DoubleDictionary alloc] init];
          break;
        case GPBTypeEnum:
          result = [[GPBUInt64EnumDictionary alloc]
              initWithValidationFunction:field.enumDescriptor.enumVerifier];
          break;
        case GPBTypeData:
        case GPBTypeMessage:
        case GPBTypeString:
          result = [[GPBUInt64ObjectDictionary alloc] init];
          break;
        case GPBTypeGroup:
          NSCAssert(NO, @"shouldn't happen");
          return nil;
      }
      break;
    case GPBTypeInt64:
    case GPBTypeSFixed64:
    case GPBTypeSInt64:
      switch (valueType) {
        case GPBTypeBool:
          result = [[GPBInt64BoolDictionary alloc] init];
          break;
        case GPBTypeFixed32:
        case GPBTypeUInt32:
          result = [[GPBInt64UInt32Dictionary alloc] init];
          break;
        case GPBTypeInt32:
        case GPBTypeSFixed32:
        case GPBTypeSInt32:
          result = [[GPBInt64Int32Dictionary alloc] init];
          break;
        case GPBTypeFixed64:
        case GPBTypeUInt64:
          result = [[GPBInt64UInt64Dictionary alloc] init];
          break;
        case GPBTypeInt64:
        case GPBTypeSFixed64:
        case GPBTypeSInt64:
          result = [[GPBInt64Int64Dictionary alloc] init];
          break;
        case GPBTypeFloat:
          result = [[GPBInt64FloatDictionary alloc] init];
          break;
        case GPBTypeDouble:
          result = [[GPBInt64DoubleDictionary alloc] init];
          break;
        case GPBTypeEnum:
          result = [[GPBInt64EnumDictionary alloc]
              initWithValidationFunction:field.enumDescriptor.enumVerifier];
          break;
        case GPBTypeData:
        case GPBTypeMessage:
        case GPBTypeString:
          result = [[GPBInt64ObjectDictionary alloc] init];
          break;
        case GPBTypeGroup:
          NSCAssert(NO, @"shouldn't happen");
          return nil;
      }
      break;
    case GPBTypeString:
      switch (valueType) {
        case GPBTypeBool:
          result = [[GPBStringBoolDictionary alloc] init];
          break;
        case GPBTypeFixed32:
        case GPBTypeUInt32:
          result = [[GPBStringUInt32Dictionary alloc] init];
          break;
        case GPBTypeInt32:
        case GPBTypeSFixed32:
        case GPBTypeSInt32:
          result = [[GPBStringInt32Dictionary alloc] init];
          break;
        case GPBTypeFixed64:
        case GPBTypeUInt64:
          result = [[GPBStringUInt64Dictionary alloc] init];
          break;
        case GPBTypeInt64:
        case GPBTypeSFixed64:
        case GPBTypeSInt64:
          result = [[GPBStringInt64Dictionary alloc] init];
          break;
        case GPBTypeFloat:
          result = [[GPBStringFloatDictionary alloc] init];
          break;
        case GPBTypeDouble:
          result = [[GPBStringDoubleDictionary alloc] init];
          break;
        case GPBTypeEnum:
          result = [[GPBStringEnumDictionary alloc]
              initWithValidationFunction:field.enumDescriptor.enumVerifier];
          break;
        case GPBTypeData:
        case GPBTypeMessage:
        case GPBTypeString:
          if (autocreator) {
            result = [[GPBAutocreatedDictionary alloc] init];
          } else {
            result = [[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;
  }

  if (autocreator) {
    if ((keyType == GPBTypeString) && GPBTypeIsObject(valueType)) {
      GPBAutocreatedDictionary *autoDict = result;
      autoDict->_autocreator =  autocreator;
    } else {
      GPBInt32Int32Dictionary *gpbDict = result;
      gpbDict->_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) {
    // No lock needed, this is called from places expecting to mutate
    // so no threading protection is needed.
    dict = CreateMapForField(field, nil);
    GPBSetRetainedObjectIvarWithFieldInternal(self, field, dict, syntax);
  }
  return dict;
}

// This is like GPBGetObjectIvarWithField(), but for maps, it should
// only be used to wire the method into the class.
static id GetMapIvarWithField(GPBMessage *self, GPBFieldDescriptor *field) {
  id dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
  if (!dict) {
    // Check again after getting the lock.
    OSSpinLockLock(&self->readOnlyMutex_);
    dict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
    if (!dict) {
      dict = CreateMapForField(field, self);
      GPBSetAutocreatedRetainedObjectIvarWithField(self, field, dict);
    }
    OSSpinLockUnlock(&self->readOnlyMutex_);
  }
  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 autocreated %@ for %@.", [array class], self);
}

void GPBAutocreatedDictionaryModified(GPBMessage *self, id dictionary) {
  // When one of our autocreated dicts adds elements, make it visible.
  GPBDescriptor *descriptor = [[self class] descriptor];
  for (GPBFieldDescriptor *field in descriptor->fields_) {
    if (field.fieldType == GPBFieldTypeMap) {
      id curDict = GPBGetObjectIvarWithFieldNoAutocreate(self, field);
      if (curDict == dictionary) {
        if ((field.mapKeyType == GPBTypeString) &&
            GPBFieldTypeIsObject(field)) {
          GPBAutocreatedDictionary *autoDict = dictionary;
          autoDict->_autocreator = nil;
        } else {
          GPBInt32Int32Dictionary *gpbDict = dictionary;
          gpbDict->_autocreator = nil;
        }
        GPBBecomeVisibleToAutocreator(self);
        return;
      }
    }
  }
  NSCAssert(NO, @"Unknown autocreated %@ for %@.", [dictionary class], self);
}

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, self: %@.",
            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_;
}

@implementation GPBMessage

+ (void)initialize {
  Class pbMessageClass = [GPBMessage class];
  if ([self class] == pbMessageClass) {
    // This is here to start up the "base" class descriptor.
    [self descriptor];
    // Message shares extension method resolving with GPBRootObject so insure
    // it is started up at the same time.
    (void)[GPBRootObject class];
  } 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.
    // Note: The generated code for -descriptor calls
    // +[GPBDescriptor allocDescriptorForClass:...], passing the GPBRootObject
    // subclass for the file.  That call chain is what ensures that *Root class
    // is started up to support extension resolution off the message class
    // (+resolveClassMethod: below) in a thread safe manner.
    [self descriptor];
  }
}

+ (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 error:(NSError **)errorPtr {
  return [self initWithData:data extensionRegistry:nil error:errorPtr];
}

- (instancetype)initWithData:(NSData *)data
           extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
                       error:(NSError **)errorPtr {
  if ((self = [self init])) {
    @try {
      [self mergeFromData:data extensionRegistry:extensionRegistry];
    }
    @catch (NSException *exception) {
      [self release];
      self = nil;
      if (errorPtr) {
        *errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
                                           exception.reason);
      }
    }
#ifdef DEBUG
    if (self && !self.initialized) {
      [self release];
      self = nil;
      if (errorPtr) {
        *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
      }
    }
#endif
  }
  return self;
}

- (instancetype)initWithCodedInputStream:(GPBCodedInputStream *)input
                       extensionRegistry:
                           (GPBExtensionRegistry *)extensionRegistry
                                   error:(NSError **)errorPtr {
  if ((self = [self init])) {
    @try {
      [self mergeFromCodedInputStream:input extensionRegistry:extensionRegistry];
    }
    @catch (NSException *exception) {
      [self release];
      self = nil;
      if (errorPtr) {
        *errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
                                           exception.reason);
      }
    }
#ifdef DEBUG
    if (self && !self.initialized) {
      [self release];
      self = nil;
      if (errorPtr) {
        *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
      }
    }
#endif
  }
  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;
            }
          }
        } else {
          if ((field.mapKeyType == GPBTypeString) &&
              GPBFieldTypeIsObject(field)) {
            GPBAutocreatedDictionary *autoDict = arrayOrMap;
            if (autoDict->_autocreator == self) {
              autoDict->_autocreator = nil;
            }
          } else {
            // Type doesn't matter, it is a GPB*Dictionary.
            GPBInt32Int32Dictionary *gpbDict = arrayOrMap;
            if (gpbDict->_autocreator == self) {
              gpbDict->_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,
                   @"%@: Single message field %@ not required or optional?",
                   [self class], field.name);
          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 {
#ifdef DEBUG
  if (!self.initialized) {
    return nil;
  }
#endif
  NSMutableData *data = [NSMutableData dataWithLength:[self serializedSize]];
  GPBCodedOutputStream *stream =
      [[GPBCodedOutputStream alloc] initWithData:data];
  @try {
    [self writeToCodedOutputStream:stream];
  }
  @catch (NSException *exception) {
    // This really shouldn't happen. The only way writeToCodedOutputStream:
    // could throw is if something in the library has a bug and the
    // serializedSize was wrong.
#ifdef DEBUG
    NSLog(@"%@: Internal exception while building message data: %@",
          [self class], exception);
#endif
    data = nil;
  }
  [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];
  @try {
    [self writeDelimitedToCodedOutputStream:stream];
  }
  @catch (NSException *exception) {
    // This really shouldn't happen.  The only way writeToCodedOutputStream:
    // could throw is if something in the library has a bug and the
    // serializedSize was wrong.
#ifdef DEBUG
    NSLog(@"%@: Internal exception while building message delimitedData: %@",
          [self class], exception);
#endif
    data = nil;
  }
  [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 error:(NSError **)errorPtr {
  return [self parseFromData:data extensionRegistry:nil error:errorPtr];
}

+ (instancetype)parseFromData:(NSData *)data
            extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
                        error:(NSError **)errorPtr {
  return [[[self alloc] initWithData:data
                   extensionRegistry:extensionRegistry
                               error:errorPtr] autorelease];
}

+ (instancetype)parseFromCodedInputStream:(GPBCodedInputStream *)input
                        extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
                                    error:(NSError **)errorPtr {
  return
      [[[self alloc] initWithCodedInputStream:input
                            extensionRegistry:extensionRegistry
                                        error:errorPtr] autorelease];
}

#pragma mark - Parse Delimited From Data Support

+ (instancetype)parseDelimitedFromCodedInputStream:(GPBCodedInputStream *)input
                                 extensionRegistry:
                                     (GPBExtensionRegistry *)extensionRegistry
                                             error:(NSError **)errorPtr {
  GPBMessage *message = [[[self alloc] init] autorelease];
  @try {
    [message mergeDelimitedFromCodedInputStream:input
                              extensionRegistry:extensionRegistry];
  }
  @catch (NSException *exception) {
    [message release];
    message = nil;
    if (errorPtr) {
      *errorPtr = MessageErrorWithReason(GPBMessageErrorCodeMalformedData,
                                         exception.reason);
    }
  }
#ifdef DEBUG
  if (message && !message.initialized) {
    [message release];
    message = nil;
    if (errorPtr) {
      *errorPtr = MessageError(GPBMessageErrorCodeMissingRequiredField, nil);
    }
  }
#endif
  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:@"%@: %@ can only be set to NO (to clear field).",
                               [obj class],
                               NSStringFromSelector(field->setHasSel_)];
          }
          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_) {
        if (field.fieldType == GPBFieldTypeRepeated) {
          context.impToAdd = imp_implementationWithBlock(^(id obj) {
            return GetArrayIvarWithField(obj, field);
          });
        } else {
          context.impToAdd = imp_implementationWithBlock(^(id obj) {
            return GetMapIvarWithField(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];
}

+ (BOOL)resolveClassMethod:(SEL)sel {
  // Extensions scoped to a Message and looked up via class methods.
  if (GPBResolveExtensionClassMethod(self, sel)) {
    return YES;
  }
  return [super resolveClassMethod:sel];
}

#pragma mark - NSCoding Support

+ (BOOL)supportsSecureCoding {
  return YES;
}

- (instancetype)initWithCoder:(NSCoder *)aDecoder {
  self = [self init];
  if (self) {
    NSData *data =
        [aDecoder decodeObjectOfClass:[NSData class] forKey:kGPBDataCoderKey];
    if (data.length) {
      [self mergeFromData:data extensionRegistry:nil];
    }
  }
  return self;
}

- (void)encodeWithCoder:(NSCoder *)aCoder {
  NSData *data = [self data];
  if (data.length) {
    [aCoder encodeObject:data forKey:kGPBDataCoderKey];
  }
}

#pragma mark - KVC Support

+ (BOOL)accessInstanceVariablesDirectly {
  // Make sure KVC doesn't use instance variables.
  return NO;
}

@end