Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 154 insertions, 154 deletions

diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h
index 5acc729c1db..695ab77b43d 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h
@@ -35,13 +35,13 @@
 #ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_HELPERS_H__
 #define GOOGLE_PROTOBUF_COMPILER_JAVA_HELPERS_H__
 
-#include <cstdint>
-#include <string>
-
-#include <google/protobuf/compiler/java/java_context.h>
-#include <google/protobuf/descriptor.pb.h>
-#include <google/protobuf/io/printer.h>
-#include <google/protobuf/descriptor.h>
+#include <cstdint> 
+#include <string> 
+ 
+#include <google/protobuf/compiler/java/java_context.h> 
+#include <google/protobuf/descriptor.pb.h> 
+#include <google/protobuf/io/printer.h> 
+#include <google/protobuf/descriptor.h> 
 
 namespace google {
 namespace protobuf {
@@ -53,8 +53,8 @@ namespace java {
 extern const char kThickSeparator[];
 extern const char kThinSeparator[];
 
-bool IsForbiddenKotlin(const TProtoStringType& field_name);
-
+bool IsForbiddenKotlin(const TProtoStringType& field_name); 
+ 
 // If annotation_file is non-empty, prints a javax.annotation.Generated
 // annotation to the given Printer. annotation_file will be referenced in the
 // annotation's comments field. delimiter should be the Printer's delimiter
@@ -64,102 +64,102 @@ bool IsForbiddenKotlin(const TProtoStringType& field_name);
 // annotation_file should be generated from the filename of the source file
 // being annotated (which in turn must be a Java identifier plus ".java").
 void PrintGeneratedAnnotation(io::Printer* printer, char delimiter = '$',
-                              const TProtoStringType& annotation_file = "");
-
-// If a GeneratedMessageLite contains non-lite enums, then its verifier
-// must be instantiated inline, rather than retrieved from the enum class.
-void PrintEnumVerifierLogic(io::Printer* printer,
-                            const FieldDescriptor* descriptor,
-                            const std::map<TProtoStringType, TProtoStringType>& variables,
-                            const char* var_name,
-                            const char* terminating_string, bool enforce_lite);
-
-// Converts a name to camel-case. If cap_first_letter is true, capitalize the
-// first letter.
-TProtoStringType ToCamelCase(const TProtoStringType& input, bool lower_first);
-
-char ToUpperCh(char ch);
-char ToLowerCh(char ch);
-
+                              const TProtoStringType& annotation_file = ""); 
+
+// If a GeneratedMessageLite contains non-lite enums, then its verifier 
+// must be instantiated inline, rather than retrieved from the enum class. 
+void PrintEnumVerifierLogic(io::Printer* printer, 
+                            const FieldDescriptor* descriptor, 
+                            const std::map<TProtoStringType, TProtoStringType>& variables, 
+                            const char* var_name, 
+                            const char* terminating_string, bool enforce_lite); 
+ 
 // Converts a name to camel-case. If cap_first_letter is true, capitalize the
 // first letter.
-TProtoStringType UnderscoresToCamelCase(const TProtoStringType& name,
-                                   bool cap_first_letter);
+TProtoStringType ToCamelCase(const TProtoStringType& input, bool lower_first); 
+ 
+char ToUpperCh(char ch); 
+char ToLowerCh(char ch); 
+ 
+// Converts a name to camel-case. If cap_first_letter is true, capitalize the 
+// first letter. 
+TProtoStringType UnderscoresToCamelCase(const TProtoStringType& name, 
+                                   bool cap_first_letter); 
 // Converts the field's name to camel-case, e.g. "foo_bar_baz" becomes
 // "fooBarBaz" or "FooBarBaz", respectively.
-TProtoStringType UnderscoresToCamelCase(const FieldDescriptor* field);
-TProtoStringType UnderscoresToCapitalizedCamelCase(const FieldDescriptor* field);
+TProtoStringType UnderscoresToCamelCase(const FieldDescriptor* field); 
+TProtoStringType UnderscoresToCapitalizedCamelCase(const FieldDescriptor* field); 
 
 // Similar, but for method names.  (Typically, this merely has the effect
 // of lower-casing the first letter of the name.)
-TProtoStringType UnderscoresToCamelCase(const MethodDescriptor* method);
+TProtoStringType UnderscoresToCamelCase(const MethodDescriptor* method); 
 
-// Same as UnderscoresToCamelCase, but checks for reserved keywords
-TProtoStringType UnderscoresToCamelCaseCheckReserved(const FieldDescriptor* field);
-
-// Similar to UnderscoresToCamelCase, but guarantees that the result is a
+// Same as UnderscoresToCamelCase, but checks for reserved keywords 
+TProtoStringType UnderscoresToCamelCaseCheckReserved(const FieldDescriptor* field); 
+ 
+// Similar to UnderscoresToCamelCase, but guarantees that the result is a 
 // complete Java identifier by adding a _ if needed.
-TProtoStringType CamelCaseFieldName(const FieldDescriptor* field);
+TProtoStringType CamelCaseFieldName(const FieldDescriptor* field); 
 
 // Get an identifier that uniquely identifies this type within the file.
 // This is used to declare static variables related to this type at the
 // outermost file scope.
-TProtoStringType UniqueFileScopeIdentifier(const Descriptor* descriptor);
+TProtoStringType UniqueFileScopeIdentifier(const Descriptor* descriptor); 
 
 // Gets the unqualified class name for the file.  For each .proto file, there
 // will be one Java class containing all the immutable messages and another
 // Java class containing all the mutable messages.
 // TODO(xiaofeng): remove the default value after updating client code.
-TProtoStringType FileClassName(const FileDescriptor* file, bool immutable = true);
+TProtoStringType FileClassName(const FileDescriptor* file, bool immutable = true); 
 
 // Returns the file's Java package name.
-TProtoStringType FileJavaPackage(const FileDescriptor* file, bool immutable);
+TProtoStringType FileJavaPackage(const FileDescriptor* file, bool immutable); 
 
 // Returns output directory for the given package name.
-TProtoStringType JavaPackageToDir(TProtoStringType package_name);
+TProtoStringType JavaPackageToDir(TProtoStringType package_name); 
 
 // Comma-separate list of option-specified interfaces implemented by the
 // Message, to follow the "implements" declaration of the Message definition.
-TProtoStringType ExtraMessageInterfaces(const Descriptor* descriptor);
+TProtoStringType ExtraMessageInterfaces(const Descriptor* descriptor); 
 // Comma-separate list of option-specified interfaces implemented by the
 // MutableMessage, to follow the "implements" declaration of the MutableMessage
 // definition.
-TProtoStringType ExtraMutableMessageInterfaces(const Descriptor* descriptor);
+TProtoStringType ExtraMutableMessageInterfaces(const Descriptor* descriptor); 
 // Comma-separate list of option-specified interfaces implemented by the
 // Builder, to follow the "implements" declaration of the Builder definition.
-TProtoStringType ExtraBuilderInterfaces(const Descriptor* descriptor);
+TProtoStringType ExtraBuilderInterfaces(const Descriptor* descriptor); 
 // Comma-separate list of option-specified interfaces extended by the
 // MessageOrBuilder, to follow the "extends" declaration of the
 // MessageOrBuilder definition.
-TProtoStringType ExtraMessageOrBuilderInterfaces(const Descriptor* descriptor);
+TProtoStringType ExtraMessageOrBuilderInterfaces(const Descriptor* descriptor); 
 
 // Get the unqualified Java class name for mutable messages. i.e. without
 // package or outer classnames.
-inline TProtoStringType ShortMutableJavaClassName(const Descriptor* descriptor) {
+inline TProtoStringType ShortMutableJavaClassName(const Descriptor* descriptor) { 
   return descriptor->name();
 }
 
-// Whether the given descriptor is for one of the core descriptor protos. We
-// cannot currently use the new runtime with core protos since there is a
-// bootstrapping problem with obtaining their descriptors.
-inline bool IsDescriptorProto(const Descriptor* descriptor) {
-  return descriptor->file()->name() == "net/proto2/proto/descriptor.proto" ||
-         descriptor->file()->name() == "google/protobuf/descriptor.proto";
-}
-
-// Returns the stored type string used by the experimental runtime for oneof
-// fields.
-TProtoStringType GetOneofStoredType(const FieldDescriptor* field);
-
-
+// Whether the given descriptor is for one of the core descriptor protos. We 
+// cannot currently use the new runtime with core protos since there is a 
+// bootstrapping problem with obtaining their descriptors. 
+inline bool IsDescriptorProto(const Descriptor* descriptor) { 
+  return descriptor->file()->name() == "net/proto2/proto/descriptor.proto" || 
+         descriptor->file()->name() == "google/protobuf/descriptor.proto"; 
+} 
+
+// Returns the stored type string used by the experimental runtime for oneof 
+// fields. 
+TProtoStringType GetOneofStoredType(const FieldDescriptor* field); 
+ 
+ 
 // Whether we should generate multiple java files for messages.
-inline bool MultipleJavaFiles(const FileDescriptor* descriptor,
-                              bool immutable) {
-  (void) immutable;
+inline bool MultipleJavaFiles(const FileDescriptor* descriptor, 
+                              bool immutable) { 
+  (void) immutable; 
   return descriptor->options().java_multiple_files();
 }
 
-
+ 
 // Returns true if `descriptor` will be written to its own .java file.
 // `immutable` should be set to true if we're generating for the immutable API.
 template <typename Descriptor>
@@ -178,26 +178,26 @@ inline bool IsOwnFile(const ServiceDescriptor* descriptor, bool immutable) {
 // annotation data for that descriptor. `suffix` is usually empty, but may
 // (e.g.) be "OrBuilder" for some generated interfaces.
 template <typename Descriptor>
-TProtoStringType AnnotationFileName(const Descriptor* descriptor,
-                               const TProtoStringType& suffix) {
+TProtoStringType AnnotationFileName(const Descriptor* descriptor, 
+                               const TProtoStringType& suffix) { 
   return descriptor->name() + suffix + ".java.pb.meta";
 }
 
 template <typename Descriptor>
 void MaybePrintGeneratedAnnotation(Context* context, io::Printer* printer,
                                    Descriptor* descriptor, bool immutable,
-                                   const TProtoStringType& suffix = "") {
-  if (IsOwnFile(descriptor, immutable)) {
+                                   const TProtoStringType& suffix = "") { 
+  if (IsOwnFile(descriptor, immutable)) { 
     PrintGeneratedAnnotation(printer, '$',
-                             context->options().annotate_code
-                                 ? AnnotationFileName(descriptor, suffix)
-                                 : "");
+                             context->options().annotate_code 
+                                 ? AnnotationFileName(descriptor, suffix) 
+                                 : ""); 
   }
 }
 
 // Get the unqualified name that should be used for a field's field
 // number constant.
-TProtoStringType FieldConstantName(const FieldDescriptor* field);
+TProtoStringType FieldConstantName(const FieldDescriptor* field); 
 
 // Returns the type of the FieldDescriptor.
 // This does nothing interesting for the open source release, but is used for
@@ -225,41 +225,41 @@ const char* PrimitiveTypeName(JavaType type);
 // types.
 const char* BoxedPrimitiveTypeName(JavaType type);
 
-// Kotlin source does not distinguish between primitives and non-primitives,
-// but does use Kotlin-specific qualified types for them.
-const char* KotlinTypeName(JavaType type);
-
+// Kotlin source does not distinguish between primitives and non-primitives, 
+// but does use Kotlin-specific qualified types for them. 
+const char* KotlinTypeName(JavaType type); 
+ 
 // Get the name of the java enum constant representing this type. E.g.,
 // "INT32" for FieldDescriptor::TYPE_INT32. The enum constant's full
 // name is "com.google.protobuf.WireFormat.FieldType.INT32".
 const char* FieldTypeName(const FieldDescriptor::Type field_type);
 
 class ClassNameResolver;
-TProtoStringType DefaultValue(const FieldDescriptor* field, bool immutable,
-                         ClassNameResolver* name_resolver);
-inline TProtoStringType ImmutableDefaultValue(const FieldDescriptor* field,
-                                         ClassNameResolver* name_resolver) {
+TProtoStringType DefaultValue(const FieldDescriptor* field, bool immutable, 
+                         ClassNameResolver* name_resolver); 
+inline TProtoStringType ImmutableDefaultValue(const FieldDescriptor* field, 
+                                         ClassNameResolver* name_resolver) { 
   return DefaultValue(field, true, name_resolver);
 }
 bool IsDefaultValueJavaDefault(const FieldDescriptor* field);
 bool IsByteStringWithCustomDefaultValue(const FieldDescriptor* field);
 
 // Does this message class have descriptor and reflection methods?
-inline bool HasDescriptorMethods(const Descriptor* /* descriptor */,
+inline bool HasDescriptorMethods(const Descriptor* /* descriptor */, 
                                  bool enforce_lite) {
-  return !enforce_lite;
+  return !enforce_lite; 
 }
-inline bool HasDescriptorMethods(const EnumDescriptor* /* descriptor */,
+inline bool HasDescriptorMethods(const EnumDescriptor* /* descriptor */, 
                                  bool enforce_lite) {
-  return !enforce_lite;
+  return !enforce_lite; 
 }
-inline bool HasDescriptorMethods(const FileDescriptor* /* descriptor */,
+inline bool HasDescriptorMethods(const FileDescriptor* /* descriptor */, 
                                  bool enforce_lite) {
-  return !enforce_lite;
+  return !enforce_lite; 
 }
 
 // Should we generate generic services for this file?
-inline bool HasGenericServices(const FileDescriptor* file, bool enforce_lite) {
+inline bool HasGenericServices(const FileDescriptor* file, bool enforce_lite) { 
   return file->service_count() > 0 &&
          HasDescriptorMethods(file, enforce_lite) &&
          file->options().java_generic_services();
@@ -268,50 +268,50 @@ inline bool HasGenericServices(const FileDescriptor* file, bool enforce_lite) {
 // Methods for shared bitfields.
 
 // Gets the name of the shared bitfield for the given index.
-TProtoStringType GetBitFieldName(int index);
+TProtoStringType GetBitFieldName(int index); 
 
 // Gets the name of the shared bitfield for the given bit index.
 // Effectively, GetBitFieldName(bitIndex / 32)
-TProtoStringType GetBitFieldNameForBit(int bitIndex);
+TProtoStringType GetBitFieldNameForBit(int bitIndex); 
 
 // Generates the java code for the expression that returns the boolean value
 // of the bit of the shared bitfields for the given bit index.
 // Example: "((bitField1_ & 0x04) == 0x04)"
-TProtoStringType GenerateGetBit(int bitIndex);
+TProtoStringType GenerateGetBit(int bitIndex); 
 
 // Generates the java code for the expression that sets the bit of the shared
 // bitfields for the given bit index.
 // Example: "bitField1_ = (bitField1_ | 0x04)"
-TProtoStringType GenerateSetBit(int bitIndex);
+TProtoStringType GenerateSetBit(int bitIndex); 
 
 // Generates the java code for the expression that clears the bit of the shared
 // bitfields for the given bit index.
 // Example: "bitField1_ = (bitField1_ & ~0x04)"
-TProtoStringType GenerateClearBit(int bitIndex);
+TProtoStringType GenerateClearBit(int bitIndex); 
 
 // Does the same as GenerateGetBit but operates on the bit field on a local
 // variable. This is used by the builder to copy the value in the builder to
 // the message.
 // Example: "((from_bitField1_ & 0x04) == 0x04)"
-TProtoStringType GenerateGetBitFromLocal(int bitIndex);
+TProtoStringType GenerateGetBitFromLocal(int bitIndex); 
 
 // Does the same as GenerateSetBit but operates on the bit field on a local
 // variable. This is used by the builder to copy the value in the builder to
 // the message.
 // Example: "to_bitField1_ = (to_bitField1_ | 0x04)"
-TProtoStringType GenerateSetBitToLocal(int bitIndex);
+TProtoStringType GenerateSetBitToLocal(int bitIndex); 
 
 // Does the same as GenerateGetBit but operates on the bit field on a local
 // variable. This is used by the parsing constructor to record if a repeated
 // field is mutable.
 // Example: "((mutable_bitField1_ & 0x04) == 0x04)"
-TProtoStringType GenerateGetBitMutableLocal(int bitIndex);
+TProtoStringType GenerateGetBitMutableLocal(int bitIndex); 
 
 // Does the same as GenerateSetBit but operates on the bit field on a local
 // variable. This is used by the parsing constructor to record if a repeated
 // field is mutable.
 // Example: "mutable_bitField1_ = (mutable_bitField1_ | 0x04)"
-TProtoStringType GenerateSetBitMutableLocal(int bitIndex);
+TProtoStringType GenerateSetBitMutableLocal(int bitIndex); 
 
 // Returns whether the JavaType is a reference type.
 bool IsReferenceType(JavaType type);
@@ -357,30 +357,30 @@ inline bool HasPackedFields(const Descriptor* descriptor) {
 // them has a required field. Return true if a required field is found.
 bool HasRequiredFields(const Descriptor* descriptor);
 
-inline bool IsProto2(const FileDescriptor* descriptor) {
-  return descriptor->syntax() == FileDescriptor::SYNTAX_PROTO2;
-}
-
-inline bool IsRealOneof(const FieldDescriptor* descriptor) {
-  return descriptor->containing_oneof() &&
-         !descriptor->containing_oneof()->is_synthetic();
-}
-
-inline bool HasHazzer(const FieldDescriptor* descriptor) {
-  return !descriptor->is_repeated() &&
-         (descriptor->message_type() || descriptor->has_optional_keyword() ||
-          IsProto2(descriptor->file()) || IsRealOneof(descriptor));
-}
-
-inline bool HasHasbit(const FieldDescriptor* descriptor) {
-  // Note that currently message fields inside oneofs have hasbits. This is
-  // surprising, as the oneof case should avoid any need for a hasbit. But if
-  // you change this method to remove hasbits for oneofs, a few tests fail.
-  // TODO(b/124347790): remove hasbits for oneofs
-  return !descriptor->is_repeated() &&
-         (descriptor->has_optional_keyword() || IsProto2(descriptor->file()));
+inline bool IsProto2(const FileDescriptor* descriptor) { 
+  return descriptor->syntax() == FileDescriptor::SYNTAX_PROTO2; 
 }
 
+inline bool IsRealOneof(const FieldDescriptor* descriptor) { 
+  return descriptor->containing_oneof() && 
+         !descriptor->containing_oneof()->is_synthetic(); 
+} 
+ 
+inline bool HasHazzer(const FieldDescriptor* descriptor) { 
+  return !descriptor->is_repeated() && 
+         (descriptor->message_type() || descriptor->has_optional_keyword() || 
+          IsProto2(descriptor->file()) || IsRealOneof(descriptor)); 
+} 
+ 
+inline bool HasHasbit(const FieldDescriptor* descriptor) { 
+  // Note that currently message fields inside oneofs have hasbits. This is 
+  // surprising, as the oneof case should avoid any need for a hasbit. But if 
+  // you change this method to remove hasbits for oneofs, a few tests fail. 
+  // TODO(b/124347790): remove hasbits for oneofs 
+  return !descriptor->is_repeated() && 
+         (descriptor->has_optional_keyword() || IsProto2(descriptor->file())); 
+} 
+ 
 // Whether generate classes expose public PARSER instances.
 inline bool ExposePublicParser(const FileDescriptor* descriptor) {
   // TODO(liujisi): Mark the PARSER private in 3.1.x releases.
@@ -394,11 +394,11 @@ inline bool SupportUnknownEnumValue(const FileDescriptor* descriptor) {
   return descriptor->syntax() == FileDescriptor::SYNTAX_PROTO3;
 }
 
-inline bool SupportUnknownEnumValue(const FieldDescriptor* field) {
-  return field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3;
-}
-
-// Check whether a message has repeated fields.
+inline bool SupportUnknownEnumValue(const FieldDescriptor* field) { 
+  return field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3; 
+} 
+ 
+// Check whether a message has repeated fields. 
 bool HasRepeatedFields(const Descriptor* descriptor);
 
 inline bool IsMapEntry(const Descriptor* descriptor) {
@@ -413,47 +413,47 @@ inline bool IsAnyMessage(const Descriptor* descriptor) {
   return descriptor->full_name() == "google.protobuf.Any";
 }
 
-inline bool IsWrappersProtoFile(const FileDescriptor* descriptor) {
-  return descriptor->name() == "google/protobuf/wrappers.proto";
-}
-
+inline bool IsWrappersProtoFile(const FileDescriptor* descriptor) { 
+  return descriptor->name() == "google/protobuf/wrappers.proto"; 
+} 
+ 
 inline bool CheckUtf8(const FieldDescriptor* descriptor) {
   return descriptor->file()->syntax() == FileDescriptor::SYNTAX_PROTO3 ||
-         descriptor->file()->options().java_string_check_utf8();
+         descriptor->file()->options().java_string_check_utf8(); 
 }
 
-inline TProtoStringType GeneratedCodeVersionSuffix() {
+inline TProtoStringType GeneratedCodeVersionSuffix() { 
   return "V3";
 }
-
-void WriteUInt32ToUtf16CharSequence(uint32_t number,
-                                    std::vector<uint16_t>* output);
-
-inline void WriteIntToUtf16CharSequence(int value,
-                                        std::vector<uint16_t>* output) {
-  WriteUInt32ToUtf16CharSequence(static_cast<uint32_t>(value), output);
-}
-
-// Escape a UTF-16 character so it can be embedded in a Java string literal.
-void EscapeUtf16ToString(uint16_t code, TProtoStringType* output);
-
-// Only the lowest two bytes of the return value are used. The lowest byte
-// is the integer value of a j/c/g/protobuf/FieldType enum. For the other
-// byte:
-//    bit 0: whether the field is required.
-//    bit 1: whether the field requires UTF-8 validation.
-//    bit 2: whether the field needs isInitialized check.
-//    bit 3: whether the field is a map field with proto2 enum value.
-//    bits 4-7: unused
-int GetExperimentalJavaFieldType(const FieldDescriptor* field);
-
-// To get the total number of entries need to be built for experimental runtime
-// and the first field number that are not in the table part
-std::pair<int, int> GetTableDrivenNumberOfEntriesAndLookUpStartFieldNumber(
-    const FieldDescriptor** fields, int count);
+ 
+void WriteUInt32ToUtf16CharSequence(uint32_t number, 
+                                    std::vector<uint16_t>* output); 
+ 
+inline void WriteIntToUtf16CharSequence(int value, 
+                                        std::vector<uint16_t>* output) { 
+  WriteUInt32ToUtf16CharSequence(static_cast<uint32_t>(value), output); 
+} 
+ 
+// Escape a UTF-16 character so it can be embedded in a Java string literal. 
+void EscapeUtf16ToString(uint16_t code, TProtoStringType* output); 
+ 
+// Only the lowest two bytes of the return value are used. The lowest byte 
+// is the integer value of a j/c/g/protobuf/FieldType enum. For the other 
+// byte: 
+//    bit 0: whether the field is required. 
+//    bit 1: whether the field requires UTF-8 validation. 
+//    bit 2: whether the field needs isInitialized check. 
+//    bit 3: whether the field is a map field with proto2 enum value. 
+//    bits 4-7: unused 
+int GetExperimentalJavaFieldType(const FieldDescriptor* field); 
+ 
+// To get the total number of entries need to be built for experimental runtime 
+// and the first field number that are not in the table part 
+std::pair<int, int> GetTableDrivenNumberOfEntriesAndLookUpStartFieldNumber( 
+    const FieldDescriptor** fields, int count); 
 }  // namespace java
 }  // namespace compiler
 }  // namespace protobuf
-}  // namespace google
+}  // namespace google 
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_HELPERS_H__