[ObjC] Add generation control for descriptor custom options.

There is a new boolean ObjC Generator Option called
`strip_custom_options` that defaults to `True` that causes all
extensions for the descriptor custom options to not generated.
See https://protobuf.dev/programming-guides/proto2/#customoptions
for more information on these. Since the ObjC runtime doesn't
capture this data, we're not aware of any reason they would be need.
If you do enable this option, please open an issue and let us know
as we'd rather remove this option and have this be the only
behavior.

PiperOrigin-RevId: 556805883

Author: thomasvl

src/google/protobuf/compiler/objectivec/field.cc

@@ -30,6 +30,7 @@
 
 #include "google/protobuf/compiler/objectivec/field.h"
 
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -447,16 +448,10 @@ void RepeatedFieldGenerator::EmitArrayComment(io::Printer* printer) const {
 
 FieldGeneratorMap::FieldGeneratorMap(const Descriptor* descriptor)
     : descriptor_(descriptor),
-      field_generators_(descriptor->field_count()),
-      extension_generators_(descriptor->extension_count()) {
-  // Construct all the FieldGenerators.
+      field_generators_(static_cast<size_t>(descriptor->field_count())) {
   for (int i = 0; i < descriptor->field_count(); i++) {
     field_generators_[i].reset(FieldGenerator::Make(descriptor->field(i)));
   }
-  for (int i = 0; i < descriptor->extension_count(); i++) {
-    extension_generators_[i].reset(
-        FieldGenerator::Make(descriptor->extension(i)));
-  }
 }
 
 const FieldGenerator& FieldGeneratorMap::get(
@@ -465,10 +460,6 @@ const FieldGenerator& FieldGeneratorMap::get(
   return *field_generators_[field->index()];
 }
 
-const FieldGenerator& FieldGeneratorMap::get_extension(int index) const {
-  return *extension_generators_[index];
-}
-
 int FieldGeneratorMap::CalculateHasBits() {
   int total_bits = 0;
   for (int i = 0; i < descriptor_->field_count(); i++) {

src/google/protobuf/compiler/objectivec/field.h

@@ -172,7 +172,6 @@ class FieldGeneratorMap {
   FieldGeneratorMap& operator=(const FieldGeneratorMap&) = delete;
 
   const FieldGenerator& get(const FieldDescriptor* field) const;
-  const FieldGenerator& get_extension(int index) const;
 
   // Assigns the has bits and returns the number of bits needed.
   int CalculateHasBits();
@@ -185,7 +184,6 @@ class FieldGeneratorMap {
  private:
   const Descriptor* descriptor_;
   std::vector<std::unique_ptr<FieldGenerator>> field_generators_;
-  std::vector<std::unique_ptr<FieldGenerator>> extension_generators_;
 };
 
 }  // namespace objectivec

src/google/protobuf/compiler/objectivec/file.cc

@@ -31,6 +31,8 @@
 #include "google/protobuf/compiler/objectivec/file.h"
 
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <iterator>
 #include <memory>
@@ -44,9 +46,11 @@
 #include "absl/strings/str_join.h"
 #include "google/protobuf/compiler/objectivec/enum.h"
 #include "google/protobuf/compiler/objectivec/extension.h"
+#include "google/protobuf/compiler/objectivec/helpers.h"
 #include "google/protobuf/compiler/objectivec/import_writer.h"
 #include "google/protobuf/compiler/objectivec/message.h"
 #include "google/protobuf/compiler/objectivec/names.h"
+#include "google/protobuf/compiler/objectivec/options.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/descriptor_legacy.h"
@@ -64,28 +68,48 @@ const int32_t GOOGLE_PROTOBUF_OBJC_VERSION = 30007;
 
 const char* kHeaderExtension = ".pbobjc.h";
 
-// Checks if a message contains any extension definitions (on the message or
-// a nested message under it).
-bool MessageContainsExtensions(const Descriptor* message) {
+// Checks if a message contains extension definitions (on the message or
+// a nested message under it). `include_custom_options` decides if custom
+// options count as extensions.
+bool MessageContainsExtensions(const Descriptor* message,
+                               bool include_custom_options) {
   if (message->extension_count() > 0) {
-    return true;
+    if (include_custom_options) {
+      return true;
+    }
+    for (int i = 0; i < message->extension_count(); i++) {
+      if (!ExtensionIsCustomOption(message->extension(i))) {
+        return true;
+      }
+    }
   }
   for (int i = 0; i < message->nested_type_count(); i++) {
-    if (MessageContainsExtensions(message->nested_type(i))) {
+    if (MessageContainsExtensions(message->nested_type(i),
+                                  include_custom_options)) {
       return true;
     }
   }
   return false;
 }
 
-// Checks if the file contains any extensions definitions (at the root or
-// nested under a message).
-bool FileContainsExtensions(const FileDescriptor* file) {
+// Checks if the file contains extensions definitions (at the root or
+// nested under a message). `include_custom_options` decides if custom
+// options count as extensions.
+bool FileContainsExtensions(const FileDescriptor* file,
+                            bool include_custom_options) {
   if (file->extension_count() > 0) {
-    return true;
+    if (include_custom_options) {
+      return true;
+    }
+    for (int i = 0; i < file->extension_count(); i++) {
+      if (!ExtensionIsCustomOption(file->extension(i))) {
+        return true;
+      }
+    }
   }
   for (int i = 0; i < file->message_type_count(); i++) {
-    if (MessageContainsExtensions(file->message_type(i))) {
+    if (MessageContainsExtensions(file->message_type(i),
+                                  include_custom_options)) {
       return true;
     }
   }
@@ -112,17 +136,20 @@ void MakeDescriptors(
     const Descriptor* descriptor, const std::string& file_description_name,
     std::vector<std::unique_ptr<EnumGenerator>>* enum_generators,
     std::vector<std::unique_ptr<ExtensionGenerator>>* extension_generators,
-    std::vector<std::unique_ptr<MessageGenerator>>* message_generators) {
+    std::vector<std::unique_ptr<MessageGenerator>>* message_generators,
+    bool strip_custom_options) {
   for (int i = 0; i < descriptor->enum_type_count(); i++) {
     enum_generators->emplace_back(
         std::make_unique<EnumGenerator>(descriptor->enum_type(i)));
   }
   for (int i = 0; i < descriptor->nested_type_count(); i++) {
     message_generators->emplace_back(std::make_unique<MessageGenerator>(
         file_description_name, descriptor->nested_type(i)));
-    message_generators->back()->AddExtensionGenerators(extension_generators);
+    message_generators->back()->AddExtensionGenerators(extension_generators,
+                                                       strip_custom_options);
     MakeDescriptors(descriptor->nested_type(i), file_description_name,
-                    enum_generators, extension_generators, message_generators);
+                    enum_generators, extension_generators, message_generators,
+                    strip_custom_options);
   }
 }
 
@@ -184,7 +211,8 @@ FileGenerator::CommonState::CollectMinimalFileDepsContainingExtensionsInternal(
     }
   }
 
-  const bool file_has_exts = FileContainsExtensions(file);
+  const bool file_has_exts =
+      FileContainsExtensions(file, include_custom_options);
 
   // Fast path: if nothing to prune or there was only one dep, the prune work is
   // a waste, skip it.
@@ -241,16 +269,23 @@ FileGenerator::FileGenerator(const FileDescriptor* file,
         std::make_unique<EnumGenerator>(file_->enum_type(i)));
   }
   for (int i = 0; i < file_->extension_count(); i++) {
-    extension_generators_.push_back(std::make_unique<ExtensionGenerator>(
-        root_class_name_, file_->extension(i)));
+    const FieldDescriptor* extension = file_->extension(i);
+    if (!generation_options.strip_custom_options ||
+        !ExtensionIsCustomOption(extension)) {
+      extension_generators_.push_back(
+          std::make_unique<ExtensionGenerator>(root_class_name_, extension));
+    }
   }
+  file_scoped_extension_count_ = extension_generators_.size();
   for (int i = 0; i < file_->message_type_count(); i++) {
     message_generators_.emplace_back(std::make_unique<MessageGenerator>(
         file_description_name_, file_->message_type(i)));
-    message_generators_.back()->AddExtensionGenerators(&extension_generators_);
+    message_generators_.back()->AddExtensionGenerators(
+        &extension_generators_, generation_options.strip_custom_options);
     MakeDescriptors(file_->message_type(i), file_description_name_,
                     &enum_generators_, &extension_generators_,
-                    &message_generators_);
+                    &message_generators_,
+                    generation_options.strip_custom_options);
   }
 }
 
@@ -298,17 +333,17 @@ void FileGenerator::GenerateHeader(io::Printer* p) const {
 
     // The dynamic methods block is only needed if there are extensions that are
     // file level scoped (not message scoped). The first
-    // file_->extension_count() of extension_generators_ are the file scoped
+    // file_scoped_extension_count_ of extension_generators_ are the file scoped
     // ones.
-    if (file_->extension_count()) {
+    if (file_scoped_extension_count_) {
       p->Emit("@interface $root_class_name$ (DynamicMethods)\n");
 
-      for (int i = 0; i < file_->extension_count(); i++) {
+      for (size_t i = 0; i < file_scoped_extension_count_; i++) {
         extension_generators_[i]->GenerateMembersHeader(p);
       }
 
       p->Emit("@end\n\n");
-    }  // file_->extension_count()
+    }
 
     for (const auto& generator : message_generators_) {
       generator->GenerateMessageHeader(p);

src/google/protobuf/compiler/objectivec/file.h

@@ -31,6 +31,7 @@
 #ifndef GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_FILE_H__
 #define GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_FILE_H__
 
+#include <cstddef>
 #include <functional>
 #include <memory>
 #include <string>
@@ -55,7 +56,10 @@ class FileGenerator {
   // Wrapper for some common state that is shared between file generations to
   // improve performance when more than one file is generated at a time.
   struct CommonState {
-    CommonState() = default;
+    // `include_custom_options` will cause any custom options to be included
+    // in the calculations around files defining extensions.
+    explicit CommonState(bool include_custom_options)
+        : include_custom_options(include_custom_options) {}
 
     std::vector<const FileDescriptor*>
     CollectMinimalFileDepsContainingExtensions(const FileDescriptor* file);
@@ -71,6 +75,7 @@ class FileGenerator {
     const MinDepsEntry& CollectMinimalFileDepsContainingExtensionsInternal(
         const FileDescriptor* file);
     absl::flat_hash_map<const FileDescriptor*, MinDepsEntry> deps_info_cache;
+    const bool include_custom_options;
   };
 
   FileGenerator(const FileDescriptor* file,
@@ -131,7 +136,10 @@ class FileGenerator {
 
   std::vector<std::unique_ptr<EnumGenerator>> enum_generators_;
   std::vector<std::unique_ptr<MessageGenerator>> message_generators_;
-  // The first file_->extension_count() are the extensions at file level scope.
+  // The first file_scoped_extension_count_ are the extensions at file level
+  // scope. This can be less than file_->extension_count() when custom options
+  // are being filtered away.
+  size_t file_scoped_extension_count_;
   std::vector<std::unique_ptr<ExtensionGenerator>> extension_generators_;
 };
 

src/google/protobuf/compiler/objectivec/generator.cc

@@ -30,20 +30,24 @@
 
 #include "google/protobuf/compiler/objectivec/generator.h"
 
+#include <cstddef>
+#include <cstdlib>
 #include <fstream>
-#include <iostream>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "absl/container/flat_hash_set.h"
+#include "absl/memory/memory.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "google/protobuf/compiler/objectivec/file.h"
 #include "google/protobuf/compiler/objectivec/names.h"
+#include "google/protobuf/compiler/objectivec/options.h"
 #include "google/protobuf/io/printer.h"
 #include "google/protobuf/io/zero_copy_stream.h"
 
@@ -258,6 +262,18 @@ bool ObjectiveCGenerator::GenerateAll(
             options[i].second);
         return false;
       }
+    } else if (options[i].first == "strip_custom_options") {
+      // Controls if extensions that define custom options are included the
+      // generated code. Since ObjC protos does not capture these descriptor
+      // options, there normally isn't a need for these extensions. Docs on
+      // custom options:
+      //   https://protobuf.dev/programming-guides/proto2/#customoptions
+      if (!StringToBool(options[i].second,
+                        &generation_options.strip_custom_options)) {
+        *error = absl::StrCat("error: Unknown value for strip_custom_options: ",
+                              options[i].second);
+        return false;
+      }
     } else if (options[i].first == "experimental_multi_source_generation") {
       // This is an experimental option, and could be removed or change at any
       // time; it is not documented in the README.md for that reason.
@@ -314,7 +330,7 @@ bool ObjectiveCGenerator::GenerateAll(
     return false;
   }
 
-  FileGenerator::CommonState state;
+  FileGenerator::CommonState state(!generation_options.strip_custom_options);
   for (const auto& file : files) {
     const FileGenerator file_generator(file, generation_options, state);
     std::string filepath = FilePath(file);

src/google/protobuf/compiler/objectivec/generator.h

@@ -33,6 +33,7 @@
 #ifndef GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
 #define GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
 
+#include <cstdint>
 #include <string>
 #include <vector>
 

src/google/protobuf/compiler/objectivec/helpers.cc

@@ -105,8 +105,15 @@ std::string HandleExtremeFloatingPoint(std::string val, bool add_float_suffix) {
   }
 }
 
+const char* kDescriptorProtoName = "google/protobuf/descriptor.proto";
+
 }  // namespace
 
+bool ExtensionIsCustomOption(const FieldDescriptor* extension_field) {
+  return extension_field->containing_type()->file()->name() ==
+         kDescriptorProtoName;
+}
+
 std::string GetCapitalizedType(const FieldDescriptor* field) {
   switch (field->type()) {
     case FieldDescriptor::TYPE_INT32:

src/google/protobuf/compiler/objectivec/helpers.h

@@ -36,6 +36,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/io/printer.h"
@@ -48,6 +49,10 @@ namespace objectivec {
 // Escape C++ trigraphs by escaping question marks to "\?".
 std::string EscapeTrigraphs(absl::string_view to_escape);
 
+// Returns true if the extension field is a custom option.
+// https://protobuf.dev/programming-guides/proto2/#customoptions
+bool ExtensionIsCustomOption(const FieldDescriptor* extension_field);
+
 enum ObjectiveCType {
   OBJECTIVECTYPE_INT32,
   OBJECTIVECTYPE_UINT32,

src/google/protobuf/compiler/objectivec/message.cc

@@ -253,11 +253,15 @@ MessageGenerator::MessageGenerator(const std::string& file_description_name,
 }
 
 void MessageGenerator::AddExtensionGenerators(
-    std::vector<std::unique_ptr<ExtensionGenerator>>* extension_generators) {
+    std::vector<std::unique_ptr<ExtensionGenerator>>* extension_generators,
+    bool strip_custom_options) {
   for (int i = 0; i < descriptor_->extension_count(); i++) {
-    extension_generators->push_back(std::make_unique<ExtensionGenerator>(
-        class_name_, descriptor_->extension(i)));
-    extension_generators_.push_back(extension_generators->back().get());
+    const FieldDescriptor* extension = descriptor_->extension(i);
+    if (!strip_custom_options || !ExtensionIsCustomOption(extension)) {
+      extension_generators->push_back(
+          std::make_unique<ExtensionGenerator>(class_name_, extension));
+      extension_generators_.push_back(extension_generators->back().get());
+    }
   }
 }
 
@@ -379,7 +383,7 @@ void MessageGenerator::GenerateMessageHeader(io::Printer* printer) const {
     printer->Emit("\n");
   }
 
-  if (descriptor_->extension_count() > 0) {
+  if (!extension_generators_.empty()) {
     printer->Emit({{"extension_info",
                     [&] {
                       for (const auto* generator : extension_generators_) {
@@ -482,7 +486,7 @@ void MessageGenerator::GenerateSource(io::Printer* printer) const {
           // If the message scopes extensions, trigger the root class
           // +initialize/+extensionRegistry as that is where the
           // runtime support for extensions lives.
-          if (descriptor_->extension_count() > 0) {
+          if (!extension_generators_.empty()) {
             printer->Emit(R"objc(
               // Start up the root class to support the scoped extensions.
               __unused Class rootStartup = [$root_class_name$ class];