third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/objectivec/GPBDictionary.m

 // 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.
@@ skipping 27 matching lines @@
 
 // ------------------------------ NOTE ------------------------------
 // At the moment, this is all using NSNumbers in NSDictionaries under
 // the hood, but it is all hidden so we can come back and optimize
 // with direct CFDictionary usage later.  The reason that wasn't
 // done yet is needing to support 32bit iOS builds.  Otherwise
 // it would be pretty simple to store all this data in CFDictionaries
 // directly.
 // ------------------------------------------------------------------
 
+// Direct access is use for speed, to avoid even internally declaring things
+// read/write, etc. The warning is enabled in the project to ensure code calling
+// protos can turn on -Wdirect-ivar-access without issues.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdirect-ivar-access"
+
 // Used to include code only visible to specific versions of the static
 // analyzer. Useful for wrapping code that only exists to silence the analyzer.
 // Determine the values you want to use for BEGIN_APPLE_BUILD_VERSION,
 // END_APPLE_BUILD_VERSION using:
 //   xcrun clang -dM -E -x c /dev/null | grep __apple_build_version__
 // Example usage:
 //  #if GPB_STATIC_ANALYZER_ONLY(5621, 5623) ... #endif
 #define GPB_STATIC_ANALYZER_ONLY(BEGIN_APPLE_BUILD_VERSION, END_APPLE_BUILD_VERSION) \
     (defined(__clang_analyzer__) && \
      (__apple_build_version__ >= BEGIN_APPLE_BUILD_VERSION && \
@@ skipping 419 matching lines @@
       }
     }
   }
 
   if (!hitError) {
     // Handle the special defaults and/or missing key/value.
     if ((keyDataType == GPBDataTypeString) && (key.valueString == nil)) {
       key.valueString = [@"" retain];
     }
     if (GPBDataTypeIsObject(valueDataType) && value.valueString == nil) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wswitch-enum"
       switch (valueDataType) {
         case GPBDataTypeString:
           value.valueString = [@"" retain];
           break;
         case GPBDataTypeBytes:
           value.valueData = [GPBEmptyNSData() retain];
           break;
 #if defined(__clang_analyzer__)
         case GPBDataTypeGroup:
           // Maps can't really have Groups as the value type, but this case is needed
           // so the analyzer won't report the posibility of send nil in for the value
           // in the NSMutableDictionary case below.
 #endif
         case GPBDataTypeMessage: {
           value.valueMessage = [[field.msgClass alloc] init];
           break;
         }
         default:
           // Nothing
           break;
       }
+#pragma clang diagnostic pop
     }
 
     if ((keyDataType == GPBDataTypeString) && GPBDataTypeIsObject(valueDataType)) {
 #if GPB_STATIC_ANALYZER_ONLY(6020053, 7000181)
      // Limited to Xcode 6.4 - 7.2, are known to fail here. The upper end can
      // be raised as needed for new Xcodes.
      //
      // This is only needed on a "shallow" analyze; on a "deep" analyze, the
      // existing code path gets this correct. In shallow, the analyzer decides
      // GPBDataTypeIsObject(valueDataType) is both false and true on a single
@@ skipping 43 matching lines @@
 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, UInt32, uint32_t, KHELPER)
 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Int32, int32_t, KHELPER)
 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, UInt64, uint64_t, KHELPER)
 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Int64, int64_t, KHELPER)
 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Bool, BOOL, KHELPER)
 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Float, float, KHELPER)
 //%DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, Double, double, KHELPER)
 //%DICTIONARY_KEY_TO_ENUM_IMPL(KEY_NAME, KEY_TYPE, KisP, Enum, int32_t, KHELPER)
 
 //%PDDM-DEFINE DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER)
-//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD, value)
+//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD, VALUE_NAME, value)
 
 //%PDDM-DEFINE DICTIONARY_POD_KEY_TO_OBJECT_IMPL(KEY_NAME, KEY_TYPE, VALUE_NAME, VALUE_TYPE)
-//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, , VALUE_NAME, VALUE_TYPE, POD, OBJECT, object)
+//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, , VALUE_NAME, VALUE_TYPE, POD, OBJECT, Object, object)
 
-//%PDDM-DEFINE DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME)
+//%PDDM-DEFINE DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR)
 //%#pragma mark - KEY_NAME -> VALUE_NAME
 //%
 //%@implementation GPB##KEY_NAME##VALUE_NAME##Dictionary {
 //% @package
 //%  NSMutableDictionary *_dictionary;
 //%}
 //%
 //%+ (instancetype)dictionary {
-//%  return [[[self alloc] initWith##VNAME$u##s:NULL forKeys:NULL count:0] autorelease];
+//%  return [[[self alloc] initWith##VNAME##s:NULL forKeys:NULL count:0] autorelease];
 //%}
 //%
-//%+ (instancetype)dictionaryWith##VNAME$u##:(VALUE_TYPE)##VNAME
+//%+ (instancetype)dictionaryWith##VNAME##:(VALUE_TYPE)##VNAME_VAR
 //%                      ##VNAME$S##  forKey:(KEY_TYPE##KisP$S##KisP)key {
-//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count:
+//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count:
 //%  // on to get the type correct.
-//%  return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:&##VNAME
+//%  return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:&##VNAME_VAR
 //%               KEY_NAME$S VALUE_NAME$S                        ##VNAME$S##  forKeys:&key
 //%               KEY_NAME$S VALUE_NAME$S                        ##VNAME$S##    count:1] autorelease];
 //%}
 //%
-//%+ (instancetype)dictionaryWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s
+//%+ (instancetype)dictionaryWith##VNAME##s:(const VALUE_TYPE [])##VNAME_VAR##s
 //%                      ##VNAME$S##  forKeys:(const KEY_TYPE##KisP$S##KisP [])keys
 //%                      ##VNAME$S##    count:(NSUInteger)count {
-//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count:
+//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count:
 //%  // on to get the type correct.
-//%  return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:##VNAME##s
+//%  return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:##VNAME_VAR##s
 //%               KEY_NAME$S VALUE_NAME$S                               forKeys:keys
 //%               KEY_NAME$S VALUE_NAME$S                                 count:count] autorelease];
 //%}
 //%
 //%+ (instancetype)dictionaryWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary {
 //%  // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
 //%  // on to get the type correct.
 //%  return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 //%}
 //%
 //%+ (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
 //%  return [[[self alloc] initWithCapacity:numItems] autorelease];
 //%}
 //%
 //%- (instancetype)init {
-//%  return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0];
+//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
 //%}
 //%
-//%- (instancetype)initWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s
+//%- (instancetype)initWith##VNAME##s:(const VALUE_TYPE [])##VNAME_VAR##s
 //%                ##VNAME$S##  forKeys:(const KEY_TYPE##KisP$S##KisP [])keys
 //%                ##VNAME$S##    count:(NSUInteger)count {
 //%  self = [super init];
 //%  if (self) {
 //%    _dictionary = [[NSMutableDictionary alloc] init];
-//%    if (count && VNAME##s && keys) {
+//%    if (count && VNAME_VAR##s && keys) {
 //%      for (NSUInteger i = 0; i < count; ++i) {
-//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME##s[i], ______)##DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______)        [_dictionary setObject:WRAPPED##VHELPER(VNAME##s[i]) forKey:WRAPPED##KHELPER(keys[i])];
+//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME_VAR##s[i], ______)##DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______)        [_dictionary setObject:WRAPPED##VHELPER(VNAME_VAR##s[i]) forKey:WRAPPED##KHELPER(keys[i])];
 //%      }
 //%    }
 //%  }
 //%  return self;
 //%}
 //%
 //%- (instancetype)initWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary {
-//%  self = [self initWith##VNAME$u##s:NULL forKeys:NULL count:0];
+//%  self = [self initWith##VNAME##s:NULL forKeys:NULL count:0];
 //%  if (self) {
 //%    if (dictionary) {
 //%      [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
 //%    }
 //%  }
 //%  return self;
 //%}
 //%
 //%- (instancetype)initWithCapacity:(NSUInteger)numItems {
 //%  #pragma unused(numItems)
-//%  return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0];
+//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
 //%}
 //%
-//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, )
+//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, )
 //%
 //%VALUE_FOR_KEY_##VHELPER(KEY_TYPE##KisP$S##KisP, VALUE_NAME, VALUE_TYPE, KHELPER)
 //%
-//%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, )
+//%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, )
 //%
 //%@end
 //%
 
 //%PDDM-DEFINE DICTIONARY_KEY_TO_ENUM_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER)
 //%DICTIONARY_KEY_TO_ENUM_IMPL2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD)
 //%PDDM-DEFINE DICTIONARY_KEY_TO_ENUM_IMPL2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER)
 //%#pragma mark - KEY_NAME -> VALUE_NAME
 //%
 //%@implementation GPB##KEY_NAME##VALUE_NAME##Dictionary {
@@ skipping 89 matching lines @@
 //%  }
 //%  return self;
 //%}
 //%
 //%- (instancetype)initWithValidationFunction:(GPBEnumValidationFunc)func
 //%                                  capacity:(NSUInteger)numItems {
 //%  #pragma unused(numItems)
 //%  return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0];
 //%}
 //%
-//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, value, Raw)
+//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, Value, value, Raw)
 //%
-//%- (BOOL)valueForKey:(KEY_TYPE##KisP$S##KisP)key value:(VALUE_TYPE *)value {
+//%- (BOOL)getEnum:(VALUE_TYPE *)value forKey:(KEY_TYPE##KisP$S##KisP)key {
 //%  NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)];
 //%  if (wrapped && value) {
 //%    VALUE_TYPE result = UNWRAP##VALUE_NAME(wrapped);
 //%    if (!_validationFunc(result)) {
 //%      result = kGPBUnrecognizedEnumeratorValue;
 //%    }
 //%    *value = result;
 //%  }
 //%  return (wrapped != NULL);
 //%}
 //%
-//%- (BOOL)valueForKey:(KEY_TYPE##KisP$S##KisP)key rawValue:(VALUE_TYPE *)rawValue {
+//%- (BOOL)getRawValue:(VALUE_TYPE *)rawValue forKey:(KEY_TYPE##KisP$S##KisP)key {
 //%  NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)];
 //%  if (wrapped && rawValue) {
 //%    *rawValue = UNWRAP##VALUE_NAME(wrapped);
 //%  }
 //%  return (wrapped != NULL);
 //%}
 //%
-//%- (void)enumerateKeysAndValuesUsingBlock:
+//%- (void)enumerateKeysAndEnumsUsingBlock:
 //%    (void (^)(KEY_TYPE KisP##key, VALUE_TYPE value, BOOL *stop))block {
 //%  GPBEnumValidationFunc func = _validationFunc;
 //%  [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey,
 //%                                                   ENUM_TYPE##VHELPER(VALUE_TYPE)##aValue,
 //%                                                   BOOL *stop) {
 //%      VALUE_TYPE unwrapped = UNWRAP##VALUE_NAME(aValue);
 //%      if (!func(unwrapped)) {
 //%        unwrapped = kGPBUnrecognizedEnumeratorValue;
 //%      }
 //%      block(UNWRAP##KEY_NAME(aKey), unwrapped, stop);
 //%  }];
 //%}
 //%
-//%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, value, Raw)
+//%DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, Value, Enum, value, Raw)
 //%
-//%- (void)setValue:(VALUE_TYPE)value forKey:(KEY_TYPE##KisP$S##KisP)key {
+//%- (void)setEnum:(VALUE_TYPE)value forKey:(KEY_TYPE##KisP$S##KisP)key {
 //%DICTIONARY_VALIDATE_KEY_##KHELPER(key, )  if (!_validationFunc(value)) {
 //%    [NSException raise:NSInvalidArgumentException
 //%                format:@"GPB##KEY_NAME##VALUE_NAME##Dictionary: Attempt to set an unknown enum value (%d)",
 //%                       value];
 //%  }
 //%
 //%  [_dictionary setObject:WRAPPED##VHELPER(value) forKey:WRAPPED##KHELPER(key)];
 //%  if (_autocreator) {
 //%    GPBAutocreatedDictionaryModified(_autocreator, self);
 //%  }
 //%}
 //%
 //%@end
 //%
 
-//%PDDM-DEFINE DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ACCESSOR_NAME)
+//%PDDM-DEFINE DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ACCESSOR_NAME)
 //%- (void)dealloc {
 //%  NSAssert(!_autocreator,
 //%           @"%@: Autocreator must be cleared before release, autocreator: %@",
 //%           [self class], _autocreator);
 //%  [_dictionary release];
 //%  [super dealloc];
 //%}
 //%
 //%- (instancetype)copyWithZone:(NSZone *)zone {
 //%  return [[GPB##KEY_NAME##VALUE_NAME##Dictionary allocWithZone:zone] initWithDictionary:self];
 //%}
 //%
-//%- (BOOL)isEqual:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)other {
+//%- (BOOL)isEqual:(id)other {
 //%  if (self == other) {
 //%    return YES;
 //%  }
 //%  if (![other isKindOfClass:[GPB##KEY_NAME##VALUE_NAME##Dictionary class]]) {
 //%    return NO;
 //%  }
-//%  return [_dictionary isEqual:other->_dictionary];
+//%  GPB##KEY_NAME##VALUE_NAME##Dictionary *otherDictionary = other;
+//%  return [_dictionary isEqual:otherDictionary->_dictionary];
 //%}
 //%
 //%- (NSUInteger)hash {
 //%  return _dictionary.count;
 //%}
 //%
 //%- (NSString *)description {
 //%  return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 //%}
 //%
 //%- (NSUInteger)count {
 //%  return _dictionary.count;
 //%}
 //%
-//%- (void)enumerateKeysAnd##ACCESSOR_NAME##VNAME$u##sUsingBlock:
-//%    (void (^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME, BOOL *stop))block {
+//%- (void)enumerateKeysAnd##ACCESSOR_NAME##VNAME##sUsingBlock:
+//%    (void (^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME_VAR, BOOL *stop))block {
 //%  [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey,
-//%                                                   ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u,
+//%                                                   ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u,
 //%                                                   BOOL *stop) {
-//%      block(UNWRAP##KEY_NAME(aKey), UNWRAP##VALUE_NAME(a##VNAME$u), stop);
+//%      block(UNWRAP##KEY_NAME(aKey), UNWRAP##VALUE_NAME(a##VNAME_VAR$u), stop);
 //%  }];
 //%}
 //%
 //%EXTRA_METHODS_##VHELPER(KEY_NAME, VALUE_NAME)- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
 //%  NSUInteger count = _dictionary.count;
 //%  if (count == 0) {
 //%    return 0;
 //%  }
 //%
 //%  GPBDataType valueDataType = GPBGetFieldDataType(field);
 //%  GPBDataType keyDataType = field.mapKeyDataType;
 //%  __block size_t result = 0;
 //%  [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey,
-//%                                                   ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u##,
+//%                                                   ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u##,
 //%                                                   BOOL *stop) {
 //%    #pragma unused(stop)
 //%    size_t msgSize = ComputeDict##KEY_NAME##FieldSize(UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType);
-//%    msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType);
+//%    msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME_VAR$u), kMapValueFieldNumber, valueDataType);
 //%    result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize;
 //%  }];
 //%  size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage);
 //%  result += tagSize * count;
 //%  return result;
 //%}
 //%
 //%- (void)writeToCodedOutputStream:(GPBCodedOutputStream *)outputStream
 //%                         asField:(GPBFieldDescriptor *)field {
 //%  GPBDataType valueDataType = GPBGetFieldDataType(field);
 //%  GPBDataType keyDataType = field.mapKeyDataType;
 //%  uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited);
 //%  [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey,
-//%                                                   ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u,
+//%                                                   ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u,
 //%                                                   BOOL *stop) {
 //%    #pragma unused(stop)
 //%    // Write the tag.
 //%    [outputStream writeInt32NoTag:tag];
 //%    // Write the size of the message.
 //%    size_t msgSize = ComputeDict##KEY_NAME##FieldSize(UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType);
-//%    msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType);
+//%    msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME_VAR$u), kMapValueFieldNumber, valueDataType);
 //%    [outputStream writeInt32NoTag:(int32_t)msgSize];
 //%    // Write the fields.
 //%    WriteDict##KEY_NAME##Field(outputStream, UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType);
-//%    WriteDict##VALUE_NAME##Field(outputStream, UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType);
+//%    WriteDict##VALUE_NAME##Field(outputStream, UNWRAP##VALUE_NAME(a##VNAME_VAR$u), kMapValueFieldNumber, valueDataType);
 //%  }];
 //%}
 //%
 //%SERIAL_DATA_FOR_ENTRY_##VHELPER(KEY_NAME, VALUE_NAME)- (void)setGPBGenericValue:(GPBGenericValue *)value
 //%     forGPBGenericValueKey:(GPBGenericValue *)key {
 //%  [_dictionary setObject:WRAPPED##VHELPER(value->##GPBVALUE_##VHELPER(VALUE_NAME)##) forKey:WRAPPED##KHELPER(key->value##KEY_NAME)];
 //%}
 //%
 //%- (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-//%  [self enumerateKeysAnd##ACCESSOR_NAME##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##key, VALUE_TYPE VNAME, BOOL *stop) {
+//%  [self enumerateKeysAnd##ACCESSOR_NAME##VNAME##sUsingBlock:^(KEY_TYPE KisP##key, VALUE_TYPE VNAME_VAR, BOOL *stop) {
 //%      #pragma unused(stop)
-//%      block(TEXT_FORMAT_OBJ##KEY_NAME(key), TEXT_FORMAT_OBJ##VALUE_NAME(VNAME));
+//%      block(TEXT_FORMAT_OBJ##KEY_NAME(key), TEXT_FORMAT_OBJ##VALUE_NAME(VNAME_VAR));
 //%  }];
 //%}
-//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ACCESSOR_NAME)
+//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ACCESSOR_NAME)
+//%DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME, VNAME_VAR, ACCESSOR_NAME)
+//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_REMOVE, VNAME_VAR, ACCESSOR_NAME)
 //%- (void)add##ACCESSOR_NAME##EntriesFromDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)otherDictionary {
 //%  if (otherDictionary) {
 //%    [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
 //%    if (_autocreator) {
 //%      GPBAutocreatedDictionaryModified(_autocreator, self);
 //%    }
 //%  }
 //%}
 //%
-//%- (void)set##ACCESSOR_NAME##VNAME$u##:(VALUE_TYPE)VNAME forKey:(KEY_TYPE##KisP$S##KisP)key {
-//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME, )##DICTIONARY_VALIDATE_KEY_##KHELPER(key, )  [_dictionary setObject:WRAPPED##VHELPER(VNAME) forKey:WRAPPED##KHELPER(key)];
+//%- (void)set##ACCESSOR_NAME##VNAME##:(VALUE_TYPE)VNAME_VAR forKey:(KEY_TYPE##KisP$S##KisP)key {
+//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME_VAR, )##DICTIONARY_VALIDATE_KEY_##KHELPER(key, )  [_dictionary setObject:WRAPPED##VHELPER(VNAME_VAR) forKey:WRAPPED##KHELPER(key)];
 //%  if (_autocreator) {
 //%    GPBAutocreatedDictionaryModified(_autocreator, self);
 //%  }
 //%}
 //%
-//%- (void)remove##VNAME$u##ForKey:(KEY_TYPE##KisP$S##KisP)aKey {
+//%- (void)remove##VNAME_REMOVE##ForKey:(KEY_TYPE##KisP$S##KisP)aKey {
 //%  [_dictionary removeObjectForKey:WRAPPED##KHELPER(aKey)];
 //%}
 //%
 //%- (void)removeAll {
 //%  [_dictionary removeAllObjects];
 //%}
 
 //
 // Custom Generation for Bool keys
 //
 
 //%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_POD_IMPL(VALUE_NAME, VALUE_TYPE)
-//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, POD, value)
+//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, POD, VALUE_NAME, value)
 //%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_OBJECT_IMPL(VALUE_NAME, VALUE_TYPE)
-//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, OBJECT, object)
+//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, OBJECT, Object, object)
 
-//%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, HELPER, VNAME)
+//%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, HELPER, VNAME, VNAME_VAR)
 //%#pragma mark - Bool -> VALUE_NAME
 //%
 //%@implementation GPBBool##VALUE_NAME##Dictionary {
 //% @package
 //%  VALUE_TYPE _values[2];
 //%BOOL_DICT_HAS_STORAGE_##HELPER()}
 //%
 //%+ (instancetype)dictionary {
-//%  return [[[self alloc] initWith##VNAME$u##s:NULL forKeys:NULL count:0] autorelease];
+//%  return [[[self alloc] initWith##VNAME##s:NULL forKeys:NULL count:0] autorelease];
 //%}
 //%
-//%+ (instancetype)dictionaryWith##VNAME$u##:(VALUE_TYPE)VNAME
+//%+ (instancetype)dictionaryWith##VNAME##:(VALUE_TYPE)VNAME_VAR
 //%                      ##VNAME$S##  forKey:(BOOL)key {
-//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count:
+//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count:
 //%  // on to get the type correct.
-//%  return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:&##VNAME
+//%  return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:&##VNAME_VAR
 //%                    VALUE_NAME$S                        ##VNAME$S##  forKeys:&key
 //%                    VALUE_NAME$S                        ##VNAME$S##    count:1] autorelease];
 //%}
 //%
-//%+ (instancetype)dictionaryWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s
+//%+ (instancetype)dictionaryWith##VNAME##s:(const VALUE_TYPE [])##VNAME_VAR##s
 //%                      ##VNAME$S##  forKeys:(const BOOL [])keys
 //%                      ##VNAME$S##    count:(NSUInteger)count {
-//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count:
+//%  // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count:
 //%  // on to get the type correct.
-//%  return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:##VNAME##s
+//%  return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:##VNAME_VAR##s
 //%                    VALUE_NAME$S                        ##VNAME$S##  forKeys:keys
 //%                    VALUE_NAME$S                        ##VNAME$S##    count:count] autorelease];
 //%}
 //%
 //%+ (instancetype)dictionaryWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary {
 //%  // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
 //%  // on to get the type correct.
 //%  return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 //%}
 //%
 //%+ (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
 //%  return [[[self alloc] initWithCapacity:numItems] autorelease];
 //%}
 //%
 //%- (instancetype)init {
-//%  return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0];
+//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
 //%}
 //%
 //%BOOL_DICT_INITS_##HELPER(VALUE_NAME, VALUE_TYPE)
 //%
 //%- (instancetype)initWithCapacity:(NSUInteger)numItems {
 //%  #pragma unused(numItems)
-//%  return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0];
+//%  return [self initWith##VNAME##s:NULL forKeys:NULL count:0];
 //%}
 //%
 //%BOOL_DICT_DEALLOC##HELPER()
 //%
 //%- (instancetype)copyWithZone:(NSZone *)zone {
 //%  return [[GPBBool##VALUE_NAME##Dictionary allocWithZone:zone] initWithDictionary:self];
 //%}
 //%
-//%- (BOOL)isEqual:(GPBBool##VALUE_NAME##Dictionary *)other {
+//%- (BOOL)isEqual:(id)other {
 //%  if (self == other) {
 //%    return YES;
 //%  }
 //%  if (![other isKindOfClass:[GPBBool##VALUE_NAME##Dictionary class]]) {
 //%    return NO;
 //%  }
-//%  if ((BOOL_DICT_W_HAS##HELPER(0, ) != BOOL_DICT_W_HAS##HELPER(0, other->)) ||
-//%      (BOOL_DICT_W_HAS##HELPER(1, ) != BOOL_DICT_W_HAS##HELPER(1, other->))) {
+//%  GPBBool##VALUE_NAME##Dictionary *otherDictionary = other;
+//%  if ((BOOL_DICT_W_HAS##HELPER(0, ) != BOOL_DICT_W_HAS##HELPER(0, otherDictionary->)) ||
+//%      (BOOL_DICT_W_HAS##HELPER(1, ) != BOOL_DICT_W_HAS##HELPER(1, otherDictionary->))) {
 //%    return NO;
 //%  }
-//%  if ((BOOL_DICT_W_HAS##HELPER(0, ) && (NEQ_##HELPER(_values[0], other->_values[0]))) ||
-//%      (BOOL_DICT_W_HAS##HELPER(1, ) && (NEQ_##HELPER(_values[1], other->_values[1])))) {
+//%  if ((BOOL_DICT_W_HAS##HELPER(0, ) && (NEQ_##HELPER(_values[0], otherDictionary->_values[0]))) ||
+//%      (BOOL_DICT_W_HAS##HELPER(1, ) && (NEQ_##HELPER(_values[1], otherDictionary->_values[1])))) {
 //%    return NO;
 //%  }
 //%  return YES;
 //%}
 //%
 //%- (NSUInteger)hash {
 //%  return (BOOL_DICT_W_HAS##HELPER(0, ) ? 1 : 0) + (BOOL_DICT_W_HAS##HELPER(1, ) ? 1 : 0);
 //%}
 //%
 //%- (NSString *)description {
 //%  NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
 //%  if (BOOL_DICT_W_HAS##HELPER(0, )) {
 //%    [result appendFormat:@"NO: STR_FORMAT_##HELPER(VALUE_NAME)", _values[0]];
 //%  }
 //%  if (BOOL_DICT_W_HAS##HELPER(1, )) {
 //%    [result appendFormat:@"YES: STR_FORMAT_##HELPER(VALUE_NAME)", _values[1]];
 //%  }
 //%  [result appendString:@" }"];
 //%  return result;
 //%}
 //%
 //%- (NSUInteger)count {
 //%  return (BOOL_DICT_W_HAS##HELPER(0, ) ? 1 : 0) + (BOOL_DICT_W_HAS##HELPER(1, ) ? 1 : 0);
 //%}
 //%
-//%BOOL_VALUE_FOR_KEY_##HELPER(VALUE_TYPE)
+//%BOOL_VALUE_FOR_KEY_##HELPER(VALUE_NAME, VALUE_TYPE)
 //%
 //%BOOL_SET_GPBVALUE_FOR_KEY_##HELPER(VALUE_NAME, VALUE_TYPE, VisP)
 //%
 //%- (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
 //%  if (BOOL_DICT_HAS##HELPER(0, )) {
 //%    block(@"false", TEXT_FORMAT_OBJ##VALUE_NAME(_values[0]));
 //%  }
 //%  if (BOOL_DICT_W_HAS##HELPER(1, )) {
 //%    block(@"true", TEXT_FORMAT_OBJ##VALUE_NAME(_values[1]));
 //%  }
 //%}
 //%
-//%- (void)enumerateKeysAnd##VNAME$u##sUsingBlock:
-//%    (void (^)(BOOL key, VALUE_TYPE VNAME, BOOL *stop))block {
+//%- (void)enumerateKeysAnd##VNAME##sUsingBlock:
+//%    (void (^)(BOOL key, VALUE_TYPE VNAME_VAR, BOOL *stop))block {
 //%  BOOL stop = NO;
 //%  if (BOOL_DICT_HAS##HELPER(0, )) {
 //%    block(NO, _values[0], &stop);
 //%  }
 //%  if (!stop && BOOL_DICT_W_HAS##HELPER(1, )) {
 //%    block(YES, _values[1], &stop);
 //%  }
 //%}
 //%
 //%BOOL_EXTRA_METHODS_##HELPER(Bool, VALUE_NAME)- (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
@@ skipping 36 matching lines @@
 //%
 //%@end
 //%
 
 
 //
 // Helpers for PODs
 //
 
 //%PDDM-DEFINE VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_NAME, VALUE_TYPE, KHELPER)
-//%- (BOOL)valueForKey:(KEY_TYPE)key value:(VALUE_TYPE *)value {
+//%- (BOOL)get##VALUE_NAME##:(nullable VALUE_TYPE *)value forKey:(KEY_TYPE)key {
 //%  NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)];
 //%  if (wrapped && value) {
 //%    *value = UNWRAP##VALUE_NAME(wrapped);
 //%  }
 //%  return (wrapped != NULL);
 //%}
 //%PDDM-DEFINE WRAPPEDPOD(VALUE)
 //%@(VALUE)
 //%PDDM-DEFINE UNWRAPUInt32(VALUE)
 //%[VALUE unsignedIntValue]
@@ skipping 69 matching lines @@
 //%value##VALUE_NAME
 //%PDDM-DEFINE DICTIONARY_VALIDATE_VALUE_POD(VALUE_NAME, EXTRA_INDENT)
 // Empty
 //%PDDM-DEFINE DICTIONARY_VALIDATE_KEY_POD(KEY_NAME, EXTRA_INDENT)
 // Empty
 
 //%PDDM-DEFINE BOOL_DICT_HAS_STORAGE_POD()
 //%  BOOL _valueSet[2];
 //%
 //%PDDM-DEFINE BOOL_DICT_INITS_POD(VALUE_NAME, VALUE_TYPE)
-//%- (instancetype)initWithValues:(const VALUE_TYPE [])values
-//%                       forKeys:(const BOOL [])keys
-//%                         count:(NSUInteger)count {
+//%- (instancetype)initWith##VALUE_NAME##s:(const VALUE_TYPE [])values
+//%                 ##VALUE_NAME$S## forKeys:(const BOOL [])keys
+//%                 ##VALUE_NAME$S##   count:(NSUInteger)count {
 //%  self = [super init];
 //%  if (self) {
 //%    for (NSUInteger i = 0; i < count; ++i) {
 //%      int idx = keys[i] ? 1 : 0;
 //%      _values[idx] = values[i];
 //%      _valueSet[idx] = YES;
 //%    }
 //%  }
 //%  return self;
 //%}
 //%
 //%- (instancetype)initWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary {
-//%  self = [self initWithValues:NULL forKeys:NULL count:0];
+//%  self = [self initWith##VALUE_NAME##s:NULL forKeys:NULL count:0];
 //%  if (self) {
 //%    if (dictionary) {
 //%      for (int i = 0; i < 2; ++i) {
 //%        if (dictionary->_valueSet[i]) {
 //%          _values[i] = dictionary->_values[i];
 //%          _valueSet[i] = YES;
 //%        }
 //%      }
 //%    }
 //%  }
 //%  return self;
 //%}
 //%PDDM-DEFINE BOOL_DICT_DEALLOCPOD()
 //%#if !defined(NS_BLOCK_ASSERTIONS)
 //%- (void)dealloc {
 //%  NSAssert(!_autocreator,
 //%           @"%@: Autocreator must be cleared before release, autocreator: %@",
 //%           [self class], _autocreator);
 //%  [super dealloc];
 //%}
 //%#endif  // !defined(NS_BLOCK_ASSERTIONS)
 //%PDDM-DEFINE BOOL_DICT_W_HASPOD(IDX, REF)
 //%BOOL_DICT_HASPOD(IDX, REF)
 //%PDDM-DEFINE BOOL_DICT_HASPOD(IDX, REF)
 //%REF##_valueSet[IDX]
-//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_POD(VALUE_TYPE)
-//%- (BOOL)valueForKey:(BOOL)key value:(VALUE_TYPE *)value {
+//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_POD(VALUE_NAME, VALUE_TYPE)
+//%- (BOOL)get##VALUE_NAME##:(VALUE_TYPE *)value forKey:(BOOL)key {
 //%  int idx = (key ? 1 : 0);
 //%  if (_valueSet[idx]) {
 //%    if (value) {
 //%      *value = _values[idx];
 //%    }
 //%    return YES;
 //%  }
 //%  return NO;
 //%}
 //%PDDM-DEFINE BOOL_SET_GPBVALUE_FOR_KEY_POD(VALUE_NAME, VALUE_TYPE, VisP)
@@ skipping 11 matching lines @@
 //%        _valueSet[i] = YES;
 //%        _values[i] = otherDictionary->_values[i];
 //%      }
 //%    }
 //%    if (_autocreator) {
 //%      GPBAutocreatedDictionaryModified(_autocreator, self);
 //%    }
 //%  }
 //%}
 //%
-//%- (void)setValue:(VALUE_TYPE)value forKey:(BOOL)key {
+//%- (void)set##VALUE_NAME:(VALUE_TYPE)value forKey:(BOOL)key {
 //%  int idx = (key ? 1 : 0);
 //%  _values[idx] = value;
 //%  _valueSet[idx] = YES;
 //%  if (_autocreator) {
 //%    GPBAutocreatedDictionaryModified(_autocreator, self);
 //%  }
 //%}
 //%
-//%- (void)removeValueForKey:(BOOL)aKey {
+//%- (void)remove##VALUE_NAME##ForKey:(BOOL)aKey {
 //%  _valueSet[aKey ? 1 : 0] = NO;
 //%}
 //%
 //%- (void)removeAll {
 //%  _valueSet[0] = NO;
 //%  _valueSet[1] = NO;
 //%}
 //%PDDM-DEFINE STR_FORMAT_POD(VALUE_NAME)
 //%STR_FORMAT_##VALUE_NAME()
 //%PDDM-DEFINE STR_FORMAT_UInt32()
@@ skipping 140 matching lines @@
 //%           @"%@: Autocreator must be cleared before release, autocreator: %@",
 //%           [self class], _autocreator);
 //%  [_values[0] release];
 //%  [_values[1] release];
 //%  [super dealloc];
 //%}
 //%PDDM-DEFINE BOOL_DICT_W_HASOBJECT(IDX, REF)
 //%(BOOL_DICT_HASOBJECT(IDX, REF))
 //%PDDM-DEFINE BOOL_DICT_HASOBJECT(IDX, REF)
 //%REF##_values[IDX] != nil
-//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_OBJECT(VALUE_TYPE)
+//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_OBJECT(VALUE_NAME, VALUE_TYPE)
 //%- (VALUE_TYPE)objectForKey:(BOOL)key {
 //%  return _values[key ? 1 : 0];
 //%}
 //%PDDM-DEFINE BOOL_SET_GPBVALUE_FOR_KEY_OBJECT(VALUE_NAME, VALUE_TYPE, VisP)
 //%- (void)setGPBGenericValue:(GPBGenericValue *)value
 //%     forGPBGenericValueKey:(GPBGenericValue *)key {
 //%  int idx = (key->valueBool ? 1 : 0);
 //%  [_values[idx] release];
 //%  _values[idx] = [value->valueString retain];
 //%}
@@ skipping 46 matching lines @@
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - UInt32 -> UInt32
 
 @implementation GPBUInt32UInt32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint32_t)value
-                             forKey:(uint32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32:(uint32_t)value
+                              forKey:(uint32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithUInt32s:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint32_t [])values
-                             forKeys:(const uint32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values
+                              forKeys:(const uint32_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithUInt32s:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint32_t [])values
-                       forKeys:(const uint32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt32s:(const uint32_t [])values
+                        forKeys:(const uint32_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32UInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32UInt32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32UInt32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt32sUsingBlock:
     (void (^)(uint32_t key, uint32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedIntValue], [aValue unsignedIntValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, uint32_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt32sUsingBlock:^(uint32_t key, uint32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%u", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(uint32_t *)value {
+- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedIntValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt32UInt32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint32_t)value forKey:(uint32_t)key {
+- (void)setUInt32:(uint32_t)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeUInt32ForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt32 -> Int32
 
 @implementation GPBUInt32Int32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int32_t)value
++ (instancetype)dictionaryWithInt32:(int32_t)value
                              forKey:(uint32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithInt32s:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int32_t [])values
++ (instancetype)dictionaryWithInt32s:(const int32_t [])values
                              forKeys:(const uint32_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithInt32s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt32Int32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int32_t [])values
+- (instancetype)initWithInt32s:(const int32_t [])values
                        forKeys:(const uint32_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt32Int32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32Int32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32Int32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32Int32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32Int32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt32sUsingBlock:
     (void (^)(uint32_t key, int32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedIntValue], [aValue intValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, int32_t value, BOOL *stop) {
+  [self enumerateKeysAndInt32sUsingBlock:^(uint32_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%d", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(int32_t *)value {
+- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt32Int32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int32_t)value forKey:(uint32_t)key {
+- (void)setInt32:(int32_t)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeInt32ForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt32 -> UInt64
 
 @implementation GPBUInt32UInt64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint64_t)value
-                             forKey:(uint32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64:(uint64_t)value
+                              forKey:(uint32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithUInt64s:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint64_t [])values
-                             forKeys:(const uint32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values
+                              forKeys:(const uint32_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithUInt64s:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint64_t [])values
-                       forKeys:(const uint32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt64s:(const uint64_t [])values
+                        forKeys:(const uint32_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32UInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32UInt64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32UInt64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt64sUsingBlock:
     (void (^)(uint32_t key, uint64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedIntValue], [aValue unsignedLongLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, uint64_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt64sUsingBlock:^(uint32_t key, uint64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%llu", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(uint64_t *)value {
+- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedLongLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt32UInt64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint64_t)value forKey:(uint32_t)key {
+- (void)setUInt64:(uint64_t)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeUInt64ForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt32 -> Int64
 
 @implementation GPBUInt32Int64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int64_t)value
++ (instancetype)dictionaryWithInt64:(int64_t)value
                              forKey:(uint32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithInt64s:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int64_t [])values
++ (instancetype)dictionaryWithInt64s:(const int64_t [])values
                              forKeys:(const uint32_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithInt64s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt32Int64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int64_t [])values
+- (instancetype)initWithInt64s:(const int64_t [])values
                        forKeys:(const uint32_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt32Int64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32Int64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32Int64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32Int64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32Int64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt64sUsingBlock:
     (void (^)(uint32_t key, int64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedIntValue], [aValue longLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, int64_t value, BOOL *stop) {
+  [self enumerateKeysAndInt64sUsingBlock:^(uint32_t key, int64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%lld", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(int64_t *)value {
+- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped longLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt32Int64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int64_t)value forKey:(uint32_t)key {
+- (void)setInt64:(int64_t)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeInt64ForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt32 -> Bool
 
 @implementation GPBUInt32BoolDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(BOOL)value
-                             forKey:(uint32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBool:(BOOL)value
+                            forKey:(uint32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32BoolDictionary*)[self alloc] initWithValues:&value
-                                                         forKeys:&key
-                                                           count:1] autorelease];
+  return [[(GPBUInt32BoolDictionary*)[self alloc] initWithBools:&value
+                                                        forKeys:&key
+                                                          count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const BOOL [])values
-                             forKeys:(const uint32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBools:(const BOOL [])values
+                            forKeys:(const uint32_t [])keys
+                              count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32BoolDictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt32BoolDictionary*)[self alloc] initWithBools:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt32BoolDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt32BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const BOOL [])values
-                       forKeys:(const uint32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithBools:(const BOOL [])values
+                      forKeys:(const uint32_t [])keys
+                        count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt32BoolDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithBools:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32BoolDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32BoolDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32BoolDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32BoolDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndBoolsUsingBlock:
     (void (^)(uint32_t key, BOOL value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedIntValue], [aValue boolValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueBool) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, BOOL value, BOOL *stop) {
+  [self enumerateKeysAndBoolsUsingBlock:^(uint32_t key, BOOL value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], (value ? @"true" : @"false"));
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(BOOL *)value {
+- (BOOL)getBool:(nullable BOOL *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped boolValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt32BoolDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(BOOL)value forKey:(uint32_t)key {
+- (void)setBool:(BOOL)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeBoolForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt32 -> Float
 
 @implementation GPBUInt32FloatDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(float)value
++ (instancetype)dictionaryWithFloat:(float)value
                              forKey:(uint32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32FloatDictionary*)[self alloc] initWithValues:&value
+  return [[(GPBUInt32FloatDictionary*)[self alloc] initWithFloats:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const float [])values
++ (instancetype)dictionaryWithFloats:(const float [])values
                              forKeys:(const uint32_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32FloatDictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt32FloatDictionary*)[self alloc] initWithFloats:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt32FloatDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt32FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const float [])values
+- (instancetype)initWithFloats:(const float [])values
                        forKeys:(const uint32_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt32FloatDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithFloats:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32FloatDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32FloatDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32FloatDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32FloatDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndFloatsUsingBlock:
     (void (^)(uint32_t key, float value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedIntValue], [aValue floatValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, float value, BOOL *stop) {
+  [self enumerateKeysAndFloatsUsingBlock:^(uint32_t key, float value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(float *)value {
+- (BOOL)getFloat:(nullable float *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped floatValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt32FloatDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(float)value forKey:(uint32_t)key {
+- (void)setFloat:(float)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeFloatForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt32 -> Double
 
 @implementation GPBUInt32DoubleDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(double)value
-                             forKey:(uint32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDouble:(double)value
+                              forKey:(uint32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithDoubles:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const double [])values
-                             forKeys:(const uint32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDoubles:(const double [])values
+                              forKeys:(const uint32_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithDoubles:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt32DoubleDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const double [])values
-                       forKeys:(const uint32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithDoubles:(const double [])values
+                        forKeys:(const uint32_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt32DoubleDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithDoubles:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32DoubleDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32DoubleDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32DoubleDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32DoubleDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndDoublesUsingBlock:
     (void (^)(uint32_t key, double value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedIntValue], [aValue doubleValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, double value, BOOL *stop) {
+  [self enumerateKeysAndDoublesUsingBlock:^(uint32_t key, double value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(double *)value {
+- (BOOL)getDouble:(nullable double *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped doubleValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt32DoubleDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(double)value forKey:(uint32_t)key {
+- (void)setDouble:(double)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeDoubleForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt32 -> Enum
@@ skipping 103 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32EnumDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32EnumDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32EnumDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32EnumDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 70 matching lines @@
   [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueUInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   [self enumerateKeysAndRawValuesUsingBlock:^(uint32_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%u", key], @(value));
   }];
 }
 
-- (BOOL)valueForKey:(uint32_t)key value:(int32_t *)value {
+- (BOOL)getEnum:(int32_t *)value forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     int32_t result = [wrapped intValue];
     if (!_validationFunc(result)) {
       result = kGPBUnrecognizedEnumeratorValue;
     }
     *value = result;
   }
   return (wrapped != NULL);
 }
 
-- (BOOL)valueForKey:(uint32_t)key rawValue:(int32_t *)rawValue {
+- (BOOL)getRawValue:(int32_t *)rawValue forKey:(uint32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && rawValue) {
     *rawValue = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndEnumsUsingBlock:
     (void (^)(uint32_t key, int32_t value, BOOL *stop))block {
   GPBEnumValidationFunc func = _validationFunc;
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       int32_t unwrapped = [aValue intValue];
       if (!func(unwrapped)) {
         unwrapped = kGPBUnrecognizedEnumeratorValue;
       }
       block([aKey unsignedIntValue], unwrapped, stop);
   }];
 }
 
 - (void)addRawEntriesFromDictionary:(GPBUInt32EnumDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
 - (void)setRawValue:(int32_t)value forKey:(uint32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint32_t)aKey {
+- (void)removeEnumForKey:(uint32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
-- (void)setValue:(int32_t)value forKey:(uint32_t)key {
+- (void)setEnum:(int32_t)value forKey:(uint32_t)key {
   if (!_validationFunc(value)) {
     [NSException raise:NSInvalidArgumentException
                 format:@"GPBUInt32EnumDictionary: Attempt to set an unknown enum value (%d)",
                        value];
   }
 
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
@@ skipping 84 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt32ObjectDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt32ObjectDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt32ObjectDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt32ObjectDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 127 matching lines @@
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Int32 -> UInt32
 
 @implementation GPBInt32UInt32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint32_t)value
-                             forKey:(int32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32:(uint32_t)value
+                              forKey:(int32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithValues:&value
-                                                          forKeys:&key
-                                                            count:1] autorelease];
+  return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithUInt32s:&value
+                                                           forKeys:&key
+                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint32_t [])values
-                             forKeys:(const int32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values
+                              forKeys:(const int32_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithUInt32s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt32UInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint32_t [])values
-                       forKeys:(const int32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt32s:(const uint32_t [])values
+                        forKeys:(const int32_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt32UInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32UInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32UInt32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32UInt32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt32sUsingBlock:
     (void (^)(int32_t key, uint32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey intValue], [aValue unsignedIntValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int32_t key, uint32_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt32sUsingBlock:^(int32_t key, uint32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%u", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(uint32_t *)value {
+- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedIntValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt32UInt32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint32_t)value forKey:(int32_t)key {
+- (void)setUInt32:(uint32_t)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeUInt32ForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int32 -> Int32
 
 @implementation GPBInt32Int32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int32_t)value
++ (instancetype)dictionaryWithInt32:(int32_t)value
                              forKey:(int32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32Int32Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBInt32Int32Dictionary*)[self alloc] initWithInt32s:&value
                                                          forKeys:&key
                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int32_t [])values
++ (instancetype)dictionaryWithInt32s:(const int32_t [])values
                              forKeys:(const int32_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32Int32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt32Int32Dictionary*)[self alloc] initWithInt32s:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt32Int32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt32Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int32_t [])values
+- (instancetype)initWithInt32s:(const int32_t [])values
                        forKeys:(const int32_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt32Int32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32Int32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32Int32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32Int32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32Int32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt32sUsingBlock:
     (void (^)(int32_t key, int32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey intValue], [aValue intValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int32_t key, int32_t value, BOOL *stop) {
+  [self enumerateKeysAndInt32sUsingBlock:^(int32_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%d", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(int32_t *)value {
+- (BOOL)getInt32:(nullable int32_t *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt32Int32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int32_t)value forKey:(int32_t)key {
+- (void)setInt32:(int32_t)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeInt32ForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int32 -> UInt64
 
 @implementation GPBInt32UInt64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint64_t)value
-                             forKey:(int32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64:(uint64_t)value
+                              forKey:(int32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithValues:&value
-                                                          forKeys:&key
-                                                            count:1] autorelease];
+  return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithUInt64s:&value
+                                                           forKeys:&key
+                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint64_t [])values
-                             forKeys:(const int32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values
+                              forKeys:(const int32_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithUInt64s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt32UInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint64_t [])values
-                       forKeys:(const int32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt64s:(const uint64_t [])values
+                        forKeys:(const int32_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt32UInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32UInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32UInt64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32UInt64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt64sUsingBlock:
     (void (^)(int32_t key, uint64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey intValue], [aValue unsignedLongLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int32_t key, uint64_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt64sUsingBlock:^(int32_t key, uint64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%llu", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(uint64_t *)value {
+- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedLongLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt32UInt64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint64_t)value forKey:(int32_t)key {
+- (void)setUInt64:(uint64_t)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeUInt64ForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int32 -> Int64
 
 @implementation GPBInt32Int64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int64_t)value
++ (instancetype)dictionaryWithInt64:(int64_t)value
                              forKey:(int32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32Int64Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBInt32Int64Dictionary*)[self alloc] initWithInt64s:&value
                                                          forKeys:&key
                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int64_t [])values
++ (instancetype)dictionaryWithInt64s:(const int64_t [])values
                              forKeys:(const int32_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32Int64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt32Int64Dictionary*)[self alloc] initWithInt64s:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt32Int64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt32Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int64_t [])values
+- (instancetype)initWithInt64s:(const int64_t [])values
                        forKeys:(const int32_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt32Int64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32Int64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32Int64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32Int64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32Int64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt64sUsingBlock:
     (void (^)(int32_t key, int64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey intValue], [aValue longLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int32_t key, int64_t value, BOOL *stop) {
+  [self enumerateKeysAndInt64sUsingBlock:^(int32_t key, int64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%lld", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(int64_t *)value {
+- (BOOL)getInt64:(nullable int64_t *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped longLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt32Int64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int64_t)value forKey:(int32_t)key {
+- (void)setInt64:(int64_t)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeInt64ForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int32 -> Bool
 
 @implementation GPBInt32BoolDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(BOOL)value
-                             forKey:(int32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBool:(BOOL)value
+                            forKey:(int32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32BoolDictionary*)[self alloc] initWithValues:&value
-                                                        forKeys:&key
-                                                          count:1] autorelease];
+  return [[(GPBInt32BoolDictionary*)[self alloc] initWithBools:&value
+                                                       forKeys:&key
+                                                         count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const BOOL [])values
-                             forKeys:(const int32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBools:(const BOOL [])values
+                            forKeys:(const int32_t [])keys
+                              count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32BoolDictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt32BoolDictionary*)[self alloc] initWithBools:values
                                                         forKeys:keys
                                                           count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt32BoolDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt32BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const BOOL [])values
-                       forKeys:(const int32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithBools:(const BOOL [])values
+                      forKeys:(const int32_t [])keys
+                        count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt32BoolDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithBools:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32BoolDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32BoolDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32BoolDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32BoolDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndBoolsUsingBlock:
     (void (^)(int32_t key, BOOL value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey intValue], [aValue boolValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueBool) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int32_t key, BOOL value, BOOL *stop) {
+  [self enumerateKeysAndBoolsUsingBlock:^(int32_t key, BOOL value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], (value ? @"true" : @"false"));
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(BOOL *)value {
+- (BOOL)getBool:(nullable BOOL *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped boolValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt32BoolDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(BOOL)value forKey:(int32_t)key {
+- (void)setBool:(BOOL)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeBoolForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int32 -> Float
 
 @implementation GPBInt32FloatDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(float)value
++ (instancetype)dictionaryWithFloat:(float)value
                              forKey:(int32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32FloatDictionary*)[self alloc] initWithValues:&value
+  return [[(GPBInt32FloatDictionary*)[self alloc] initWithFloats:&value
                                                          forKeys:&key
                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const float [])values
++ (instancetype)dictionaryWithFloats:(const float [])values
                              forKeys:(const int32_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32FloatDictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt32FloatDictionary*)[self alloc] initWithFloats:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt32FloatDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt32FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const float [])values
+- (instancetype)initWithFloats:(const float [])values
                        forKeys:(const int32_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt32FloatDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithFloats:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32FloatDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32FloatDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32FloatDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32FloatDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndFloatsUsingBlock:
     (void (^)(int32_t key, float value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey intValue], [aValue floatValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int32_t key, float value, BOOL *stop) {
+  [self enumerateKeysAndFloatsUsingBlock:^(int32_t key, float value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(float *)value {
+- (BOOL)getFloat:(nullable float *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped floatValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt32FloatDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(float)value forKey:(int32_t)key {
+- (void)setFloat:(float)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeFloatForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int32 -> Double
 
 @implementation GPBInt32DoubleDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(double)value
-                             forKey:(int32_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDouble:(double)value
+                              forKey:(int32_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32DoubleDictionary*)[self alloc] initWithValues:&value
-                                                          forKeys:&key
-                                                            count:1] autorelease];
+  return [[(GPBInt32DoubleDictionary*)[self alloc] initWithDoubles:&value
+                                                           forKeys:&key
+                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const double [])values
-                             forKeys:(const int32_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDoubles:(const double [])values
+                              forKeys:(const int32_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt32DoubleDictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt32DoubleDictionary*)[self alloc] initWithDoubles:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt32DoubleDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt32DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const double [])values
-                       forKeys:(const int32_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithDoubles:(const double [])values
+                        forKeys:(const int32_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt32DoubleDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithDoubles:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32DoubleDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32DoubleDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32DoubleDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32DoubleDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndDoublesUsingBlock:
     (void (^)(int32_t key, double value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey intValue], [aValue doubleValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int32_t key, double value, BOOL *stop) {
+  [self enumerateKeysAndDoublesUsingBlock:^(int32_t key, double value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(double *)value {
+- (BOOL)getDouble:(nullable double *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped doubleValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt32DoubleDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(double)value forKey:(int32_t)key {
+- (void)setDouble:(double)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeDoubleForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int32 -> Enum
@@ skipping 103 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32EnumDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32EnumDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32EnumDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32EnumDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 70 matching lines @@
   [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueInt32)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   [self enumerateKeysAndRawValuesUsingBlock:^(int32_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%d", key], @(value));
   }];
 }
 
-- (BOOL)valueForKey:(int32_t)key value:(int32_t *)value {
+- (BOOL)getEnum:(int32_t *)value forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     int32_t result = [wrapped intValue];
     if (!_validationFunc(result)) {
       result = kGPBUnrecognizedEnumeratorValue;
     }
     *value = result;
   }
   return (wrapped != NULL);
 }
 
-- (BOOL)valueForKey:(int32_t)key rawValue:(int32_t *)rawValue {
+- (BOOL)getRawValue:(int32_t *)rawValue forKey:(int32_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && rawValue) {
     *rawValue = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndEnumsUsingBlock:
     (void (^)(int32_t key, int32_t value, BOOL *stop))block {
   GPBEnumValidationFunc func = _validationFunc;
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       int32_t unwrapped = [aValue intValue];
       if (!func(unwrapped)) {
         unwrapped = kGPBUnrecognizedEnumeratorValue;
       }
       block([aKey intValue], unwrapped, stop);
   }];
 }
 
 - (void)addRawEntriesFromDictionary:(GPBInt32EnumDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
 - (void)setRawValue:(int32_t)value forKey:(int32_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int32_t)aKey {
+- (void)removeEnumForKey:(int32_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
-- (void)setValue:(int32_t)value forKey:(int32_t)key {
+- (void)setEnum:(int32_t)value forKey:(int32_t)key {
   if (!_validationFunc(value)) {
     [NSException raise:NSInvalidArgumentException
                 format:@"GPBInt32EnumDictionary: Attempt to set an unknown enum value (%d)",
                        value];
   }
 
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
@@ skipping 84 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt32ObjectDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt32ObjectDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt32ObjectDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt32ObjectDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 127 matching lines @@
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - UInt64 -> UInt32
 
 @implementation GPBUInt64UInt32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint32_t)value
-                             forKey:(uint64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32:(uint32_t)value
+                              forKey:(uint64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithUInt32s:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint32_t [])values
-                             forKeys:(const uint64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values
+                              forKeys:(const uint64_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithUInt32s:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint32_t [])values
-                       forKeys:(const uint64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt32s:(const uint32_t [])values
+                        forKeys:(const uint64_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64UInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64UInt32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64UInt32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt32sUsingBlock:
     (void (^)(uint64_t key, uint32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedLongLongValue], [aValue unsignedIntValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, uint32_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt32sUsingBlock:^(uint64_t key, uint32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%u", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(uint32_t *)value {
+- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedIntValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt64UInt32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint32_t)value forKey:(uint64_t)key {
+- (void)setUInt32:(uint32_t)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeUInt32ForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt64 -> Int32
 
 @implementation GPBUInt64Int32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int32_t)value
++ (instancetype)dictionaryWithInt32:(int32_t)value
                              forKey:(uint64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithInt32s:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int32_t [])values
++ (instancetype)dictionaryWithInt32s:(const int32_t [])values
                              forKeys:(const uint64_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithInt32s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt64Int32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int32_t [])values
+- (instancetype)initWithInt32s:(const int32_t [])values
                        forKeys:(const uint64_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt64Int32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64Int32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64Int32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64Int32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64Int32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt32sUsingBlock:
     (void (^)(uint64_t key, int32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedLongLongValue], [aValue intValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, int32_t value, BOOL *stop) {
+  [self enumerateKeysAndInt32sUsingBlock:^(uint64_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%d", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(int32_t *)value {
+- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt64Int32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int32_t)value forKey:(uint64_t)key {
+- (void)setInt32:(int32_t)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeInt32ForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt64 -> UInt64
 
 @implementation GPBUInt64UInt64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint64_t)value
-                             forKey:(uint64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64:(uint64_t)value
+                              forKey:(uint64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithUInt64s:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint64_t [])values
-                             forKeys:(const uint64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values
+                              forKeys:(const uint64_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithUInt64s:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint64_t [])values
-                       forKeys:(const uint64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt64s:(const uint64_t [])values
+                        forKeys:(const uint64_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64UInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64UInt64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64UInt64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt64sUsingBlock:
     (void (^)(uint64_t key, uint64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedLongLongValue], [aValue unsignedLongLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, uint64_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt64sUsingBlock:^(uint64_t key, uint64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%llu", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(uint64_t *)value {
+- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedLongLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt64UInt64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint64_t)value forKey:(uint64_t)key {
+- (void)setUInt64:(uint64_t)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeUInt64ForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt64 -> Int64
 
 @implementation GPBUInt64Int64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int64_t)value
++ (instancetype)dictionaryWithInt64:(int64_t)value
                              forKey:(uint64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithInt64s:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int64_t [])values
++ (instancetype)dictionaryWithInt64s:(const int64_t [])values
                              forKeys:(const uint64_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithInt64s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt64Int64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int64_t [])values
+- (instancetype)initWithInt64s:(const int64_t [])values
                        forKeys:(const uint64_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt64Int64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64Int64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64Int64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64Int64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64Int64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt64sUsingBlock:
     (void (^)(uint64_t key, int64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedLongLongValue], [aValue longLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, int64_t value, BOOL *stop) {
+  [self enumerateKeysAndInt64sUsingBlock:^(uint64_t key, int64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%lld", value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(int64_t *)value {
+- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped longLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt64Int64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int64_t)value forKey:(uint64_t)key {
+- (void)setInt64:(int64_t)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeInt64ForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt64 -> Bool
 
 @implementation GPBUInt64BoolDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(BOOL)value
-                             forKey:(uint64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBool:(BOOL)value
+                            forKey:(uint64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64BoolDictionary*)[self alloc] initWithValues:&value
-                                                         forKeys:&key
-                                                           count:1] autorelease];
+  return [[(GPBUInt64BoolDictionary*)[self alloc] initWithBools:&value
+                                                        forKeys:&key
+                                                          count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const BOOL [])values
-                             forKeys:(const uint64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBools:(const BOOL [])values
+                            forKeys:(const uint64_t [])keys
+                              count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64BoolDictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt64BoolDictionary*)[self alloc] initWithBools:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt64BoolDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt64BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const BOOL [])values
-                       forKeys:(const uint64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithBools:(const BOOL [])values
+                      forKeys:(const uint64_t [])keys
+                        count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt64BoolDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithBools:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64BoolDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64BoolDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64BoolDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64BoolDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndBoolsUsingBlock:
     (void (^)(uint64_t key, BOOL value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedLongLongValue], [aValue boolValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueBool) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, BOOL value, BOOL *stop) {
+  [self enumerateKeysAndBoolsUsingBlock:^(uint64_t key, BOOL value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], (value ? @"true" : @"false"));
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(BOOL *)value {
+- (BOOL)getBool:(nullable BOOL *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped boolValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt64BoolDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(BOOL)value forKey:(uint64_t)key {
+- (void)setBool:(BOOL)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeBoolForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt64 -> Float
 
 @implementation GPBUInt64FloatDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(float)value
++ (instancetype)dictionaryWithFloat:(float)value
                              forKey:(uint64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64FloatDictionary*)[self alloc] initWithValues:&value
+  return [[(GPBUInt64FloatDictionary*)[self alloc] initWithFloats:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const float [])values
++ (instancetype)dictionaryWithFloats:(const float [])values
                              forKeys:(const uint64_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64FloatDictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt64FloatDictionary*)[self alloc] initWithFloats:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt64FloatDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt64FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const float [])values
+- (instancetype)initWithFloats:(const float [])values
                        forKeys:(const uint64_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt64FloatDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithFloats:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64FloatDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64FloatDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64FloatDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64FloatDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndFloatsUsingBlock:
     (void (^)(uint64_t key, float value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedLongLongValue], [aValue floatValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, float value, BOOL *stop) {
+  [self enumerateKeysAndFloatsUsingBlock:^(uint64_t key, float value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(float *)value {
+- (BOOL)getFloat:(nullable float *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped floatValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt64FloatDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(float)value forKey:(uint64_t)key {
+- (void)setFloat:(float)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeFloatForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt64 -> Double
 
 @implementation GPBUInt64DoubleDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(double)value
-                             forKey:(uint64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDouble:(double)value
+                              forKey:(uint64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithDoubles:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const double [])values
-                             forKeys:(const uint64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDoubles:(const double [])values
+                              forKeys:(const uint64_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithValues:values
+  return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithDoubles:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBUInt64DoubleDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const double [])values
-                       forKeys:(const uint64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithDoubles:(const double [])values
+                        forKeys:(const uint64_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBUInt64DoubleDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithDoubles:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64DoubleDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64DoubleDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64DoubleDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64DoubleDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndDoublesUsingBlock:
     (void (^)(uint64_t key, double value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey unsignedLongLongValue], [aValue doubleValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, double value, BOOL *stop) {
+  [self enumerateKeysAndDoublesUsingBlock:^(uint64_t key, double value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(double *)value {
+- (BOOL)getDouble:(nullable double *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped doubleValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBUInt64DoubleDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(double)value forKey:(uint64_t)key {
+- (void)setDouble:(double)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeDoubleForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - UInt64 -> Enum
@@ skipping 103 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64EnumDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64EnumDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64EnumDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64EnumDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 70 matching lines @@
   [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueUInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   [self enumerateKeysAndRawValuesUsingBlock:^(uint64_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%llu", key], @(value));
   }];
 }
 
-- (BOOL)valueForKey:(uint64_t)key value:(int32_t *)value {
+- (BOOL)getEnum:(int32_t *)value forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     int32_t result = [wrapped intValue];
     if (!_validationFunc(result)) {
       result = kGPBUnrecognizedEnumeratorValue;
     }
     *value = result;
   }
   return (wrapped != NULL);
 }
 
-- (BOOL)valueForKey:(uint64_t)key rawValue:(int32_t *)rawValue {
+- (BOOL)getRawValue:(int32_t *)rawValue forKey:(uint64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && rawValue) {
     *rawValue = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndEnumsUsingBlock:
     (void (^)(uint64_t key, int32_t value, BOOL *stop))block {
   GPBEnumValidationFunc func = _validationFunc;
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       int32_t unwrapped = [aValue intValue];
       if (!func(unwrapped)) {
         unwrapped = kGPBUnrecognizedEnumeratorValue;
       }
       block([aKey unsignedLongLongValue], unwrapped, stop);
   }];
 }
 
 - (void)addRawEntriesFromDictionary:(GPBUInt64EnumDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
 - (void)setRawValue:(int32_t)value forKey:(uint64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(uint64_t)aKey {
+- (void)removeEnumForKey:(uint64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
-- (void)setValue:(int32_t)value forKey:(uint64_t)key {
+- (void)setEnum:(int32_t)value forKey:(uint64_t)key {
   if (!_validationFunc(value)) {
     [NSException raise:NSInvalidArgumentException
                 format:@"GPBUInt64EnumDictionary: Attempt to set an unknown enum value (%d)",
                        value];
   }
 
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
@@ skipping 84 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBUInt64ObjectDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBUInt64ObjectDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBUInt64ObjectDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBUInt64ObjectDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 127 matching lines @@
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Int64 -> UInt32
 
 @implementation GPBInt64UInt32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint32_t)value
-                             forKey:(int64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32:(uint32_t)value
+                              forKey:(int64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithValues:&value
-                                                          forKeys:&key
-                                                            count:1] autorelease];
+  return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithUInt32s:&value
+                                                           forKeys:&key
+                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint32_t [])values
-                             forKeys:(const int64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values
+                              forKeys:(const int64_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithUInt32s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt64UInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint32_t [])values
-                       forKeys:(const int64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt32s:(const uint32_t [])values
+                        forKeys:(const int64_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt64UInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64UInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64UInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64UInt32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64UInt32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt32sUsingBlock:
     (void (^)(int64_t key, uint32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey longLongValue], [aValue unsignedIntValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt32) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int64_t key, uint32_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt32sUsingBlock:^(int64_t key, uint32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%u", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(uint32_t *)value {
+- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedIntValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt64UInt32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint32_t)value forKey:(int64_t)key {
+- (void)setUInt32:(uint32_t)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeUInt32ForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int64 -> Int32
 
 @implementation GPBInt64Int32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int32_t)value
++ (instancetype)dictionaryWithInt32:(int32_t)value
                              forKey:(int64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64Int32Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBInt64Int32Dictionary*)[self alloc] initWithInt32s:&value
                                                          forKeys:&key
                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int32_t [])values
++ (instancetype)dictionaryWithInt32s:(const int32_t [])values
                              forKeys:(const int64_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64Int32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt64Int32Dictionary*)[self alloc] initWithInt32s:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt64Int32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt64Int32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int32_t [])values
+- (instancetype)initWithInt32s:(const int32_t [])values
                        forKeys:(const int64_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt64Int32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64Int32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64Int32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64Int32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64Int32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt32sUsingBlock:
     (void (^)(int64_t key, int32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey longLongValue], [aValue intValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt32) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int64_t key, int32_t value, BOOL *stop) {
+  [self enumerateKeysAndInt32sUsingBlock:^(int64_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%d", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(int32_t *)value {
+- (BOOL)getInt32:(nullable int32_t *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt64Int32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int32_t)value forKey:(int64_t)key {
+- (void)setInt32:(int32_t)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeInt32ForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int64 -> UInt64
 
 @implementation GPBInt64UInt64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint64_t)value
-                             forKey:(int64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64:(uint64_t)value
+                              forKey:(int64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithValues:&value
-                                                          forKeys:&key
-                                                            count:1] autorelease];
+  return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithUInt64s:&value
+                                                           forKeys:&key
+                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint64_t [])values
-                             forKeys:(const int64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values
+                              forKeys:(const int64_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithUInt64s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt64UInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint64_t [])values
-                       forKeys:(const int64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt64s:(const uint64_t [])values
+                        forKeys:(const int64_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt64UInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64UInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64UInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64UInt64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64UInt64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt64sUsingBlock:
     (void (^)(int64_t key, uint64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey longLongValue], [aValue unsignedLongLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt64) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int64_t key, uint64_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt64sUsingBlock:^(int64_t key, uint64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%llu", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(uint64_t *)value {
+- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped unsignedLongLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt64UInt64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint64_t)value forKey:(int64_t)key {
+- (void)setUInt64:(uint64_t)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeUInt64ForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int64 -> Int64
 
 @implementation GPBInt64Int64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int64_t)value
++ (instancetype)dictionaryWithInt64:(int64_t)value
                              forKey:(int64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64Int64Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBInt64Int64Dictionary*)[self alloc] initWithInt64s:&value
                                                          forKeys:&key
                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int64_t [])values
++ (instancetype)dictionaryWithInt64s:(const int64_t [])values
                              forKeys:(const int64_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64Int64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt64Int64Dictionary*)[self alloc] initWithInt64s:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt64Int64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt64Int64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int64_t [])values
+- (instancetype)initWithInt64s:(const int64_t [])values
                        forKeys:(const int64_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt64Int64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64Int64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64Int64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64Int64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64Int64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt64sUsingBlock:
     (void (^)(int64_t key, int64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey longLongValue], [aValue longLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt64) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int64_t key, int64_t value, BOOL *stop) {
+  [self enumerateKeysAndInt64sUsingBlock:^(int64_t key, int64_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%lld", value]);
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(int64_t *)value {
+- (BOOL)getInt64:(nullable int64_t *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped longLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt64Int64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int64_t)value forKey:(int64_t)key {
+- (void)setInt64:(int64_t)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeInt64ForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int64 -> Bool
 
 @implementation GPBInt64BoolDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(BOOL)value
-                             forKey:(int64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBool:(BOOL)value
+                            forKey:(int64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64BoolDictionary*)[self alloc] initWithValues:&value
-                                                        forKeys:&key
-                                                          count:1] autorelease];
+  return [[(GPBInt64BoolDictionary*)[self alloc] initWithBools:&value
+                                                       forKeys:&key
+                                                         count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const BOOL [])values
-                             forKeys:(const int64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBools:(const BOOL [])values
+                            forKeys:(const int64_t [])keys
+                              count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64BoolDictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt64BoolDictionary*)[self alloc] initWithBools:values
                                                         forKeys:keys
                                                           count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt64BoolDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt64BoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const BOOL [])values
-                       forKeys:(const int64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithBools:(const BOOL [])values
+                      forKeys:(const int64_t [])keys
+                        count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt64BoolDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithBools:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64BoolDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64BoolDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64BoolDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64BoolDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndBoolsUsingBlock:
     (void (^)(int64_t key, BOOL value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey longLongValue], [aValue boolValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueBool) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int64_t key, BOOL value, BOOL *stop) {
+  [self enumerateKeysAndBoolsUsingBlock:^(int64_t key, BOOL value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], (value ? @"true" : @"false"));
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(BOOL *)value {
+- (BOOL)getBool:(nullable BOOL *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped boolValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt64BoolDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(BOOL)value forKey:(int64_t)key {
+- (void)setBool:(BOOL)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeBoolForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int64 -> Float
 
 @implementation GPBInt64FloatDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(float)value
++ (instancetype)dictionaryWithFloat:(float)value
                              forKey:(int64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64FloatDictionary*)[self alloc] initWithValues:&value
+  return [[(GPBInt64FloatDictionary*)[self alloc] initWithFloats:&value
                                                          forKeys:&key
                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const float [])values
++ (instancetype)dictionaryWithFloats:(const float [])values
                              forKeys:(const int64_t [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64FloatDictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt64FloatDictionary*)[self alloc] initWithFloats:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt64FloatDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt64FloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const float [])values
+- (instancetype)initWithFloats:(const float [])values
                        forKeys:(const int64_t [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt64FloatDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithFloats:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64FloatDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64FloatDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64FloatDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64FloatDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndFloatsUsingBlock:
     (void (^)(int64_t key, float value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey longLongValue], [aValue floatValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueFloat) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int64_t key, float value, BOOL *stop) {
+  [self enumerateKeysAndFloatsUsingBlock:^(int64_t key, float value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(float *)value {
+- (BOOL)getFloat:(nullable float *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped floatValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt64FloatDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(float)value forKey:(int64_t)key {
+- (void)setFloat:(float)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeFloatForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int64 -> Double
 
 @implementation GPBInt64DoubleDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(double)value
-                             forKey:(int64_t)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDouble:(double)value
+                              forKey:(int64_t)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64DoubleDictionary*)[self alloc] initWithValues:&value
-                                                          forKeys:&key
-                                                            count:1] autorelease];
+  return [[(GPBInt64DoubleDictionary*)[self alloc] initWithDoubles:&value
+                                                           forKeys:&key
+                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const double [])values
-                             forKeys:(const int64_t [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDoubles:(const double [])values
+                              forKeys:(const int64_t [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBInt64DoubleDictionary*)[self alloc] initWithValues:values
+  return [[(GPBInt64DoubleDictionary*)[self alloc] initWithDoubles:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBInt64DoubleDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBInt64DoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const double [])values
-                       forKeys:(const int64_t [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithDoubles:(const double [])values
+                        forKeys:(const int64_t [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         [_dictionary setObject:@(values[i]) forKey:@(keys[i])];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBInt64DoubleDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithDoubles:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64DoubleDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64DoubleDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64DoubleDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64DoubleDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndDoublesUsingBlock:
     (void (^)(int64_t key, double value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block([aKey longLongValue], [aValue doubleValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueDouble) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(int64_t key, double value, BOOL *stop) {
+  [self enumerateKeysAndDoublesUsingBlock:^(int64_t key, double value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(double *)value {
+- (BOOL)getDouble:(nullable double *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     *value = [wrapped doubleValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBInt64DoubleDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(double)value forKey:(int64_t)key {
+- (void)setDouble:(double)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeDoubleForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - Int64 -> Enum
@@ skipping 103 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64EnumDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64EnumDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64EnumDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64EnumDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 70 matching lines @@
   [_dictionary setObject:@(value->valueEnum) forKey:@(key->valueInt64)];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   [self enumerateKeysAndRawValuesUsingBlock:^(int64_t key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block([NSString stringWithFormat:@"%lld", key], @(value));
   }];
 }
 
-- (BOOL)valueForKey:(int64_t)key value:(int32_t *)value {
+- (BOOL)getEnum:(int32_t *)value forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && value) {
     int32_t result = [wrapped intValue];
     if (!_validationFunc(result)) {
       result = kGPBUnrecognizedEnumeratorValue;
     }
     *value = result;
   }
   return (wrapped != NULL);
 }
 
-- (BOOL)valueForKey:(int64_t)key rawValue:(int32_t *)rawValue {
+- (BOOL)getRawValue:(int32_t *)rawValue forKey:(int64_t)key {
   NSNumber *wrapped = [_dictionary objectForKey:@(key)];
   if (wrapped && rawValue) {
     *rawValue = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndEnumsUsingBlock:
     (void (^)(int64_t key, int32_t value, BOOL *stop))block {
   GPBEnumValidationFunc func = _validationFunc;
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       int32_t unwrapped = [aValue intValue];
       if (!func(unwrapped)) {
         unwrapped = kGPBUnrecognizedEnumeratorValue;
       }
       block([aKey longLongValue], unwrapped, stop);
   }];
 }
 
 - (void)addRawEntriesFromDictionary:(GPBInt64EnumDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
 - (void)setRawValue:(int32_t)value forKey:(int64_t)key {
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(int64_t)aKey {
+- (void)removeEnumForKey:(int64_t)aKey {
   [_dictionary removeObjectForKey:@(aKey)];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
-- (void)setValue:(int32_t)value forKey:(int64_t)key {
+- (void)setEnum:(int32_t)value forKey:(int64_t)key {
   if (!_validationFunc(value)) {
     [NSException raise:NSInvalidArgumentException
                 format:@"GPBInt64EnumDictionary: Attempt to set an unknown enum value (%d)",
                        value];
   }
 
   [_dictionary setObject:@(value) forKey:@(key)];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
@@ skipping 84 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBInt64ObjectDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBInt64ObjectDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBInt64ObjectDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBInt64ObjectDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 127 matching lines @@
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - String -> UInt32
 
 @implementation GPBStringUInt32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint32_t)value
-                             forKey:(NSString *)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32:(uint32_t)value
+                              forKey:(NSString *)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringUInt32Dictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBStringUInt32Dictionary*)[self alloc] initWithUInt32s:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint32_t [])values
-                             forKeys:(const NSString * [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values
+                              forKeys:(const NSString * [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringUInt32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBStringUInt32Dictionary*)[self alloc] initWithUInt32s:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBStringUInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBStringUInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint32_t [])values
-                       forKeys:(const NSString * [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt32s:(const uint32_t [])values
+                        forKeys:(const NSString * [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         if (!keys[i]) {
           [NSException raise:NSInvalidArgumentException
                       format:@"Attempting to add nil key to a Dictionary"];
         }
         [_dictionary setObject:@(values[i]) forKey:keys[i]];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBStringUInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringUInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringUInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringUInt32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringUInt32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt32sUsingBlock:
     (void (^)(NSString *key, uint32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block(aKey, [aValue unsignedIntValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt32Field(outputStream, [aValue unsignedIntValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt32) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(NSString *key, uint32_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt32sUsingBlock:^(NSString *key, uint32_t value, BOOL *stop) {
       #pragma unused(stop)
       block(key, [NSString stringWithFormat:@"%u", value]);
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(uint32_t *)value {
+- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     *value = [wrapped unsignedIntValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBStringUInt32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint32_t)value forKey:(NSString *)key {
+- (void)setUInt32:(uint32_t)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeUInt32ForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - String -> Int32
 
 @implementation GPBStringInt32Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int32_t)value
++ (instancetype)dictionaryWithInt32:(int32_t)value
                              forKey:(NSString *)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringInt32Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBStringInt32Dictionary*)[self alloc] initWithInt32s:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int32_t [])values
++ (instancetype)dictionaryWithInt32s:(const int32_t [])values
                              forKeys:(const NSString * [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringInt32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBStringInt32Dictionary*)[self alloc] initWithInt32s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBStringInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBStringInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int32_t [])values
+- (instancetype)initWithInt32s:(const int32_t [])values
                        forKeys:(const NSString * [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         if (!keys[i]) {
           [NSException raise:NSInvalidArgumentException
                       format:@"Attempting to add nil key to a Dictionary"];
         }
         [_dictionary setObject:@(values[i]) forKey:keys[i]];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBStringInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringInt32Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringInt32Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt32sUsingBlock:
     (void (^)(NSString *key, int32_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block(aKey, [aValue intValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt32Field(outputStream, [aValue intValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt32) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(NSString *key, int32_t value, BOOL *stop) {
+  [self enumerateKeysAndInt32sUsingBlock:^(NSString *key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block(key, [NSString stringWithFormat:@"%d", value]);
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(int32_t *)value {
+- (BOOL)getInt32:(nullable int32_t *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     *value = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBStringInt32Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int32_t)value forKey:(NSString *)key {
+- (void)setInt32:(int32_t)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeInt32ForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - String -> UInt64
 
 @implementation GPBStringUInt64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint64_t)value
-                             forKey:(NSString *)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64:(uint64_t)value
+                              forKey:(NSString *)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringUInt64Dictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBStringUInt64Dictionary*)[self alloc] initWithUInt64s:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint64_t [])values
-                             forKeys:(const NSString * [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values
+                              forKeys:(const NSString * [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringUInt64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBStringUInt64Dictionary*)[self alloc] initWithUInt64s:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBStringUInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBStringUInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint64_t [])values
-                       forKeys:(const NSString * [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt64s:(const uint64_t [])values
+                        forKeys:(const NSString * [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         if (!keys[i]) {
           [NSException raise:NSInvalidArgumentException
                       format:@"Attempting to add nil key to a Dictionary"];
         }
         [_dictionary setObject:@(values[i]) forKey:keys[i]];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBStringUInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringUInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringUInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringUInt64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringUInt64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt64sUsingBlock:
     (void (^)(NSString *key, uint64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block(aKey, [aValue unsignedLongLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictUInt64Field(outputStream, [aValue unsignedLongLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueUInt64) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(NSString *key, uint64_t value, BOOL *stop) {
+  [self enumerateKeysAndUInt64sUsingBlock:^(NSString *key, uint64_t value, BOOL *stop) {
       #pragma unused(stop)
       block(key, [NSString stringWithFormat:@"%llu", value]);
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(uint64_t *)value {
+- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     *value = [wrapped unsignedLongLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBStringUInt64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint64_t)value forKey:(NSString *)key {
+- (void)setUInt64:(uint64_t)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeUInt64ForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - String -> Int64
 
 @implementation GPBStringInt64Dictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int64_t)value
++ (instancetype)dictionaryWithInt64:(int64_t)value
                              forKey:(NSString *)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringInt64Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBStringInt64Dictionary*)[self alloc] initWithInt64s:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int64_t [])values
++ (instancetype)dictionaryWithInt64s:(const int64_t [])values
                              forKeys:(const NSString * [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringInt64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBStringInt64Dictionary*)[self alloc] initWithInt64s:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBStringInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBStringInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int64_t [])values
+- (instancetype)initWithInt64s:(const int64_t [])values
                        forKeys:(const NSString * [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         if (!keys[i]) {
           [NSException raise:NSInvalidArgumentException
                       format:@"Attempting to add nil key to a Dictionary"];
         }
         [_dictionary setObject:@(values[i]) forKey:keys[i]];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBStringInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringInt64Dictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringInt64Dictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt64sUsingBlock:
     (void (^)(NSString *key, int64_t value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block(aKey, [aValue longLongValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictInt64Field(outputStream, [aValue longLongValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueInt64) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(NSString *key, int64_t value, BOOL *stop) {
+  [self enumerateKeysAndInt64sUsingBlock:^(NSString *key, int64_t value, BOOL *stop) {
       #pragma unused(stop)
       block(key, [NSString stringWithFormat:@"%lld", value]);
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(int64_t *)value {
+- (BOOL)getInt64:(nullable int64_t *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     *value = [wrapped longLongValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBStringInt64Dictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int64_t)value forKey:(NSString *)key {
+- (void)setInt64:(int64_t)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeInt64ForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - String -> Bool
 
 @implementation GPBStringBoolDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(BOOL)value
-                             forKey:(NSString *)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBool:(BOOL)value
+                            forKey:(NSString *)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringBoolDictionary*)[self alloc] initWithValues:&value
-                                                         forKeys:&key
-                                                           count:1] autorelease];
+  return [[(GPBStringBoolDictionary*)[self alloc] initWithBools:&value
+                                                        forKeys:&key
+                                                          count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const BOOL [])values
-                             forKeys:(const NSString * [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBools:(const BOOL [])values
+                            forKeys:(const NSString * [])keys
+                              count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringBoolDictionary*)[self alloc] initWithValues:values
+  return [[(GPBStringBoolDictionary*)[self alloc] initWithBools:values
                                                          forKeys:keys
                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBStringBoolDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBStringBoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const BOOL [])values
-                       forKeys:(const NSString * [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithBools:(const BOOL [])values
+                      forKeys:(const NSString * [])keys
+                        count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         if (!keys[i]) {
           [NSException raise:NSInvalidArgumentException
                       format:@"Attempting to add nil key to a Dictionary"];
         }
         [_dictionary setObject:@(values[i]) forKey:keys[i]];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBStringBoolDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithBools:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringBoolDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringBoolDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringBoolDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringBoolDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndBoolsUsingBlock:
     (void (^)(NSString *key, BOOL value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block(aKey, [aValue boolValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictBoolField(outputStream, [aValue boolValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueBool) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(NSString *key, BOOL value, BOOL *stop) {
+  [self enumerateKeysAndBoolsUsingBlock:^(NSString *key, BOOL value, BOOL *stop) {
       #pragma unused(stop)
       block(key, (value ? @"true" : @"false"));
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(BOOL *)value {
+- (BOOL)getBool:(nullable BOOL *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     *value = [wrapped boolValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBStringBoolDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(BOOL)value forKey:(NSString *)key {
+- (void)setBool:(BOOL)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeBoolForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - String -> Float
 
 @implementation GPBStringFloatDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(float)value
++ (instancetype)dictionaryWithFloat:(float)value
                              forKey:(NSString *)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringFloatDictionary*)[self alloc] initWithValues:&value
+  return [[(GPBStringFloatDictionary*)[self alloc] initWithFloats:&value
                                                           forKeys:&key
                                                             count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const float [])values
++ (instancetype)dictionaryWithFloats:(const float [])values
                              forKeys:(const NSString * [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringFloatDictionary*)[self alloc] initWithValues:values
+  return [[(GPBStringFloatDictionary*)[self alloc] initWithFloats:values
                                                           forKeys:keys
                                                             count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBStringFloatDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBStringFloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const float [])values
+- (instancetype)initWithFloats:(const float [])values
                        forKeys:(const NSString * [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         if (!keys[i]) {
           [NSException raise:NSInvalidArgumentException
                       format:@"Attempting to add nil key to a Dictionary"];
         }
         [_dictionary setObject:@(values[i]) forKey:keys[i]];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBStringFloatDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithFloats:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringFloatDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringFloatDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringFloatDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringFloatDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndFloatsUsingBlock:
     (void (^)(NSString *key, float value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block(aKey, [aValue floatValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictFloatField(outputStream, [aValue floatValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueFloat) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(NSString *key, float value, BOOL *stop) {
+  [self enumerateKeysAndFloatsUsingBlock:^(NSString *key, float value, BOOL *stop) {
       #pragma unused(stop)
       block(key, [NSString stringWithFormat:@"%.*g", FLT_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(float *)value {
+- (BOOL)getFloat:(nullable float *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     *value = [wrapped floatValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBStringFloatDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(float)value forKey:(NSString *)key {
+- (void)setFloat:(float)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeFloatForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - String -> Double
 
 @implementation GPBStringDoubleDictionary {
  @package
   NSMutableDictionary *_dictionary;
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(double)value
-                             forKey:(NSString *)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDouble:(double)value
+                              forKey:(NSString *)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringDoubleDictionary*)[self alloc] initWithValues:&value
-                                                           forKeys:&key
-                                                             count:1] autorelease];
+  return [[(GPBStringDoubleDictionary*)[self alloc] initWithDoubles:&value
+                                                            forKeys:&key
+                                                              count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const double [])values
-                             forKeys:(const NSString * [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDoubles:(const double [])values
+                              forKeys:(const NSString * [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBStringDoubleDictionary*)[self alloc] initWithValues:values
+  return [[(GPBStringDoubleDictionary*)[self alloc] initWithDoubles:values
                                                            forKeys:keys
                                                              count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBStringDoubleDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBStringDoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const double [])values
-                       forKeys:(const NSString * [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithDoubles:(const double [])values
+                        forKeys:(const NSString * [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     _dictionary = [[NSMutableDictionary alloc] init];
     if (count && values && keys) {
       for (NSUInteger i = 0; i < count; ++i) {
         if (!keys[i]) {
           [NSException raise:NSInvalidArgumentException
                       format:@"Attempting to add nil key to a Dictionary"];
         }
         [_dictionary setObject:@(values[i]) forKey:keys[i]];
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBStringDoubleDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithDoubles:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       [_dictionary addEntriesFromDictionary:dictionary->_dictionary];
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringDoubleDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringDoubleDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringDoubleDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringDoubleDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
 - (NSUInteger)count {
   return _dictionary.count;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndDoublesUsingBlock:
     (void (^)(NSString *key, double value, BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       block(aKey, [aValue doubleValue], stop);
   }];
 }
 
 - (size_t)computeSerializedSizeAsField:(GPBFieldDescriptor *)field {
   NSUInteger count = _dictionary.count;
@@ skipping 37 matching lines @@
     WriteDictDoubleField(outputStream, [aValue doubleValue], kMapValueFieldNumber, valueDataType);
   }];
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   [_dictionary setObject:@(value->valueDouble) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
-  [self enumerateKeysAndValuesUsingBlock:^(NSString *key, double value, BOOL *stop) {
+  [self enumerateKeysAndDoublesUsingBlock:^(NSString *key, double value, BOOL *stop) {
       #pragma unused(stop)
       block(key, [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]);
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(double *)value {
+- (BOOL)getDouble:(nullable double *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     *value = [wrapped doubleValue];
   }
   return (wrapped != NULL);
 }
 
 - (void)addEntriesFromDictionary:(GPBStringDoubleDictionary *)otherDictionary {
   if (otherDictionary) {
     [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary];
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(double)value forKey:(NSString *)key {
+- (void)setDouble:(double)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeDoubleForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
 @end
 
 #pragma mark - String -> Enum
@@ skipping 107 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [_dictionary release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBStringEnumDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBStringEnumDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBStringEnumDictionary class]]) {
     return NO;
   }
-  return [_dictionary isEqual:other->_dictionary];
+  GPBStringEnumDictionary *otherDictionary = other;
+  return [_dictionary isEqual:otherDictionary->_dictionary];
 }
 
 - (NSUInteger)hash {
   return _dictionary.count;
 }
 
 - (NSString *)description {
   return [NSString stringWithFormat:@"<%@ %p> { %@ }", [self class], self, _dictionary];
 }
 
@@ skipping 70 matching lines @@
   [_dictionary setObject:@(value->valueEnum) forKey:key->valueString];
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   [self enumerateKeysAndRawValuesUsingBlock:^(NSString *key, int32_t value, BOOL *stop) {
       #pragma unused(stop)
       block(key, @(value));
   }];
 }
 
-- (BOOL)valueForKey:(NSString *)key value:(int32_t *)value {
+- (BOOL)getEnum:(int32_t *)value forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && value) {
     int32_t result = [wrapped intValue];
     if (!_validationFunc(result)) {
       result = kGPBUnrecognizedEnumeratorValue;
     }
     *value = result;
   }
   return (wrapped != NULL);
 }
 
-- (BOOL)valueForKey:(NSString *)key rawValue:(int32_t *)rawValue {
+- (BOOL)getRawValue:(int32_t *)rawValue forKey:(NSString *)key {
   NSNumber *wrapped = [_dictionary objectForKey:key];
   if (wrapped && rawValue) {
     *rawValue = [wrapped intValue];
   }
   return (wrapped != NULL);
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndEnumsUsingBlock:
     (void (^)(NSString *key, int32_t value, BOOL *stop))block {
   GPBEnumValidationFunc func = _validationFunc;
   [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey,
                                                    NSNumber *aValue,
                                                    BOOL *stop) {
       int32_t unwrapped = [aValue intValue];
       if (!func(unwrapped)) {
         unwrapped = kGPBUnrecognizedEnumeratorValue;
       }
       block(aKey, unwrapped, stop);
@@ skipping 13 matching lines @@
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   [_dictionary setObject:@(value) forKey:key];
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(NSString *)aKey {
+- (void)removeEnumForKey:(NSString *)aKey {
   [_dictionary removeObjectForKey:aKey];
 }
 
 - (void)removeAll {
   [_dictionary removeAllObjects];
 }
 
-- (void)setValue:(int32_t)value forKey:(NSString *)key {
+- (void)setEnum:(int32_t)value forKey:(NSString *)key {
   if (!key) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Attempting to add nil key to a Dictionary"];
   }
   if (!_validationFunc(value)) {
     [NSException raise:NSInvalidArgumentException
                 format:@"GPBStringEnumDictionary: Attempt to set an unknown enum value (%d)",
                        value];
   }
 
@@ skipping 13 matching lines @@
 
 #pragma mark - Bool -> UInt32
 
 @implementation GPBBoolUInt32Dictionary {
  @package
   uint32_t _values[2];
   BOOL _valueSet[2];
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint32_t)value
-                             forKey:(BOOL)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32:(uint32_t)value
+                              forKey:(BOOL)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithValues:&value
-                                                         forKeys:&key
-                                                           count:1] autorelease];
+  return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithUInt32s:&value
+                                                          forKeys:&key
+                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint32_t [])values
-                             forKeys:(const BOOL [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values
+                              forKeys:(const BOOL [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithValues:values
-                                                         forKeys:keys
-                                                           count:count] autorelease];
+  return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithUInt32s:values
+                                                          forKeys:keys
+                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBBoolUInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint32_t [])values
-                       forKeys:(const BOOL [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt32s:(const uint32_t [])values
+                        forKeys:(const BOOL [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     for (NSUInteger i = 0; i < count; ++i) {
       int idx = keys[i] ? 1 : 0;
       _values[idx] = values[i];
       _valueSet[idx] = YES;
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBBoolUInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       for (int i = 0; i < 2; ++i) {
         if (dictionary->_valueSet[i]) {
           _values[i] = dictionary->_values[i];
           _valueSet[i] = YES;
         }
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt32s:NULL forKeys:NULL count:0];
 }
 
 #if !defined(NS_BLOCK_ASSERTIONS)
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolUInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolUInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolUInt32Dictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolUInt32Dictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %u", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %u", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(uint32_t *)value {
+- (BOOL)getUInt32:(uint32_t *)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       *value = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   int idx = (key->valueBool ? 1 : 0);
   _values[idx] = value->valueUInt32;
   _valueSet[idx] = YES;
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   if (_valueSet[0]) {
     block(@"false", [NSString stringWithFormat:@"%u", _values[0]]);
   }
   if (_valueSet[1]) {
     block(@"true", [NSString stringWithFormat:@"%u", _values[1]]);
   }
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt32sUsingBlock:
     (void (^)(BOOL key, uint32_t value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
@@ skipping 40 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint32_t)value forKey:(BOOL)key {
+- (void)setUInt32:(uint32_t)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeUInt32ForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Int32, int32_t)
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Bool -> Int32
 
 @implementation GPBBoolInt32Dictionary {
  @package
   int32_t _values[2];
   BOOL _valueSet[2];
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int32_t)value
++ (instancetype)dictionaryWithInt32:(int32_t)value
                              forKey:(BOOL)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolInt32Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBBoolInt32Dictionary*)[self alloc] initWithInt32s:&value
                                                         forKeys:&key
                                                           count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int32_t [])values
++ (instancetype)dictionaryWithInt32s:(const int32_t [])values
                              forKeys:(const BOOL [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolInt32Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBBoolInt32Dictionary*)[self alloc] initWithInt32s:values
                                                         forKeys:keys
                                                           count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBBoolInt32Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBBoolInt32Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int32_t [])values
+- (instancetype)initWithInt32s:(const int32_t [])values
                        forKeys:(const BOOL [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     for (NSUInteger i = 0; i < count; ++i) {
       int idx = keys[i] ? 1 : 0;
       _values[idx] = values[i];
       _valueSet[idx] = YES;
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBBoolInt32Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt32s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       for (int i = 0; i < 2; ++i) {
         if (dictionary->_valueSet[i]) {
           _values[i] = dictionary->_values[i];
           _valueSet[i] = YES;
         }
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt32s:NULL forKeys:NULL count:0];
 }
 
 #if !defined(NS_BLOCK_ASSERTIONS)
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolInt32Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolInt32Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolInt32Dictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolInt32Dictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %d", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %d", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(int32_t *)value {
+- (BOOL)getInt32:(int32_t *)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       *value = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   int idx = (key->valueBool ? 1 : 0);
   _values[idx] = value->valueInt32;
   _valueSet[idx] = YES;
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   if (_valueSet[0]) {
     block(@"false", [NSString stringWithFormat:@"%d", _values[0]]);
   }
   if (_valueSet[1]) {
     block(@"true", [NSString stringWithFormat:@"%d", _values[1]]);
   }
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt32sUsingBlock:
     (void (^)(BOOL key, int32_t value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
@@ skipping 40 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int32_t)value forKey:(BOOL)key {
+- (void)setInt32:(int32_t)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeInt32ForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(UInt64, uint64_t)
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Bool -> UInt64
 
 @implementation GPBBoolUInt64Dictionary {
  @package
   uint64_t _values[2];
   BOOL _valueSet[2];
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(uint64_t)value
-                             forKey:(BOOL)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64:(uint64_t)value
+                              forKey:(BOOL)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithValues:&value
-                                                         forKeys:&key
-                                                           count:1] autorelease];
+  return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithUInt64s:&value
+                                                          forKeys:&key
+                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const uint64_t [])values
-                             forKeys:(const BOOL [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values
+                              forKeys:(const BOOL [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithValues:values
-                                                         forKeys:keys
-                                                           count:count] autorelease];
+  return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithUInt64s:values
+                                                          forKeys:keys
+                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBBoolUInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const uint64_t [])values
-                       forKeys:(const BOOL [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithUInt64s:(const uint64_t [])values
+                        forKeys:(const BOOL [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     for (NSUInteger i = 0; i < count; ++i) {
       int idx = keys[i] ? 1 : 0;
       _values[idx] = values[i];
       _valueSet[idx] = YES;
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBBoolUInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithUInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       for (int i = 0; i < 2; ++i) {
         if (dictionary->_valueSet[i]) {
           _values[i] = dictionary->_values[i];
           _valueSet[i] = YES;
         }
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithUInt64s:NULL forKeys:NULL count:0];
 }
 
 #if !defined(NS_BLOCK_ASSERTIONS)
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolUInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolUInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolUInt64Dictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolUInt64Dictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %llu", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %llu", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(uint64_t *)value {
+- (BOOL)getUInt64:(uint64_t *)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       *value = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   int idx = (key->valueBool ? 1 : 0);
   _values[idx] = value->valueUInt64;
   _valueSet[idx] = YES;
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   if (_valueSet[0]) {
     block(@"false", [NSString stringWithFormat:@"%llu", _values[0]]);
   }
   if (_valueSet[1]) {
     block(@"true", [NSString stringWithFormat:@"%llu", _values[1]]);
   }
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndUInt64sUsingBlock:
     (void (^)(BOOL key, uint64_t value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
@@ skipping 40 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(uint64_t)value forKey:(BOOL)key {
+- (void)setUInt64:(uint64_t)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeUInt64ForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Int64, int64_t)
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Bool -> Int64
 
 @implementation GPBBoolInt64Dictionary {
  @package
   int64_t _values[2];
   BOOL _valueSet[2];
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(int64_t)value
++ (instancetype)dictionaryWithInt64:(int64_t)value
                              forKey:(BOOL)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolInt64Dictionary*)[self alloc] initWithValues:&value
+  return [[(GPBBoolInt64Dictionary*)[self alloc] initWithInt64s:&value
                                                         forKeys:&key
                                                           count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const int64_t [])values
++ (instancetype)dictionaryWithInt64s:(const int64_t [])values
                              forKeys:(const BOOL [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolInt64Dictionary*)[self alloc] initWithValues:values
+  return [[(GPBBoolInt64Dictionary*)[self alloc] initWithInt64s:values
                                                         forKeys:keys
                                                           count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBBoolInt64Dictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBBoolInt64Dictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const int64_t [])values
+- (instancetype)initWithInt64s:(const int64_t [])values
                        forKeys:(const BOOL [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     for (NSUInteger i = 0; i < count; ++i) {
       int idx = keys[i] ? 1 : 0;
       _values[idx] = values[i];
       _valueSet[idx] = YES;
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBBoolInt64Dictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithInt64s:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       for (int i = 0; i < 2; ++i) {
         if (dictionary->_valueSet[i]) {
           _values[i] = dictionary->_values[i];
           _valueSet[i] = YES;
         }
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithInt64s:NULL forKeys:NULL count:0];
 }
 
 #if !defined(NS_BLOCK_ASSERTIONS)
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolInt64Dictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolInt64Dictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolInt64Dictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolInt64Dictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %lld", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %lld", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(int64_t *)value {
+- (BOOL)getInt64:(int64_t *)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       *value = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   int idx = (key->valueBool ? 1 : 0);
   _values[idx] = value->valueInt64;
   _valueSet[idx] = YES;
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   if (_valueSet[0]) {
     block(@"false", [NSString stringWithFormat:@"%lld", _values[0]]);
   }
   if (_valueSet[1]) {
     block(@"true", [NSString stringWithFormat:@"%lld", _values[1]]);
   }
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndInt64sUsingBlock:
     (void (^)(BOOL key, int64_t value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
@@ skipping 40 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int64_t)value forKey:(BOOL)key {
+- (void)setInt64:(int64_t)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeInt64ForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Bool, BOOL)
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Bool -> Bool
 
 @implementation GPBBoolBoolDictionary {
  @package
   BOOL _values[2];
   BOOL _valueSet[2];
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(BOOL)value
-                             forKey:(BOOL)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBool:(BOOL)value
+                            forKey:(BOOL)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolBoolDictionary*)[self alloc] initWithValues:&value
-                                                       forKeys:&key
-                                                         count:1] autorelease];
+  return [[(GPBBoolBoolDictionary*)[self alloc] initWithBools:&value
+                                                      forKeys:&key
+                                                        count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const BOOL [])values
-                             forKeys:(const BOOL [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithBools:(const BOOL [])values
+                            forKeys:(const BOOL [])keys
+                              count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolBoolDictionary*)[self alloc] initWithValues:values
-                                                       forKeys:keys
-                                                         count:count] autorelease];
+  return [[(GPBBoolBoolDictionary*)[self alloc] initWithBools:values
+                                                      forKeys:keys
+                                                        count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBBoolBoolDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBBoolBoolDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const BOOL [])values
-                       forKeys:(const BOOL [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithBools:(const BOOL [])values
+                      forKeys:(const BOOL [])keys
+                        count:(NSUInteger)count {
   self = [super init];
   if (self) {
     for (NSUInteger i = 0; i < count; ++i) {
       int idx = keys[i] ? 1 : 0;
       _values[idx] = values[i];
       _valueSet[idx] = YES;
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBBoolBoolDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithBools:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       for (int i = 0; i < 2; ++i) {
         if (dictionary->_valueSet[i]) {
           _values[i] = dictionary->_values[i];
           _valueSet[i] = YES;
         }
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithBools:NULL forKeys:NULL count:0];
 }
 
 #if !defined(NS_BLOCK_ASSERTIONS)
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolBoolDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolBoolDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolBoolDictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolBoolDictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %d", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %d", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(BOOL *)value {
+- (BOOL)getBool:(BOOL *)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       *value = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   int idx = (key->valueBool ? 1 : 0);
   _values[idx] = value->valueBool;
   _valueSet[idx] = YES;
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   if (_valueSet[0]) {
     block(@"false", (_values[0] ? @"true" : @"false"));
   }
   if (_valueSet[1]) {
     block(@"true", (_values[1] ? @"true" : @"false"));
   }
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndBoolsUsingBlock:
     (void (^)(BOOL key, BOOL value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
@@ skipping 40 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(BOOL)value forKey:(BOOL)key {
+- (void)setBool:(BOOL)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeBoolForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Float, float)
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Bool -> Float
 
 @implementation GPBBoolFloatDictionary {
  @package
   float _values[2];
   BOOL _valueSet[2];
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(float)value
++ (instancetype)dictionaryWithFloat:(float)value
                              forKey:(BOOL)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolFloatDictionary*)[self alloc] initWithValues:&value
+  return [[(GPBBoolFloatDictionary*)[self alloc] initWithFloats:&value
                                                         forKeys:&key
                                                           count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const float [])values
++ (instancetype)dictionaryWithFloats:(const float [])values
                              forKeys:(const BOOL [])keys
                                count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
+  // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolFloatDictionary*)[self alloc] initWithValues:values
+  return [[(GPBBoolFloatDictionary*)[self alloc] initWithFloats:values
                                                         forKeys:keys
                                                           count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBBoolFloatDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBBoolFloatDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const float [])values
+- (instancetype)initWithFloats:(const float [])values
                        forKeys:(const BOOL [])keys
                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     for (NSUInteger i = 0; i < count; ++i) {
       int idx = keys[i] ? 1 : 0;
       _values[idx] = values[i];
       _valueSet[idx] = YES;
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBBoolFloatDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithFloats:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       for (int i = 0; i < 2; ++i) {
         if (dictionary->_valueSet[i]) {
           _values[i] = dictionary->_values[i];
           _valueSet[i] = YES;
         }
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithFloats:NULL forKeys:NULL count:0];
 }
 
 #if !defined(NS_BLOCK_ASSERTIONS)
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolFloatDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolFloatDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolFloatDictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolFloatDictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %f", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %f", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(float *)value {
+- (BOOL)getFloat:(float *)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       *value = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   int idx = (key->valueBool ? 1 : 0);
   _values[idx] = value->valueFloat;
   _valueSet[idx] = YES;
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   if (_valueSet[0]) {
     block(@"false", [NSString stringWithFormat:@"%.*g", FLT_DIG, _values[0]]);
   }
   if (_valueSet[1]) {
     block(@"true", [NSString stringWithFormat:@"%.*g", FLT_DIG, _values[1]]);
   }
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndFloatsUsingBlock:
     (void (^)(BOOL key, float value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
@@ skipping 40 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(float)value forKey:(BOOL)key {
+- (void)setFloat:(float)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeFloatForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
 //%PDDM-EXPAND DICTIONARY_BOOL_KEY_TO_POD_IMPL(Double, double)
 // This block of code is generated, do not edit it directly.
 
 #pragma mark - Bool -> Double
 
 @implementation GPBBoolDoubleDictionary {
  @package
   double _values[2];
   BOOL _valueSet[2];
 }
 
 + (instancetype)dictionary {
-  return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease];
+  return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease];
 }
 
-+ (instancetype)dictionaryWithValue:(double)value
-                             forKey:(BOOL)key {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDouble:(double)value
+                              forKey:(BOOL)key {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolDoubleDictionary*)[self alloc] initWithValues:&value
-                                                         forKeys:&key
-                                                           count:1] autorelease];
+  return [[(GPBBoolDoubleDictionary*)[self alloc] initWithDoubles:&value
+                                                          forKeys:&key
+                                                            count:1] autorelease];
 }
 
-+ (instancetype)dictionaryWithValues:(const double [])values
-                             forKeys:(const BOOL [])keys
-                               count:(NSUInteger)count {
-  // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count:
++ (instancetype)dictionaryWithDoubles:(const double [])values
+                              forKeys:(const BOOL [])keys
+                                count:(NSUInteger)count {
+  // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count:
   // on to get the type correct.
-  return [[(GPBBoolDoubleDictionary*)[self alloc] initWithValues:values
-                                                         forKeys:keys
-                                                           count:count] autorelease];
+  return [[(GPBBoolDoubleDictionary*)[self alloc] initWithDoubles:values
+                                                          forKeys:keys
+                                                            count:count] autorelease];
 }
 
 + (instancetype)dictionaryWithDictionary:(GPBBoolDoubleDictionary *)dictionary {
   // Cast is needed so the compiler knows what class we are invoking initWithDictionary:
   // on to get the type correct.
   return [[(GPBBoolDoubleDictionary*)[self alloc] initWithDictionary:dictionary] autorelease];
 }
 
 + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems {
   return [[[self alloc] initWithCapacity:numItems] autorelease];
 }
 
 - (instancetype)init {
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
-- (instancetype)initWithValues:(const double [])values
-                       forKeys:(const BOOL [])keys
-                         count:(NSUInteger)count {
+- (instancetype)initWithDoubles:(const double [])values
+                        forKeys:(const BOOL [])keys
+                          count:(NSUInteger)count {
   self = [super init];
   if (self) {
     for (NSUInteger i = 0; i < count; ++i) {
       int idx = keys[i] ? 1 : 0;
       _values[idx] = values[i];
       _valueSet[idx] = YES;
     }
   }
   return self;
 }
 
 - (instancetype)initWithDictionary:(GPBBoolDoubleDictionary *)dictionary {
-  self = [self initWithValues:NULL forKeys:NULL count:0];
+  self = [self initWithDoubles:NULL forKeys:NULL count:0];
   if (self) {
     if (dictionary) {
       for (int i = 0; i < 2; ++i) {
         if (dictionary->_valueSet[i]) {
           _values[i] = dictionary->_values[i];
           _valueSet[i] = YES;
         }
       }
     }
   }
   return self;
 }
 
 - (instancetype)initWithCapacity:(NSUInteger)numItems {
   #pragma unused(numItems)
-  return [self initWithValues:NULL forKeys:NULL count:0];
+  return [self initWithDoubles:NULL forKeys:NULL count:0];
 }
 
 #if !defined(NS_BLOCK_ASSERTIONS)
 - (void)dealloc {
   NSAssert(!_autocreator,
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolDoubleDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolDoubleDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolDoubleDictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolDoubleDictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %lf", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %lf", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(double *)value {
+- (BOOL)getDouble:(double *)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       *value = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)setGPBGenericValue:(GPBGenericValue *)value
      forGPBGenericValueKey:(GPBGenericValue *)key {
   int idx = (key->valueBool ? 1 : 0);
   _values[idx] = value->valueDouble;
   _valueSet[idx] = YES;
 }
 
 - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block {
   if (_valueSet[0]) {
     block(@"false", [NSString stringWithFormat:@"%.*lg", DBL_DIG, _values[0]]);
   }
   if (_valueSet[1]) {
     block(@"true", [NSString stringWithFormat:@"%.*lg", DBL_DIG, _values[1]]);
   }
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndDoublesUsingBlock:
     (void (^)(BOOL key, double value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
@@ skipping 40 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(double)value forKey:(BOOL)key {
+- (void)setDouble:(double)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeDoubleForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
@@ skipping 84 matching lines @@
            [self class], _autocreator);
   [_values[0] release];
   [_values[1] release];
   [super dealloc];
 }
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolObjectDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolObjectDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolObjectDictionary class]]) {
     return NO;
   }
-  if (((_values[0] != nil) != (other->_values[0] != nil)) ||
-      ((_values[1] != nil) != (other->_values[1] != nil))) {
+  GPBBoolObjectDictionary *otherDictionary = other;
+  if (((_values[0] != nil) != (otherDictionary->_values[0] != nil)) ||
+      ((_values[1] != nil) != (otherDictionary->_values[1] != nil))) {
     return NO;
   }
-  if (((_values[0] != nil) && (![_values[0] isEqual:other->_values[0]])) ||
-      ((_values[1] != nil) && (![_values[1] isEqual:other->_values[1]]))) {
+  if (((_values[0] != nil) && (![_values[0] isEqual:otherDictionary->_values[0]])) ||
+      ((_values[1] != nil) && (![_values[1] isEqual:otherDictionary->_values[1]]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return ((_values[0] != nil) ? 1 : 0) + ((_values[1] != nil) ? 1 : 0);
 }
 
 - (NSString *)description {
@@ skipping 257 matching lines @@
            @"%@: Autocreator must be cleared before release, autocreator: %@",
            [self class], _autocreator);
   [super dealloc];
 }
 #endif  // !defined(NS_BLOCK_ASSERTIONS)
 
 - (instancetype)copyWithZone:(NSZone *)zone {
   return [[GPBBoolEnumDictionary allocWithZone:zone] initWithDictionary:self];
 }
 
-- (BOOL)isEqual:(GPBBoolEnumDictionary *)other {
+- (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
   if (![other isKindOfClass:[GPBBoolEnumDictionary class]]) {
     return NO;
   }
-  if ((_valueSet[0] != other->_valueSet[0]) ||
-      (_valueSet[1] != other->_valueSet[1])) {
+  GPBBoolEnumDictionary *otherDictionary = other;
+  if ((_valueSet[0] != otherDictionary->_valueSet[0]) ||
+      (_valueSet[1] != otherDictionary->_valueSet[1])) {
     return NO;
   }
-  if ((_valueSet[0] && (_values[0] != other->_values[0])) ||
-      (_valueSet[1] && (_values[1] != other->_values[1]))) {
+  if ((_valueSet[0] && (_values[0] != otherDictionary->_values[0])) ||
+      (_valueSet[1] && (_values[1] != otherDictionary->_values[1]))) {
     return NO;
   }
   return YES;
 }
 
 - (NSUInteger)hash {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
 - (NSString *)description {
   NSMutableString *result = [NSMutableString stringWithFormat:@"<%@ %p> {", [self class], self];
   if (_valueSet[0]) {
     [result appendFormat:@"NO: %d", _values[0]];
   }
   if (_valueSet[1]) {
     [result appendFormat:@"YES: %d", _values[1]];
   }
   [result appendString:@" }"];
   return result;
 }
 
 - (NSUInteger)count {
   return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0);
 }
 
-- (BOOL)valueForKey:(BOOL)key value:(int32_t*)value {
+- (BOOL)getEnum:(int32_t*)value forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (value) {
       int32_t result = _values[idx];
       if (!_validationFunc(result)) {
         result = kGPBUnrecognizedEnumeratorValue;
       }
       *value = result;
     }
     return YES;
   }
   return NO;
 }
 
-- (BOOL)valueForKey:(BOOL)key rawValue:(int32_t*)rawValue {
+- (BOOL)getRawValue:(int32_t*)rawValue forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   if (_valueSet[idx]) {
     if (rawValue) {
       *rawValue = _values[idx];
     }
     return YES;
   }
   return NO;
 }
 
-- (void)enumerateKeysAndValuesUsingBlock:
+- (void)enumerateKeysAndRawValuesUsingBlock:
     (void (^)(BOOL key, int32_t value, BOOL *stop))block {
   BOOL stop = NO;
   if (_valueSet[0]) {
     block(NO, _values[0], &stop);
   }
   if (!stop && _valueSet[1]) {
     block(YES, _values[1], &stop);
   }
 }
 
-- (void)enumerateKeysAndRawValuesUsingBlock:
+- (void)enumerateKeysAndEnumsUsingBlock:
     (void (^)(BOOL key, int32_t rawValue, BOOL *stop))block {
   BOOL stop = NO;
   GPBEnumValidationFunc func = _validationFunc;
   int32_t validatedValue;
   if (_valueSet[0]) {
     validatedValue = _values[0];
     if (!func(validatedValue)) {
       validatedValue = kGPBUnrecognizedEnumeratorValue;
     }
     block(NO, validatedValue, &stop);
@@ skipping 84 matching lines @@
         _valueSet[i] = YES;
         _values[i] = otherDictionary->_values[i];
       }
     }
     if (_autocreator) {
       GPBAutocreatedDictionaryModified(_autocreator, self);
     }
   }
 }
 
-- (void)setValue:(int32_t)value forKey:(BOOL)key {
+- (void)setEnum:(int32_t)value forKey:(BOOL)key {
   if (!_validationFunc(value)) {
     [NSException raise:NSInvalidArgumentException
                 format:@"GPBBoolEnumDictionary: Attempt to set an unknown enum value (%d)",
      value];
   }
   int idx = (key ? 1 : 0);
   _values[idx] = value;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
 - (void)setRawValue:(int32_t)rawValue forKey:(BOOL)key {
   int idx = (key ? 1 : 0);
   _values[idx] = rawValue;
   _valueSet[idx] = YES;
   if (_autocreator) {
     GPBAutocreatedDictionaryModified(_autocreator, self);
   }
 }
 
-- (void)removeValueForKey:(BOOL)aKey {
+- (void)removeEnumForKey:(BOOL)aKey {
   _valueSet[aKey ? 1 : 0] = NO;
 }
 
 - (void)removeAll {
   _valueSet[0] = NO;
   _valueSet[1] = NO;
 }
 
 @end
 
@@ skipping 96 matching lines @@
 }
 
 - (void)enumerateKeysAndObjectsWithOptions:(NSEnumerationOptions)opts
                                 usingBlock:(void (^)(id key,
                                                      id obj,
                                                      BOOL *stop))block {
   [_dictionary enumerateKeysAndObjectsWithOptions:opts usingBlock:block];
 }
 
 @end
+
+#pragma clang diagnostic pop