third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_message_field.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 27 matching lines @@
 #include <google/protobuf/stubs/strutil.h>
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace cpp {
 
 namespace {
 
 void SetMessageVariables(const FieldDescriptor* descriptor,
-                         map<string, string>* variables,
+                         std::map<string, string>* variables,
                          const Options& options) {
   SetCommonFieldVariables(descriptor, variables, options);
   (*variables)["type"] = FieldMessageTypeName(descriptor);
   if (descriptor->options().weak() || !descriptor->containing_oneof()) {
     (*variables)["non_null_ptr_to_name"] =
         StrCat("this->", (*variables)["name"], "_");
   }
   (*variables)["stream_writer"] =
       (*variables)["declared_type"] +
       (HasFastArraySerialization(descriptor->message_type()->file(), options)
@@ skipping 95 matching lines @@
         printer->Print(variables_,
           "  $name$_ = ::google::protobuf::Arena::Create< $type$ >(\n"
           "      GetArenaNoVirtual());\n");
       }
     printer->Print(variables_,
       "}\n"
       "$type$* $classname$::_slow_$release_name$() {\n"
       "  if ($name$_ == NULL) {\n"
       "    return NULL;\n"
       "  } else {\n"
-      "    $type$* temp = new $type$;\n"
-      "    temp->MergeFrom(*$name$_);\n"
+      "    $type$* temp = new $type$(*$name$_);\n"
       "    $name$_ = NULL;\n"
       "    return temp;\n"
       "  }\n"
       "}\n"
       "$type$* $classname$::unsafe_arena_release_$name$() {\n"
       "  // @@protoc_insertion_point(field_unsafe_arena_release:$full_name$)\n"
       "  $clear_hasbit$\n"
       "  $type$* temp = $name$_;\n"
       "  $name$_ = NULL;\n"
       "  return temp;\n"
@@ skipping 36 matching lines @@
       "}\n");
   }
 }
 
 void MessageFieldGenerator::
 GenerateDependentInlineAccessorDefinitions(io::Printer* printer) const {
   if (!dependent_field_) {
     return;
   }
 
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   // For the CRTP base class, all mutation methods are dependent, and so
   // they must be in the header.
   variables["dependent_classname"] =
       DependentBaseClassTemplateName(descriptor_->containing_type()) + "<T>";
   variables["this_message"] = DependentBaseDownCast();
   if (!variables["set_hasbit"].empty()) {
     variables["set_hasbit"] =
         variables["this_message"] + variables["set_hasbit"];
   }
   if (!variables["clear_hasbit"].empty()) {
@@ skipping 106 matching lines @@
       "    $clear_hasbit$\n"
       "  }\n"
       "  // @@protoc_insertion_point(field_set_allocated:$full_name$)\n"
       "}\n");
   }
 }
 
 void MessageFieldGenerator::
 GenerateInlineAccessorDefinitions(io::Printer* printer,
                                   bool is_inline) const {
-  map<string, string> variables(variables_);
+  if (dependent_field_) {
+    // for dependent fields we cannot access its internal_default_instance,
+    // because the type is incomplete.
+    // TODO(gerbens) deprecate dependent base class.
+    std::map<string, string> variables(variables_);
+    variables["inline"] = is_inline ? "inline " : "";
+    printer->Print(variables,
+      "$inline$const $type$& $classname$::$name$() const {\n"
+      "  // @@protoc_insertion_point(field_get:$full_name$)\n"
+      "  return $name$_ != NULL ? *$name$_\n"
+      "                         : *internal_default_instance()->$name$_;\n"
+      "}\n");
+    return;
+  }
+
+  std::map<string, string> variables(variables_);
   variables["inline"] = is_inline ? "inline " : "";
   printer->Print(variables,
     "$inline$const $type$& $classname$::$name$() const {\n"
-    "  // @@protoc_insertion_point(field_get:$full_name$)\n");
-
-  PrintHandlingOptionalStaticInitializers(
-      variables, descriptor_->file(), options_, printer,
-      // With static initializers.
-      "  return $name$_ != NULL ? *$name$_ : *default_instance_->$name$_;\n",
-      // Without.
-      "  return $name$_ != NULL ? *$name$_ : *default_instance().$name$_;\n");
-  printer->Print(variables, "}\n");
-
-  if (dependent_field_) {
-    return;
-  }
+    "  // @@protoc_insertion_point(field_get:$full_name$)\n"
+    "  return $name$_ != NULL ? *$name$_\n"
+    "                         : *$type$::internal_default_instance();\n"
+    "}\n");
 
   if (SupportsArenas(descriptor_)) {
     printer->Print(variables,
       "$inline$"
       "$type$* $classname$::mutable_$name$() {\n"
       "  $set_hasbit$\n"
       "  if ($name$_ == NULL) {\n"
       "    _slow_mutable_$name$();\n"
       "  }\n"
       "  // @@protoc_insertion_point(field_mutable:$full_name$)\n"
@@ skipping 81 matching lines @@
       "  } else {\n"
       "    $clear_hasbit$\n"
       "  }\n"
       "  // @@protoc_insertion_point(field_set_allocated:$full_name$)\n"
       "}\n");
   }
 }
 
 void MessageFieldGenerator::
 GenerateClearingCode(io::Printer* printer) const {
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   variables["this_message"] = dependent_field_ ? DependentBaseDownCast() : "";
   if (!HasFieldPresence(descriptor_->file())) {
     // If we don't have has-bits, message presence is indicated only by ptr !=
     // NULL. Thus on clear, we need to delete the object.
     printer->Print(variables,
       "if ($this_message$GetArenaNoVirtual() == NULL && "
       "$this_message$$name$_ != NULL) delete $this_message$$name$_;\n"
       "$this_message$$name$_ = NULL;\n");
   } else {
     printer->Print(variables,
       "if ($this_message$$name$_ != NULL) $this_message$$name$_->"
       "$dependent_type$::Clear();\n");
   }
 }
 
 void MessageFieldGenerator::
+GenerateMessageClearingCode(io::Printer* printer) const {
+  std::map<string, string> variables(variables_);
+  variables["type"] = FieldMessageTypeName(descriptor_);
+
+  if (!HasFieldPresence(descriptor_->file())) {
+    // If we don't have has-bits, message presence is indicated only by ptr !=
+    // NULL. Thus on clear, we need to delete the object.
+    printer->Print(variables_,
+      "if (GetArenaNoVirtual() == NULL && $name$_ != NULL) {\n"
+      "  delete $name$_;\n"
+      "}\n"
+      "$name$_ = NULL;\n");
+  } else {
+    printer->Print(variables_,
+      "GOOGLE_DCHECK($name$_ != NULL);\n"
+      "$name$_->$type$::Clear();\n");
+  }
+}
+
+void MessageFieldGenerator::
 GenerateMergingCode(io::Printer* printer) const {
   printer->Print(variables_,
     "mutable_$name$()->$type$::MergeFrom(from.$name$());\n");
 }
 
 void MessageFieldGenerator::
 GenerateSwappingCode(io::Printer* printer) const {
   printer->Print(variables_, "std::swap($name$_, other->$name$_);\n");
 }
 
 void MessageFieldGenerator::
+GenerateDestructorCode(io::Printer* printer) const {
+  // In google3 a default instance will never get deleted so we don't need to
+  // worry about that but in opensource protobuf default instances are deleted
+  // in shutdown process and we need to take special care when handling them.
+  printer->Print(variables_,
+    "if (this != internal_default_instance()) {\n"
+    "  delete $name$_;\n"
+    "}\n");
+}
+
+void MessageFieldGenerator::
 GenerateConstructorCode(io::Printer* printer) const {
   printer->Print(variables_, "$name$_ = NULL;\n");
 }
 
 void MessageFieldGenerator::
+GenerateCopyConstructorCode(io::Printer* printer) const {
+  // For non-Arena enabled messages, everything always goes on the heap.
+  //
+  // For Arena enabled messages, the logic is a bit more convoluted.
+  //
+  // In the copy constructor, we call InternalMetadataWithArena::MergeFrom,
+  // which does *not* copy the Arena pointer.  In the generated MergeFrom
+  // (see MessageFieldGenerator::GenerateMergingCode), we:
+  // -> copy the has bits (but this is done in bulk by a memcpy in the copy
+  //    constructor)
+  // -> check whether the destination field pointer is NULL (it will be, since
+  //    we're initializing it and would have called SharedCtor) and if so:
+  // -> call _slow_mutable_$name$(), which calls either
+  //    ::google::protobuf::Arena::CreateMessage<>(GetArenaNoVirtual()), or
+  //    ::google::protobuf::Arena::Create<>(GetArenaNoVirtual())
+  //
+  // At this point, GetArenaNoVirtual returns NULL since the Arena pointer
+  // wasn't copied, so both of these methods allocate the submessage on the
+  // heap.
+
+  printer->Print(variables_,
+    "if (from.has_$name$()) {\n"
+    "  $name$_ = new $type$(*from.$name$_);\n"
+    "} else {\n"
+    "  $name$_ = NULL;\n"
+    "}\n");
+}
+
+void MessageFieldGenerator::
 GenerateMergeFromCodedStream(io::Printer* printer) const {
   if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
     printer->Print(variables_,
       "DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(\n"
       "     input, mutable_$name$()));\n");
   } else {
     printer->Print(variables_,
       "DO_(::google::protobuf::internal::WireFormatLite::ReadGroupNoVirtual(\n"
       "      $number$, input, mutable_$name$()));\n");
   }
 }
 
 void MessageFieldGenerator::
 GenerateSerializeWithCachedSizes(io::Printer* printer) const {
   printer->Print(variables_,
     "::google::protobuf::internal::WireFormatLite::Write$stream_writer$(\n"
     "  $number$, *$non_null_ptr_to_name$, output);\n");
 }
 
 void MessageFieldGenerator::
 GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
   printer->Print(variables_,
     "target = ::google::protobuf::internal::WireFormatLite::\n"
-    "  Write$declared_type$NoVirtualToArray(\n"
-    "    $number$, *$non_null_ptr_to_name$, target);\n");
+    "  InternalWrite$declared_type$NoVirtualToArray(\n"
+    "    $number$, *$non_null_ptr_to_name$, false, target);\n");
 }
 
 void MessageFieldGenerator::
 GenerateByteSize(io::Printer* printer) const {
   printer->Print(variables_,
     "total_size += $tag_size$ +\n"
     "  ::google::protobuf::internal::WireFormatLite::$declared_type$SizeNoVirtual(\n"
     "    *$non_null_ptr_to_name$);\n");
 }
 
@@ skipping 34 matching lines @@
       "$deprecated_attr$const $type$& $name$() const;\n");
 }
 
 void MessageOneofFieldGenerator::
 GenerateDependentInlineAccessorDefinitions(io::Printer* printer) const {
   // For the CRTP base class, all mutation methods are dependent, and so
   // they must be in the header.
   if (!dependent_base_) {
     return;
   }
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   variables["inline"] = "inline ";
   variables["dependent_classname"] =
       DependentBaseClassTemplateName(descriptor_->containing_type()) + "<T>";
   variables["this_message"] = "reinterpret_cast<T*>(this)->";
   // Const message access is needed for the dependent getter.
   variables["this_const_message"] = "reinterpret_cast<const T*>(this)->";
   variables["tmpl"] = "template <class T>\n";
   variables["field_member"] = variables["this_message"] +
                               variables["oneof_prefix"] + variables["name"] +
                               "_";
   InternalGenerateInlineAccessorDefinitions(variables, printer);
 }
 
 void MessageOneofFieldGenerator::
 GenerateInlineAccessorDefinitions(io::Printer* printer,
                                   bool is_inline) const {
   if (dependent_base_) {
     return;
   }
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   variables["inline"] = is_inline ? "inline " : "";
   variables["dependent_classname"] = variables["classname"];
   variables["this_message"] = "";
   variables["this_const_message"] = "";
   variables["tmpl"] = "";
   variables["field_member"] =
       variables["oneof_prefix"] + variables["name"] + "_";
   variables["dependent_type"] = variables["type"];
   InternalGenerateInlineAccessorDefinitions(variables, printer);
 }
 
 void MessageOneofFieldGenerator::
 GenerateNonInlineAccessorDefinitions(io::Printer* printer) const {
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   variables["field_member"] =
       variables["oneof_prefix"] + variables["name"] + "_";
 
   //printer->Print(variables,
 }
 
-void MessageOneofFieldGenerator::
-InternalGenerateInlineAccessorDefinitions(const map<string, string>& variables,
-                                          io::Printer* printer) const {
+void MessageOneofFieldGenerator::InternalGenerateInlineAccessorDefinitions(
+    const std::map<string, string>& variables, io::Printer* printer) const {
   printer->Print(variables,
     "$tmpl$"
     "$inline$ "
     "const $type$& $dependent_classname$::$name$() const {\n"
     "  // @@protoc_insertion_point(field_get:$full_name$)\n"
     "  return $this_const_message$has_$name$()\n"
     "      ? *$this_const_message$$oneof_prefix$$name$_\n"
     "      : $dependent_type$::default_instance();\n"
     "}\n");
 
@@ skipping 23 matching lines @@
       "}\n"
       "$tmpl$"
       "$inline$"
       "$type$* $dependent_classname$::$release_name$() {\n"
       "  // @@protoc_insertion_point(field_release:$full_name$)\n"
       "  if ($this_message$has_$name$()) {\n"
       "    $this_message$clear_has_$oneof_name$();\n"
       "    if ($this_message$GetArenaNoVirtual() != NULL) {\n"
       // N.B.: safe to use the underlying field pointer here because we are sure
       // that it is non-NULL (because has_$name$() returned true).
-      "      $dependent_typename$* temp = new $dependent_typename$;\n"
-      "      temp->MergeFrom(*$field_member$);\n"
+      "      $dependent_typename$* temp = "
+      "new $dependent_typename$(*$field_member$);\n"
       "      $field_member$ = NULL;\n"
       "      return temp;\n"
       "    } else {\n"
       "      $dependent_typename$* temp = $field_member$;\n"
       "      $field_member$ = NULL;\n"
       "      return temp;\n"
       "    }\n"
       "  } else {\n"
       "    return NULL;\n"
       "  }\n"
@@ skipping 104 matching lines @@
       "    $this_message$set_has_$name$();\n"
       "    $field_member$ = $name$;\n"
       "  }\n"
       "  // @@protoc_insertion_point(field_set_allocated:$full_name$)\n"
       "}\n");
   }
 }
 
 void MessageOneofFieldGenerator::
 GenerateClearingCode(io::Printer* printer) const {
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   variables["this_message"] = dependent_field_ ? DependentBaseDownCast() : "";
   if (SupportsArenas(descriptor_)) {
     printer->Print(variables,
       "if ($this_message$GetArenaNoVirtual() == NULL) {\n"
       "  delete $this_message$$oneof_prefix$$name$_;\n"
       "}\n");
   } else {
     printer->Print(variables,
       "delete $this_message$$oneof_prefix$$name$_;\n");
   }
 }
 
 void MessageOneofFieldGenerator::
+GenerateMessageClearingCode(io::Printer* printer) const {
+  GenerateClearingCode(printer);
+}
+
+void MessageOneofFieldGenerator::
 GenerateSwappingCode(io::Printer* printer) const {
   // Don't print any swapping code. Swapping the union will swap this field.
 }
 
 void MessageOneofFieldGenerator::
+GenerateDestructorCode(io::Printer* printer) const {
+  // We inherit from MessageFieldGenerator, so we need to override the default
+  // behavior.
+}
+
+void MessageOneofFieldGenerator::
 GenerateConstructorCode(io::Printer* printer) const {
   // Don't print any constructor code. The field is in a union. We allocate
   // space only when this field is used.
 }
 
 // ===================================================================
 
 RepeatedMessageFieldGenerator::RepeatedMessageFieldGenerator(
     const FieldDescriptor* descriptor, const Options& options)
     : FieldGenerator(options),
@@ skipping 51 matching lines @@
       "$deprecated_attr$const ::google::protobuf::RepeatedPtrField< $type$ >&\n"
       "    $name$() const;\n");
   }
 }
 
 void RepeatedMessageFieldGenerator::
 GenerateDependentInlineAccessorDefinitions(io::Printer* printer) const {
   if (!dependent_field_) {
     return;
   }
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   // For the CRTP base class, all mutation methods are dependent, and so
   // they must be in the header.
   variables["dependent_classname"] =
       DependentBaseClassTemplateName(descriptor_->containing_type()) + "<T>";
   variables["this_message"] = DependentBaseDownCast();
   variables["this_const_message"] = DependentBaseConstDownCast();
 
   if (dependent_getter_) {
     printer->Print(variables,
       "template <class T>\n"
@@ skipping 10 matching lines @@
     // TODO(dlj): move insertion points
     "  // @@protoc_insertion_point(field_mutable:$full_name$)\n"
     "  return $this_message$$name$_.Mutable(index);\n"
     "}\n"
     "template <class T>\n"
     "inline $type$* $dependent_classname$::add_$name$() {\n"
     "  // @@protoc_insertion_point(field_add:$full_name$)\n"
     "  return $this_message$$name$_.Add();\n"
     "}\n");
 
-
   if (dependent_getter_) {
     printer->Print(variables,
       "template <class T>\n"
       "inline const ::google::protobuf::RepeatedPtrField< $type$ >&\n"
       "$dependent_classname$::$name$() const {\n"
       "  // @@protoc_insertion_point(field_list:$full_name$)\n"
       "  return $this_const_message$$name$_;\n"
       "}\n");
   }
 
   // Generate mutable access to the entire list:
   printer->Print(variables,
     "template <class T>\n"
     "inline ::google::protobuf::RepeatedPtrField< $type$ >*\n"
     "$dependent_classname$::mutable_$name$() {\n"
     "  // @@protoc_insertion_point(field_mutable_list:$full_name$)\n"
     "  return &$this_message$$name$_;\n"
     "}\n");
 }
 
 void RepeatedMessageFieldGenerator::
 GenerateInlineAccessorDefinitions(io::Printer* printer,
                                   bool is_inline) const {
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   variables["inline"] = is_inline ? "inline " : "";
 
   if (!dependent_getter_) {
     printer->Print(variables,
       "$inline$"
       "const $type$& $classname$::$name$(int index) const {\n"
       "  // @@protoc_insertion_point(field_get:$full_name$)\n"
       "  return $name$_.$cppget$(index);\n"
       "}\n");
   }
@@ skipping 29 matching lines @@
       "const ::google::protobuf::RepeatedPtrField< $type$ >&\n"
       "$classname$::$name$() const {\n"
       "  // @@protoc_insertion_point(field_list:$full_name$)\n"
       "  return $name$_;\n"
       "}\n");
   }
 }
 
 void RepeatedMessageFieldGenerator::
 GenerateClearingCode(io::Printer* printer) const {
-  map<string, string> variables(variables_);
+  std::map<string, string> variables(variables_);
   variables["this_message"] = dependent_field_ ? DependentBaseDownCast() : "";
   printer->Print(variables, "$this_message$$name$_.Clear();\n");
 }
 
 void RepeatedMessageFieldGenerator::
 GenerateMergingCode(io::Printer* printer) const {
   printer->Print(variables_, "$name$_.MergeFrom(from.$name$_);\n");
 }
 
 void RepeatedMessageFieldGenerator::
@@ skipping 28 matching lines @@
     "  ::google::protobuf::internal::WireFormatLite::Write$stream_writer$(\n"
     "    $number$, this->$name$(i), output);\n"
     "}\n");
 }
 
 void RepeatedMessageFieldGenerator::
 GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
   printer->Print(variables_,
     "for (unsigned int i = 0, n = this->$name$_size(); i < n; i++) {\n"
     "  target = ::google::protobuf::internal::WireFormatLite::\n"
-    "    Write$declared_type$NoVirtualToArray(\n"
-    "      $number$, this->$name$(i), target);\n"
+    "    InternalWrite$declared_type$NoVirtualToArray(\n"
+    "      $number$, this->$name$(i), false, target);\n"
     "}\n");
 }
 
 void RepeatedMessageFieldGenerator::
 GenerateByteSize(io::Printer* printer) const {
   printer->Print(variables_,
-    "total_size += $tag_size$ * this->$name$_size();\n"
-    "for (int i = 0; i < this->$name$_size(); i++) {\n"
+    "{\n"
+    "  unsigned int count = this->$name$_size();\n");
+  printer->Indent();
+  printer->Print(variables_,
+    "total_size += $tag_size$UL * count;\n"
+    "for (unsigned int i = 0; i < count; i++) {\n"
     "  total_size +=\n"
     "    ::google::protobuf::internal::WireFormatLite::$declared_type$SizeNoVirtual(\n"
     "      this->$name$(i));\n"
     "}\n");
+  printer->Outdent();
+  printer->Print("}\n");
 }
 
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google