google · copybara-service · Oct 20, 2023
diff --git a/protobuf/compiler/src/google/protobuf/compiler/j2objc/j2objc_enum.cc b/protobuf/compiler/src/google/protobuf/compiler/j2objc/j2objc_enum.cc
@@ -33,10 +33,11 @@
 //  Sanjay Ghemawat, Jeff Dean, Cyrus Najmabadi, and others.
 
 #include <google/protobuf/compiler/j2objc/j2objc_enum.h>
+#include <google/protobuf/compiler/j2objc/j2objc_helpers.h>
 
 #include <string>
 
-#include <google/protobuf/compiler/j2objc/j2objc_helpers.h>
+#include "google/protobuf/compiler/j2objc/common.h"
 
 namespace google {
 namespace protobuf {
@@ -66,6 +67,7 @@ EnumGenerator::~EnumGenerator() {
 
 void EnumGenerator::CollectSourceImports(std::set<std::string>* imports) const {
   imports->insert("java/lang/IllegalArgumentException.h");
+  imports->insert("java/lang/IllegalStateException.h");
 }
 
 void EnumGenerator::GenerateHeader(io::Printer* printer) {
@@ -85,6 +87,11 @@ void EnumGenerator::GenerateHeader(io::Printer* printer) {
                      EnumOrdinalName(canonical_values_[i]), "ordinal",
                      SimpleItoa(i));
   }
+  if (!descriptor_->is_closed()) {
+      printer->Print("$ordinalname$_UNRECOGNIZED = $count$,\n", "ordinalname",
+                     COrdinalEnumName(descriptor_), "count",
+                     SimpleItoa(canonical_values_.size()));
+  }
 
   printer->Outdent();
   printer->Print("};\n\n");
@@ -113,6 +120,10 @@ void EnumGenerator::GenerateHeader(io::Printer* printer) {
                      EnumValueName(canonical_values_[i]), "value",
                      SimpleItoa(canonical_values_[i]->number()));
   }
+  if (!descriptor_->is_closed()) {
+      printer->Print("$ordinalname$_UNRECOGNIZED = -1,\n", "ordinalname",
+                     CValueEnumName(descriptor_));
+  }
 
   printer->Outdent();
   printer->Print("};\n\n");
@@ -140,6 +151,13 @@ void EnumGenerator::GenerateHeader(io::Printer* printer) {
           SimpleItoa(canonical_values_[i]->number()), "valuepreprocessorname",
           CValuePreprocessorName(descriptor_));
   }
+  if (!descriptor_->is_closed()) {
+      printer->Print(
+          "#define $classname$_UNRECOGNIZED_VALUE "
+          "($valuepreprocessorname$)-1\n",
+          "classname", ClassName(descriptor_), "valuepreprocessorname",
+          CValuePreprocessorName(descriptor_));
+  }
 
   printer->Print(
       "\n"
@@ -184,26 +202,32 @@ void EnumGenerator::GenerateHeader(io::Printer* printer) {
         "classname", ClassName(descriptor_), "name",
         canonical_values_[i]->name());
   }
+  if (!descriptor_->is_closed()) {
+    printer->Print(
+        "FOUNDATION_EXPORT $classname$ *$classname$_get_UNRECOGNIZED(void);\n",
+        "classname", ClassName(descriptor_));
+  }
 }
 
 const int kMaxRowChars = 80;
 
 void EnumGenerator::GenerateSource(io::Printer* printer) {
+  const int canonical_count = canonical_values_.size();
+  const int enum_count = canonical_count + (descriptor_->is_closed() ? 0 : 1);
   printer->Print(
       "\nJ2OBJC_INITIALIZED_DEFN($classname$)\n"
       "\n"
       "$classname$ *$classname$_values_[$count$];\n"
       "\n"
       "ComGoogleProtobufDescriptors_EnumDescriptor"
-          " *$classname$_descriptor_ = nil;\n"
+      " *$classname$_descriptor_ = nil;\n"
       "\n"
       "@implementation $classname$\n"
       "\n"
       "+ (void)initialize {\n"
       "  if (self == [$classname$ class]) {\n"
       "    NSString *names[] = {",
-      "classname", ClassName(descriptor_),
-      "count", SimpleItoa(canonical_values_.size()));
+      "classname", ClassName(descriptor_), "count", SimpleItoa(enum_count));
 
   // Count characters and only add line breaks when the line exceeds the max.
   int row_chars = kMaxRowChars + 1;
@@ -217,6 +241,9 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
     printer->Print(" @\"$name$\",", "name", name);
     row_chars += added_chars;
   }
+  if (!descriptor_->is_closed()) {
+    printer->Print(" @\"UNRECOGNIZED\",");
+  }
   printer->Print("\n"
       "    };\n"
       "    jint int_values[] = {");
@@ -231,19 +258,22 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
     printer->Print(" $value$,", "value", value);
     row_chars += added_chars;
   }
+  if (!descriptor_->is_closed()) {
+    printer->Print(" -1,");
+  }
 
   printer->Print(
       "\n"
       "    };\n"
       "    $classname$_descriptor_ = "
       "CGPInitializeEnumType(self, $count$, $classname$_values_, names,"
-      " int_values);\n"
+      " int_values, $is_closed$);\n"
       "    J2OBJC_SET_INITIALIZED($classname$)\n"
       "  }\n"
       "}\n"
       "\n"
       "+ (IOSObjectArray *)values {\n"
-      "  return $classname$_values();"
+      "  return $classname$_values();\n"
       "}\n"
       "\n"
       "+ ($classname$ *)valueOfWithNSString:(NSString *)name {\n"
@@ -257,8 +287,26 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
       "+ ($classname$ *)forNumberWithInt:($valuepreprocessorname$)value {\n"
       "  return $classname$_forNumberWithInt_(value);\n"
       "}\n"
-      "\n"
-      "- ($valuepreprocessorname$)getNumber {\n"
+      "\n",
+      "classname", ClassName(descriptor_), "count", SimpleItoa(enum_count),
+      "valuepreprocessorname", CValuePreprocessorName(descriptor_),
+      "is_closed", SimpleItoa(descriptor_->is_closed()));
+
+  printer->Print(
+      "- ($valuepreprocessorname$)getNumber {\n",
+      "valuepreprocessorname", CValuePreprocessorName(descriptor_));
+  if (!descriptor_->is_closed()) {
+    printer->Print(
+        // "=="" is safe because it's testing a unique enum constant.
+        "  if (self == $classname$_get_UNRECOGNIZED()) {\n"
+        "    @throw "
+        "create_JavaLangIllegalArgumentException_initWithNSString_(\n"
+        "        @\"Can't get the number of an unknown enum value.\");\n"
+        "  }\n",
+        "classname", ClassName(descriptor_));
+  }
+
+  printer->Print(
       "  return value_;\n"
       "}\n"
       "\n"
@@ -267,7 +315,20 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
       "}\n"
       "\n"
       "- (ComGoogleProtobufDescriptors_EnumValueDescriptor *)"
-      "getValueDescriptor {\n"
+      "getValueDescriptor {\n",
+      "classname", ClassName(descriptor_));
+
+  if (!descriptor_->is_closed()) {
+    printer->Print(
+        "  if (value_ == $classname$_Value_UNRECOGNIZED) {\n"
+        "    @throw create_JavaLangIllegalStateException_initWithNSString_(\n"
+        "        @\"Can't get the descriptor of an unrecognized enum "
+        "value.\");\n"
+        "  }\n",
+        "classname", ClassName(descriptor_));
+  }
+
+  printer->Print(
       "  return $classname$_descriptor_->values_->buffer_[[self ordinal]];\n"
       "}\n"
       "\n"
@@ -276,21 +337,25 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
       "J2OBJC_CLASS_TYPE_LITERAL_SOURCE($classname$)\n"
       "\n"
       "IOSObjectArray *$classname$_values(void) {\n"
-      "  $classname$_initialize();"
+      "  $classname$_initialize();\n"
       "  return [IOSObjectArray arrayWithObjects:$classname$_values_"
       " count:$count$ type:$classname$_class_()];\n"
       "}\n"
       "\n"
       "$classname$ *$classname$_valueOfWithNSString_(NSString *name) {\n"
-      "  $classname$_initialize();"
+      "  $classname$_initialize();\n"
       "  for (jint i = 0; i < $count$; i++) {\n"
       "    $classname$ *e = $classname$_values_[i];\n"
       "    if ([name isEqual:[e name]]) {\n"
       "      return e;\n"
       "    }\n"
       "  }\n"
       "  @throw create_JavaLangIllegalArgumentException_initWithNSString_("
-      "name);\n"
+      "name);\n",
+      "classname", ClassName(descriptor_), "count",
+      SimpleItoa(enum_count));  // Include UNRECOGNIZED constant.
+
+  printer->Print(
       "}\n"
       "\n"
       "$classname$ *$classname$_valueOfWithInt_($valuepreprocessorname$ value) "
@@ -300,7 +365,7 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
       "\n"
       "$classname$ *$classname$_forNumberWithInt_($valuepreprocessorname$ "
       "value) {\n"
-      "  $classname$_initialize();"
+      "  $classname$_initialize();\n"
       "  for (jint i = 0; i < $count$; i++) {\n"
       "    $classname$ *e = $classname$_values_[i];\n"
       "    if (value == [e getNumber]) {\n"
@@ -309,7 +374,11 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
       "  }\n"
       "  return nil;\n"
       "}\n"
-      "\n"
+      "\n",
+      "classname", ClassName(descriptor_), "count", SimpleItoa(canonical_count),
+      "valuepreprocessorname", CValuePreprocessorName(descriptor_));
+
+  printer->Print(
       "$classname$ *$classname$_fromOrdinal($ordinalpreprocessorname$ ordinal) "
       "{\n"
       "  $classname$_initialize();\n"
@@ -318,11 +387,8 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
       "  }\n"
       "  return $classname$_values_[ordinal];\n"
       "}\n",
-      "classname", ClassName(descriptor_), "count",
-      SimpleItoa(canonical_values_.size()), "ordinalpreprocessorname",
-      COrdinalPreprocessorName(descriptor_), "valueenumname",
-      CValueEnumName(descriptor_), "valuepreprocessorname",
-      CValuePreprocessorName(descriptor_));
+      "classname", ClassName(descriptor_), "count", SimpleItoa(enum_count),
+      "ordinalpreprocessorname", COrdinalPreprocessorName(descriptor_));
 
   for (int i = 0; i < canonical_values_.size(); i++) {
     printer->Print(
@@ -333,6 +399,14 @@ void EnumGenerator::GenerateSource(io::Printer* printer) {
         "classname", ClassName(descriptor_),
         "name", canonical_values_[i]->name());
   }
+  if (!descriptor_->is_closed()) {
+    printer->Print(
+        "\n$classname$ *$classname$_get_$name$(void) {\n"
+        "  $classname$_initialize();\n"
+        "  return $classname$_values_[$classname$_Enum_$name$];\n"
+        "}\n",
+        "classname", ClassName(descriptor_), "name", "UNRECOGNIZED");
+  }
 }
 
 }  // namespace j2objc

diff --git a/protobuf/runtime/src/com/google/protobuf/Descriptors.m b/protobuf/runtime/src/com/google/protobuf/Descriptors.m
@@ -137,7 +137,7 @@ void CGPInitFields(
 
 CGPEnumDescriptor *CGPInitializeEnumType(
     Class enumClass, jint valuesCount, JavaLangEnum<ComGoogleProtobufProtocolMessageEnum> *values[],
-    NSString **names, jint *intValues) {
+    NSString **names, jint *intValues, jboolean is_closed) {
   Ivar valueIvar = class_getInstanceVariable(enumClass, "value_");
   ptrdiff_t valueOffset = ivar_getOffset(valueIvar);
 
@@ -175,7 +175,9 @@ void CGPInitFields(
   // Construct the enum descriptor.
   CGPEnumDescriptor *enumDesc =
       objc_constructInstance([CGPEnumDescriptor class], (void *)enumDescPtr);
-  return [enumDesc initWithValueOffset:valueOffset retainedValues:valuesArray];
+  return [enumDesc initWithValueOffset:valueOffset
+                        retainedValues:valuesArray
+                             is_closed:is_closed];
 }
 
 void CGPInitializeOneofCaseEnum(
@@ -453,22 +455,27 @@ id CGPFieldGetDefaultValue(CGPFieldDescriptor *field) {
 
 CGPEnumValueDescriptor *CGPEnumValueDescriptorFromInt(CGPEnumDescriptor *enumType, jint value) {
   NSUInteger count = enumType->values_->size_;
+  NSUInteger numValues = enumType->is_closed_ ? count : count - 1;  // Skip the UNRECOGNIZED value.
   CGPEnumValueDescriptor **valuesBuf = enumType->values_->buffer_;
-  for (NSUInteger i = 0; i < count; i++) {
+  for (NSUInteger i = 0; i < numValues; i++) {
     CGPEnumValueDescriptor *valueDescriptor = valuesBuf[i];
     if (valueDescriptor->number_ == value) {
       return valueDescriptor;
     }
   }
-  return nil;
+  // If proto3 (not closed), the UNRECOGNIZED value is the last values element.
+  return enumType->is_closed_ ? nil : valuesBuf[count - 1];
 }
 
 @implementation ComGoogleProtobufDescriptors_EnumDescriptor
 
-- (instancetype)initWithValueOffset:(ptrdiff_t)valueOffset retainedValues:(IOSObjectArray *)values {
+- (instancetype)initWithValueOffset:(ptrdiff_t)valueOffset
+                     retainedValues:(IOSObjectArray *)values
+                          is_closed:(jboolean)is_closed {
   if (self = [super init]) {
     valueOffset_ = valueOffset;
     values_ = values; // Already retained.
+    is_closed_ = is_closed;
   }
   return self;
 }

diff --git a/protobuf/runtime/src/com/google/protobuf/Descriptors_PackagePrivate.h b/protobuf/runtime/src/com/google/protobuf/Descriptors_PackagePrivate.h
@@ -135,9 +135,12 @@ typedef struct CGPOneofData {
  @public
   ptrdiff_t valueOffset_;
   IOSObjectArray *values_;
+  jboolean is_closed_;
 }
 
-- (instancetype)initWithValueOffset:(ptrdiff_t)valueOffset retainedValues:(IOSObjectArray *)values;
+- (instancetype)initWithValueOffset:(ptrdiff_t)valueOffset
+                     retainedValues:(IOSObjectArray *)values
+                          is_closed:(jboolean)is_closed;
 
 @end
 
@@ -194,7 +197,7 @@ IOSObjectArray *CGPGetSerializationOrderFields(CGPDescriptor *descriptor);
 CGPEnumDescriptor *CGPInitializeEnumType(
     Class enumClass, jint valuesCount,
     __strong JavaLangEnum<ComGoogleProtobufProtocolMessageEnum> *values[],
-    __strong NSString **names, jint *intValues);
+    __strong NSString **names, jint *intValues, jboolean is_closed);
 
 void CGPInitializeOneofCaseEnum(
     Class enumClass, jint valuesCount,

diff --git a/protobuf/tests/EnumsTest.java b/protobuf/tests/EnumsTest.java
@@ -13,18 +13,17 @@
  */
 
 import com.google.protobuf.ExtensionRegistry;
-
+import java.io.ByteArrayInputStream;
+import java.util.ArrayList;
+import java.util.List;
 import protos.Color;
 import protos.EnumFields;
 import protos.EnumMsg;
 import protos.EnumMsg.InnerMsg.Utensil;
 import protos.EnumMsg.Shape;
 import protos.EnumMsgOrBuilder;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.util.ArrayList;
-import java.util.List;
+import protos.Foo;
+import protos.SomeEnum;
 
 /**
  * Tests for correct behavior of enum fields.
@@ -101,6 +100,19 @@ public void testAddAll() throws Exception {
     assertEquals(Shape.CIRCLE, builder.getEnumR(2));
   }
 
+  public void testMinusOne() throws Exception {
+    assertEquals(0, SomeEnum.UNKNOWN.getNumber());
+    assertEquals(1, SomeEnum.A.getNumber());
+    assertEquals(-1, SomeEnum.UNRECOGNIZED.getNumber());
+
+    assertEquals(SomeEnum.UNKNOWN, SomeEnum.forNumber(0));
+    assertEquals(SomeEnum.A, SomeEnum.forNumber(1));
+    assertEquals(SomeEnum.UNRECOGNIZED, SomeEnum.forNumber(-1));
+
+    Foo foo = Foo.parseFrom(new byte[] {0x08, 0x7f}, ExtensionRegistry.getEmptyRegistry());
+    assertEquals(SomeEnum.UNKNOWN, foo.getE());
+  }
+
   private void checkFields(EnumMsgOrBuilder msg) {
     assertEquals(Shape.SQUARE, msg.getEnumF());
     assertEquals(Color.RED, msg.getOuterEnumF());

diff --git a/protobuf/tests/Makefile b/protobuf/tests/Makefile
@@ -16,6 +16,7 @@ JAVA_TESTS = \
   MessagesTest.java \
   OneofTest.java \
   PrimitivesTest.java \
+  Proto3EnumTest.java \
 	Proto3OptionalTest.java \
 	com/google/protobuf/FieldPresenceTest.java \
   com/google/protobuf/WireFormatTest.java \
@@ -58,6 +59,7 @@ PROTOS = \
   package_prefix.proto \
   prefix_option.proto \
   primitives.proto \
+  proto3_enum.proto \
   single_file.proto \
   size_test.proto \
   string_fields.proto \