Add kotlin/native-compatible map support, gated by the generate properties option.

stefanhaustein · copybara-github · commit a804c3b39c88 · 2025-04-10T01:47:08.000-07:00
Also adjust the generic field type for "fieldNameList" property NSArray access to repeated fields.

PiperOrigin-RevId: 745923366
diff --git a/protobuf/compiler/src/google/protobuf/compiler/j2objc/j2objc_field.cc b/protobuf/compiler/src/google/protobuf/compiler/j2objc/j2objc_field.cc
@@ -94,6 +94,25 @@ std::string GetStorageType(const FieldDescriptor* descriptor) {
   }
 }
 
+std::string GetGenericType(const FieldDescriptor* descriptor) {
+  switch (GetJavaType(descriptor)) {
+    case JAVATYPE_INT:
+    case JAVATYPE_LONG:
+    case JAVATYPE_FLOAT:
+    case JAVATYPE_DOUBLE:
+    case JAVATYPE_BOOLEAN:
+      return "NSNumber *";
+    case JAVATYPE_STRING:
+      return "NSString *";
+    case JAVATYPE_BYTES:
+      return "ComGoogleProtobufByteString *";
+    case JAVATYPE_ENUM:
+      return ClassName(descriptor->enum_type()) + " *";
+    case JAVATYPE_MESSAGE:
+      return ClassName(descriptor->message_type()) + " *";
+  }
+}
+
 std::string GetNonNullType(const FieldDescriptor* descriptor) {
   switch (GetJavaType(descriptor)) {
     case JAVATYPE_INT:
@@ -136,6 +155,7 @@ void SetCommonFieldVariables(const FieldDescriptor* descriptor,
   (*variables)["parameter_type"] = GetParameterType(descriptor);
   (*variables)["storage_type"] = GetStorageType(descriptor);
   (*variables)["nonnull_type"] = GetNonNullType(descriptor);
+  (*variables)["generic_type"] = GetGenericType(descriptor);
   (*variables)["field_name"] = GetFieldName(descriptor);
   (*variables)["flags"] = GetFieldFlags(descriptor);
   (*variables)["field_type"] = GetFieldTypeEnumValue(descriptor);
@@ -426,7 +446,7 @@ void RepeatedFieldGenerator::GenerateMessageOrBuilderProtocol(
         "@property (readonly, getter=Get$capitalized_name$Count)"
         " jint $camelcase_name$Count;\n"
         "@property (readonly, getter=Get$capitalized_name$Array)"
-        " NSArray<$storage_type$> *$camelcase_name$List;\n"
+        " NSArray<$generic_type$> *$camelcase_name$List;\n"
         "- ($nonnull_type$)get$capitalized_name$Index:(int)index;\n");
   }
 }
@@ -466,8 +486,10 @@ MapFieldGenerator::MapFieldGenerator(
   value_field_ = entry_message->FindFieldByName("value");
 
   variables_["key_storage_type"] = GetStorageType(key_field_);
+  variables_["key_generic_type"] = GetStorageType(key_field_);
   variables_["key_parameter_type"] = GetParameterType(key_field_);
   variables_["key_descriptor_type"] = GetFieldTypeEnumValue(key_field_);
+  variables_["value_generic_type"] = GetGenericType(value_field_);
   variables_["value_nonnull_type"] = GetNonNullType(value_field_);
   variables_["value_parameter_type"] = GetParameterType(value_field_);
   variables_["value_descriptor_type"] = GetFieldTypeEnumValue(value_field_);
@@ -501,6 +523,31 @@ void MapFieldGenerator::GenerateFieldBuilderHeader(io::Printer* printer) const {
                  "*)put$capitalized_name$With$key_parameter_type$:"
                  "($key_storage_type$)key with$value_parameter_type$:"
                  "($value_nonnull_type$)value;\n");
+  
+  if (IsGenerateProperties(descriptor_->file())) {
+    printer->Print(
+        variables_,
+        "- (nonnull $classname$_Builder *)put$capitalized_name$:"
+        "($key_nonnull_type$)key value:($value_nonnull_type$)value;\n");
+  }
+}
+
+void MapFieldGenerator::GenerateFieldSource(io::Printer* printer) const {
+  if (IsGenerateProperties(descriptor_->file())) {
+    printer->Print(
+        variables_,
+        "\n"
+        "@dynamic $camelcase_name$Map;\n");
+  }
+}
+
+void MapFieldGenerator::GenerateFieldBuilderSource(io::Printer* printer) const {
+  if (IsGenerateProperties(descriptor_->file())) {
+    printer->Print(
+      variables_,
+      "\n"
+      "@dynamic $camelcase_name$Map;\n");
+  }
 }
 
 void MapFieldGenerator::GenerateMessageOrBuilderProtocol(
@@ -518,6 +565,14 @@ void MapFieldGenerator::GenerateMessageOrBuilderProtocol(
       "with$value_parameter_type$:($value_nonnull_type$)defaultValue;\n"
       "- ($value_nonnull_type$)get$capitalized_name$OrThrowWith"
       "$key_parameter_type$:($key_storage_type$)key;\n");
+  
+  if (IsGenerateProperties(descriptor_->file())) {
+    printer->Print(
+        variables_,
+        "@property (readonly, getter=Get$capitalized_name$Dict)"
+        " NSDictionary<$key_generic_type$, $value_generic_type$>"
+        " *$camelcase_name$Map;\n");
+  }
   // clang-format on
 }
 
diff --git a/protobuf/compiler/src/google/protobuf/compiler/j2objc/j2objc_field.h b/protobuf/compiler/src/google/protobuf/compiler/j2objc/j2objc_field.h
@@ -143,7 +143,9 @@ class MapFieldGenerator : public FieldGenerator {
 
   virtual ~MapFieldGenerator() { }
 
+  virtual void GenerateFieldSource(io::Printer* printer) const;
   virtual void GenerateFieldBuilderHeader(io::Printer* printer) const;
+  virtual void GenerateFieldBuilderSource(io::Printer* printer) const;
   virtual void GenerateMessageOrBuilderProtocol(io::Printer* printer) const;
   virtual void GenerateDeclaration(io::Printer* printer) const;
   virtual void GenerateMapEntryFieldData(io::Printer *printer) const;
diff --git a/protobuf/runtime/src/com/google/protobuf/GeneratedMessage.mm b/protobuf/runtime/src/com/google/protobuf/GeneratedMessage.mm
@@ -466,6 +466,16 @@ static BOOL AddMapGetterMethod(Class cls, SEL sel, CGPFieldDescriptor *field) {
   return class_addMethod(cls, sel, imp, "@@:");
 }
 
+static BOOL AddDictGetterMethod(Class cls, SEL sel, CGPFieldDescriptor *field) {
+  size_t offset = CGPFieldGetOffset(field, cls);
+  CGPFieldJavaType keyType = CGPFieldGetJavaType(CGPFieldMapKey(field));
+  CGPFieldJavaType valueType = CGPFieldGetJavaType(CGPFieldMapValue(field));
+  IMP imp = imp_implementationWithBlock(^id(id msg) {
+    return CGPMapFieldAsDict(MAP_FIELD_PTR(msg, offset), keyType, valueType);
+  });
+  return class_addMethod(cls, sel, imp, "@@:");
+}
+
 static BOOL AddClearMethod(Class cls, SEL sel, CGPFieldDescriptor *field) {
   IMP imp;
   size_t offset = CGPFieldGetOffset(field, cls);
@@ -1066,12 +1076,14 @@ static BOOL ResolveGetAccessor(Class cls, CGPDescriptor *descriptor, SEL sel, co
         return AddCountMethod(cls, sel, field);
       } else if (MatchesEnd(tail, "Map")) {
         return AddMapGetterMethod(cls, sel, field);
-      } else if (Matches(&tail, "OrThrowWith", 11)
-          && MatchesKeyword(&tail, CGPFieldMapKey(field)) && MatchesEnd(tail, ":")) {
+      } else if (MatchesEnd(tail, "Dict")) {
+        return AddDictGetterMethod(cls, sel, field);
+      } else if (Matches(&tail, "OrThrowWith", 11) &&
+                 MatchesKeyword(&tail, CGPFieldMapKey(field)) && MatchesEnd(tail, ":")) {
         return AddMapGetWithKeyMethod(cls, sel, field, false);
-      } else if (Matches(&tail2, "OrDefaultWith", 13)
-          && MatchesKeyword(&tail2, CGPFieldMapKey(field)) && Matches(&tail2, ":with", 5)
-          && MatchesKeyword(&tail2, CGPFieldMapValue(field)) && MatchesEnd(tail2, ":")) {
+      } else if (Matches(&tail2, "OrDefaultWith", 13) &&
+                 MatchesKeyword(&tail2, CGPFieldMapKey(field)) && Matches(&tail2, ":with", 5) &&
+                 MatchesKeyword(&tail2, CGPFieldMapValue(field)) && MatchesEnd(tail2, ":")) {
         return AddMapGetWithKeyMethod(cls, sel, field, true);
       }
     } else if (CGPFieldIsRepeated(field)) {
@@ -1216,10 +1228,15 @@ static BOOL ResolvePutAccessor(Class cls, CGPDescriptor *descriptor, SEL sel, co
   for (NSUInteger i = 0; i < count; ++i) {
     CGPFieldDescriptor *field = fieldsBuf[i];
     const char *tail = selName;
-    if (CGPFieldIsMap(field) && MatchesName(&tail, field) && Matches(&tail, "With", 4)
-        && MatchesKeyword(&tail, CGPFieldMapKey(field)) && Matches(&tail, ":with", 5)
-        && MatchesKeyword(&tail, CGPFieldMapValue(field)) && MatchesEnd(tail, ":")) {
-      return AddPutMethod(cls, sel, field);
+    if (CGPFieldIsMap(field) && MatchesName(&tail, field)) {
+      if (Matches(&tail, "With", 4) && MatchesKeyword(&tail, CGPFieldMapKey(field)) &&
+          Matches(&tail, ":with", 5) && MatchesKeyword(&tail, CGPFieldMapValue(field)) &&
+          MatchesEnd(tail, ":")) {
+        return AddPutMethod(cls, sel, field);
+      }
+      if (Matches(&tail, ":value", 6) && MatchesEnd(tail, ":")) {
+        return AddPutMethod(cls, sel, field);
+      }
     }
   }
   return NO;
diff --git a/protobuf/runtime/src/com/google/protobuf/MapField.h b/protobuf/runtime/src/com/google/protobuf/MapField.h
@@ -141,6 +141,9 @@ void CGPMapFieldAssignFromList(
 id<JavaUtilMap> CGPMapFieldAsJavaMap(
     CGPMapField *field, CGPFieldJavaType keyType, CGPFieldJavaType valueType);
 
+NSDictionary *CGPMapFieldAsDict(CGPMapField *field, CGPFieldJavaType keyType,
+                                CGPFieldJavaType valueType);
+
 CF_EXTERN_C_END
 
 #endif // __ComGoogleProtobufMapField_H__
diff --git a/protobuf/runtime/src/com/google/protobuf/MapField.m b/protobuf/runtime/src/com/google/protobuf/MapField.m
@@ -677,6 +677,18 @@ @interface CGPMapFieldMap : JavaUtilAbstractMap {
   return map;
 }
 
+NSDictionary *CGPMapFieldAsDict(CGPMapField *field, CGPFieldJavaType keyType,
+                                CGPFieldJavaType valueType) {
+  id<JavaUtilMap> map = CGPMapFieldAsJavaMap(field, keyType, valueType);
+  // Alternatively, we could use a NSDict subclass here, similar to the "Java" map impl,
+  // avoiding the copy -- or copy the underlying data from the underlying data structures directly.
+  NSMutableDictionary *result = [[NSMutableDictionary alloc] init];
+  for (id entry in map.entrySet) {
+    result[[entry getKey]] = [entry getValue];
+  }
+  return result;
+}
+
 @interface CGPMapFieldEntrySet : JavaUtilAbstractSet {
  @package
   CGPMapFieldMap *map_;
