Fix handling of optional dependencies in java generator.

Java reflection is used to fail smoothly when the extensions aren't
found in the classpath.

PiperOrigin-RevId: 802766998

Author: mkruskal-google

java/core/src/main/java/com/google/protobuf/GeneratedFile.java

@@ -0,0 +1,34 @@
+package com.google.protobuf;
+
+/**
+ * All generated outer classes extend this class. This class implements shared logic that should
+ * only be called by generated code.
+ *
+ * <p>Users should generally ignore this class and use the generated Outer class directly instead.
+ *
+ * <p>This class is intended to only be extended by protoc created gencode. It is not intended or
+ * supported to extend this class, and any protected methods may be removed without it being
+ * considered a breaking change as long as all supported gencode does not depend on the changed
+ * methods.
+ */
+public abstract class GeneratedFile {
+
+  protected GeneratedFile() {}
+
+  /** Add an optional extension from a file that may or may not be in the classpath. */
+  protected static void addOptionalExtension(
+      ExtensionRegistry registry, final String className, final String fieldName) {
+    try {
+      GeneratedMessage.GeneratedExtension<?, ?> ext =
+          (GeneratedMessage.GeneratedExtension<?, ?>)
+              Class.forName(className).getField(fieldName).get(null);
+      registry.add(ext);
+    } catch (ClassNotFoundException e) {
+      // ignore missing class if it's not in the classpath.
+    } catch (NoSuchFieldException e) {
+      // ignore missing field if it's not in the classpath.
+    } catch (IllegalAccessException e) {
+      // ignore malformed field if it's not what we expect.
+    }
+  }
+}

java/core/src/test/java/com/google/protobuf/ImportOptionTest.java

@@ -18,9 +18,6 @@ public final class ImportOptionTest {
 
   @Test
   public void testImportOption() throws Exception {
-    // Ensure that UnittestCustomOptions is linked in and referenced.
-    FileDescriptor unused = UnittestCustomOptions.getDescriptor();
-
     FileDescriptor fileDescriptor = UnittestImportOptionProto.getDescriptor();
     Descriptor messageDescriptor = TestMessage.getDescriptor();
     FieldDescriptor fieldDescriptor = messageDescriptor.findFieldByName("field1");
@@ -29,26 +26,15 @@ public void testImportOption() throws Exception {
     UnknownFieldSet unknownFieldsMessage = messageDescriptor.getOptions().getUnknownFields();
     UnknownFieldSet unknownFieldsField = fieldDescriptor.getOptions().getUnknownFields();
 
-    // TODO: Currently linked in options also end up in unknown fields.
-    // TODO: Exclude for open source tests once linked in options are treated
-    // differently, since `option_deps` are treated as `deps` in Bazel 7.
-    // assertThat(fileDescriptor.getOptions().getExtension(UnittestCustomOptions.fileOpt1))
-    //     .isEqualTo(1);
-    // assertThat(messageDescriptor.getOptions().getExtension(UnittestCustomOptions.messageOpt1))
-    //     .isEqualTo(2);
-    // assertThat(fieldDescriptor.getOptions().getExtension(UnittestCustomOptions.fieldOpt1))
-    //     .isEqualTo(3);
-    assertThat(unknownFieldsFile.getField(7736974).getVarintList()).containsExactly(1L);
-    assertThat(unknownFieldsMessage.getField(7739036).getVarintList()).containsExactly(2L);
-    assertThat(unknownFieldsField.getField(7740936).getFixed64List()).containsExactly(3L);
-
-    // Options from import option that are not linked in should be in unknown fields.
-    assertThat(unknownFieldsFile.getField(7736975).getVarintList()).containsExactly(1L);
-    assertThat(unknownFieldsMessage.getField(7739037).getVarintList()).containsExactly(2L);
-    assertThat(unknownFieldsField.getField(7740937).getFixed64List()).containsExactly(3L);
+    assertThat(fileDescriptor.getOptions().getExtension(UnittestCustomOptions.fileOpt1))
+        .isEqualTo(1);
+    assertThat(messageDescriptor.getOptions().getExtension(UnittestCustomOptions.messageOpt1))
+        .isEqualTo(2);
+    assertThat(fieldDescriptor.getOptions().getExtension(UnittestCustomOptions.fieldOpt1))
+        .isEqualTo(3);
 
-    assertThat(unknownFieldsFile.asMap()).hasSize(2);
-    assertThat(unknownFieldsMessage.asMap()).hasSize(2);
-    assertThat(unknownFieldsField.asMap()).hasSize(2);
+    // TODO: Since `option_deps` are treated as `deps` in Bazel 7, the unknown
+    // fields are not empty.  Once we drop Bazel 7 support we can test that these are filled with
+    // unknown fields.
   }
 }

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

@@ -31,6 +31,7 @@
 #include "google/protobuf/compiler/java/internal_helpers.h"
 #include "google/protobuf/compiler/java/lite/generator_factory.h"
 #include "google/protobuf/compiler/java/name_resolver.h"
+#include "google/protobuf/compiler/java/names.h"
 #include "google/protobuf/compiler/java/options.h"
 #include "google/protobuf/compiler/java/shared_code_generator.h"
 #include "google/protobuf/compiler/retention.h"
@@ -116,8 +117,9 @@ void CollectPublicDependencies(
 
 // Finds all extensions for custom options in the given file descriptor with the
 // builder pool which resolves Java features instead of the generated pool.
-void CollectExtensions(const FileDescriptor& file,
-                       FieldDescriptorSet* extensions) {
+void CollectExtensions(const FileDescriptor& file, const Options& options,
+                       FieldDescriptorSet* extensions,
+                       FieldDescriptorSet* optional_extensions) {
   FileDescriptorProto file_proto = StripSourceRetentionOptions(file);
   std::string file_data;
   file_proto.SerializeToString(&file_data);
@@ -139,15 +141,27 @@ void CollectExtensions(const FileDescriptor& file,
   // Unknown extensions are ok and expected in the case of option imports.
   CollectExtensions(*dynamic_file_proto, extensions);
 
-  // TODO Check against dependencies to remove option dependencies
-  // polluting the pool.  These will be handled as optional dependencies.
+  if (options.strip_nonfunctional_codegen) {
+    // Skip feature extensions, which are a visible (but non-functional)
+    // deviation between editions and legacy syntax.
+    absl::erase_if(*extensions, [](const FieldDescriptor* field) {
+      return field->containing_type()->full_name() == "google.protobuf.FeatureSet";
+    });
+  }
+
+  // Check against dependencies to handle option dependencies polluting pool.
   absl::flat_hash_set<const FileDescriptor*> dependencies;
   dependencies.insert(&file);
   for (int i = 0; i < file.dependency_count(); i++) {
     CollectPublicDependencies(file.dependency(i), &dependencies);
   }
+  for (auto* extension : *extensions) {
+    if (!dependencies.contains(extension->file())) {
+      optional_extensions->insert(extension);
+    }
+  }
   absl::erase_if(*extensions, [&](const FieldDescriptor* fieldDescriptor) {
-    return !dependencies.contains(fieldDescriptor->file());
+    return optional_extensions->contains(fieldDescriptor);
   });
 }
 
@@ -325,11 +339,14 @@ void FileGenerator::Generate(io::Printer* printer) {
     printer->Print("@com.google.protobuf.Internal.ProtoNonnullApi\n");
   }
   printer->Print(
-      "$deprecation$public final class $classname$ {\n"
+      "$deprecation$public final class $classname$ $extends${\n"
       "  private $ctor$() {}\n",
       "deprecation",
       file_->options().deprecated() ? "@java.lang.Deprecated " : "",
-      "classname", classname_, "ctor", classname_);
+      "classname", classname_, "ctor", classname_, "extends",
+      HasDescriptorMethods(file_, context_->EnforceLite())
+          ? "extends com.google.protobuf.GeneratedFile "
+          : "");
   printer->Annotate("classname", file_->name());
   printer->Indent();
 
@@ -507,15 +524,8 @@ void FileGenerator::GenerateDescriptorInitializationCodeForImmutable(
   // of the FileDescriptor based on the builder-pool, then we can use
   // reflections to find all extension fields
   FieldDescriptorSet extensions;
-  CollectExtensions(*file_, &extensions);
-
-  if (options_.strip_nonfunctional_codegen) {
-    // Skip feature extensions, which are a visible (but non-functional)
-    // deviation between editions and legacy syntax.
-    absl::erase_if(extensions, [](const FieldDescriptor* field) {
-      return field->containing_type()->full_name() == "google.protobuf.FeatureSet";
-    });
-  }
+  FieldDescriptorSet optional_extensions;
+  CollectExtensions(*file_, options_, &extensions, &optional_extensions);
 
   // Force descriptor initialization of all dependencies.
   for (int i = 0; i < file_->dependency_count(); i++) {
@@ -527,7 +537,7 @@ void FileGenerator::GenerateDescriptorInitializationCodeForImmutable(
     }
   }
 
-  if (!extensions.empty()) {
+  if (!extensions.empty() || !optional_extensions.empty()) {
     // Must construct an ExtensionRegistry containing all existing extensions
     // and use it to parse the descriptor data again to recognize extensions.
     printer->Print(
@@ -544,6 +554,25 @@ void FileGenerator::GenerateDescriptorInitializationCodeForImmutable(
           "private static void _clinit_autosplit_dinit_$method_num$(\n"
           "    com.google.protobuf.ExtensionRegistry registry) {\n");
     }
+    for (const FieldDescriptor* field : optional_extensions) {
+      std::unique_ptr<ExtensionGenerator> generator(
+          generator_factory_->NewExtensionGenerator(field));
+      printer->Emit({{"scope", field->extension_scope() != nullptr
+                                   ? name_resolver_->GetImmutableClassName(
+                                         field->extension_scope())
+                                   : name_resolver_->GetImmutableClassName(
+                                         field->file())},
+                     {"name", UnderscoresToCamelCaseCheckReserved(field)}},
+                    R"java(
+                      addOptionalExtension(registry, "$scope$", "$name$");
+                    )java");
+      bytecode_estimate += 8;
+      MaybeRestartJavaMethod(
+          printer, &bytecode_estimate, &method_num,
+          "_clinit_autosplit_dinit_$method_num$(registry);\n",
+          "private static void _clinit_autosplit_dinit_$method_num$(\n"
+          "    com.google.protobuf.ExtensionRegistry registry) {\n");
+    }
     printer->Print(
         "com.google.protobuf.Descriptors.FileDescriptor\n"
         "    .internalUpdateFileDescriptor(descriptor, registry);\n");

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

@@ -17,11 +17,11 @@
 #include <vector>
 
 #include "google/protobuf/compiler/java/options.h"
+#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/port.h"
 
 namespace google {
 namespace protobuf {
-class FileDescriptor;  // descriptor.h
 namespace io {
 class Printer;  // printer.h
 }
@@ -75,6 +75,7 @@ class FileGenerator {
   bool ShouldIncludeDependency(const FileDescriptor* descriptor,
                                bool immutable_api_);
 
+
   const FileDescriptor* file_;
   std::string java_package_;
   std::string classname_;