third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/compiler/csharp/csharp_message.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 87 matching lines @@
   return fields_by_number_;
 }
 
 void MessageGenerator::Generate(io::Printer* printer) {
   map<string, string> vars;
   vars["class_name"] = class_name();
   vars["access_level"] = class_access_level();
 
   WriteMessageDocComment(printer, descriptor_);
   printer->Print(
-    "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]\n");
-  WriteGeneratedCodeAttributes(printer);
-  printer->Print(
     vars,
     "$access_level$ sealed partial class $class_name$ : pb::IMessage<$class_name$> {\n");
   printer->Indent();
 
   // All static fields and properties
   printer->Print(
-      vars,
-      "private static readonly pb::MessageParser<$class_name$> _parser = new pb::MessageParser<$class_name$>(() => new $class_name$());\n"
-      "public static pb::MessageParser<$class_name$> Parser { get { return _parser; } }\n\n");
+          vars,
+          "private static readonly pb::MessageParser<$class_name$> _parser = new pb::MessageParser<$class_name$>(() => new $class_name$());\n");
+
+  WriteGeneratedCodeAttributes(printer);
+  printer->Print(
+          vars,
+          "public static pb::MessageParser<$class_name$> Parser { get { return _parser; } }\n\n");
 
   // Access the message descriptor via the relevant file descriptor or containing message descriptor.
   if (!descriptor_->containing_type()) {
     vars["descriptor_accessor"] = GetReflectionClassName(descriptor_->file())
         + ".Descriptor.MessageTypes[" + SimpleItoa(descriptor_->index()) + "]";
   } else {
     vars["descriptor_accessor"] = GetClassName(descriptor_->containing_type())
         + ".Descriptor.NestedTypes[" + SimpleItoa(descriptor_->index()) + "]";
   }
 
+  WriteGeneratedCodeAttributes(printer);
   printer->Print(
-    vars,
-    "public static pbr::MessageDescriptor Descriptor {\n"
-    "  get { return $descriptor_accessor$; }\n"
-    "}\n"
-    "\n"
+        vars,
+        "public static pbr::MessageDescriptor Descriptor {\n"
+        "  get { return $descriptor_accessor$; }\n"
+        "}\n"
+        "\n");
+  WriteGeneratedCodeAttributes(printer);
+  printer->Print(
+        vars,
     "pbr::MessageDescriptor pb::IMessage.Descriptor {\n"
     "  get { return Descriptor; }\n"
     "}\n"
     "\n");
 
   // Parameterless constructor and partial OnConstruction method.
+  WriteGeneratedCodeAttributes(printer);
   printer->Print(
     vars,
     "public $class_name$() {\n"
     "  OnConstruction();\n"
     "}\n\n"
     "partial void OnConstruction();\n\n");
 
   GenerateCloningCode(printer);
   GenerateFreezingCode(printer);
 
@@ skipping 29 matching lines @@
     for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
       const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
       printer->Print("$field_property_name$ = $index$,\n",
                      "field_property_name", GetPropertyName(field),
                      "index", SimpleItoa(field->number()));
     }
     printer->Outdent();
     printer->Print("}\n");
     // TODO: Should we put the oneof .proto comments here?
     // It's unclear exactly where they should go.
-    printer->Print(
-      vars,
-      "private $property_name$OneofCase $name$Case_ = $property_name$OneofCase.None;\n"
-      "public $property_name$OneofCase $property_name$Case {\n"
-      "  get { return $name$Case_; }\n"
-      "}\n\n"
+        printer->Print(
+          vars,
+          "private $property_name$OneofCase $name$Case_ = $property_name$OneofCase.None;\n");
+        WriteGeneratedCodeAttributes(printer);
+        printer->Print(
+          vars,
+          "public $property_name$OneofCase $property_name$Case {\n"
+          "  get { return $name$Case_; }\n"
+          "}\n\n");
+        WriteGeneratedCodeAttributes(printer);
+        printer->Print(
+          vars,
       "public void Clear$property_name$() {\n"
       "  $name$Case_ = $property_name$OneofCase.None;\n"
       "  $name$_ = null;\n"
       "}\n\n");
   }
 
   // Standard methods
   GenerateFrameworkMethods(printer);
   GenerateMessageSerializationMethods(printer);
   GenerateMergingMethods(printer);
 
   // Nested messages and enums
   if (HasNestedGeneratedTypes()) {
     printer->Print(
       vars,
       "#region Nested types\n"
-      "/// <summary>Container for nested types declared in the $class_name$ message type.</summary>\n"
-      "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]\n");
+      "/// <summary>Container for nested types declared in the $class_name$ message type.</summary>\n");
     WriteGeneratedCodeAttributes(printer);
     printer->Print("public static partial class Types {\n");
     printer->Indent();
     for (int i = 0; i < descriptor_->enum_type_count(); i++) {
       EnumGenerator enumGenerator(descriptor_->enum_type(i), this->options());
       enumGenerator.Generate(printer);
     }
     for (int i = 0; i < descriptor_->nested_type_count(); i++) {
       // Don't generate nested types for maps...
       if (!IsMapEntryMessage(descriptor_->nested_type(i))) {
@@ skipping 23 matching lines @@
   for (int i = 0; i < descriptor_->nested_type_count(); i++) {
     if (!IsMapEntryMessage(descriptor_->nested_type(i))) {
       return true;
     }
   }
   return false;
 }
 
 void MessageGenerator::GenerateCloningCode(io::Printer* printer) {
   map<string, string> vars;
+  WriteGeneratedCodeAttributes(printer);
   vars["class_name"] = class_name();
     printer->Print(
     vars,
     "public $class_name$($class_name$ other) : this() {\n");
   printer->Indent();
   // Clone non-oneof fields first
   for (int i = 0; i < descriptor_->field_count(); i++) {
     if (!descriptor_->field(i)->containing_oneof()) {
       scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
@@ skipping 19 matching lines @@
       printer->Print("break;\n");
       printer->Outdent();
     }
     printer->Outdent();
     printer->Print("}\n\n");
   }
 
   printer->Outdent();
   printer->Print("}\n\n");
 
+  WriteGeneratedCodeAttributes(printer);
   printer->Print(
     vars,
     "public $class_name$ Clone() {\n"
     "  return new $class_name$(this);\n"
     "}\n\n");
 }
 
 void MessageGenerator::GenerateFreezingCode(io::Printer* printer) {
 }
 
 void MessageGenerator::GenerateFrameworkMethods(io::Printer* printer) {
     map<string, string> vars;
     vars["class_name"] = class_name();
 
     // Equality
+        WriteGeneratedCodeAttributes(printer);
     printer->Print(
         vars,
         "public override bool Equals(object other) {\n"
         "  return Equals(other as $class_name$);\n"
-        "}\n\n"
+        "}\n\n");
+        WriteGeneratedCodeAttributes(printer);
+        printer->Print(
+            vars,
         "public bool Equals($class_name$ other) {\n"
         "  if (ReferenceEquals(other, null)) {\n"
         "    return false;\n"
         "  }\n"
         "  if (ReferenceEquals(other, this)) {\n"
         "    return true;\n"
         "  }\n");
     printer->Indent();
     for (int i = 0; i < descriptor_->field_count(); i++) {
         scoped_ptr<FieldGeneratorBase> generator(
             CreateFieldGeneratorInternal(descriptor_->field(i)));
         generator->WriteEquals(printer);
     }
     for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
         printer->Print("if ($property_name$Case != other.$property_name$Case) return false;\n",
             "property_name", UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
     }
     printer->Outdent();
     printer->Print(
         "  return true;\n"
         "}\n\n");
 
     // GetHashCode
     // Start with a non-zero value to easily distinguish between null and "empty" messages.
-    printer->Print(
+        WriteGeneratedCodeAttributes(printer);
+        printer->Print(
         "public override int GetHashCode() {\n"
         "  int hash = 1;\n");
     printer->Indent();
     for (int i = 0; i < descriptor_->field_count(); i++) {
         scoped_ptr<FieldGeneratorBase> generator(
             CreateFieldGeneratorInternal(descriptor_->field(i)));
         generator->WriteHash(printer);
     }
     for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
         printer->Print("hash ^= (int) $name$Case_;\n",
             "name", UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false));
     }
     printer->Print("return hash;\n");
     printer->Outdent();
     printer->Print("}\n\n");
 
-    printer->Print(
+        WriteGeneratedCodeAttributes(printer);
+        printer->Print(
         "public override string ToString() {\n"
         "  return pb::JsonFormatter.ToDiagnosticString(this);\n"
         "}\n\n");
 }
 
 void MessageGenerator::GenerateMessageSerializationMethods(io::Printer* printer) {
+  WriteGeneratedCodeAttributes(printer);
   printer->Print(
       "public void WriteTo(pb::CodedOutputStream output) {\n");
   printer->Indent();
 
   // Serialize all the fields
   for (int i = 0; i < fields_by_number().size(); i++) {
     scoped_ptr<FieldGeneratorBase> generator(
       CreateFieldGeneratorInternal(fields_by_number()[i]));
     generator->GenerateSerializationCode(printer);
   }
 
   // TODO(jonskeet): Memoize size of frozen messages?
   printer->Outdent();
   printer->Print(
-    "}\n"
-    "\n"
+        "}\n"
+        "\n");
+  WriteGeneratedCodeAttributes(printer);
+  printer->Print(
     "public int CalculateSize() {\n");
   printer->Indent();
   printer->Print("int size = 0;\n");
   for (int i = 0; i < descriptor_->field_count(); i++) {
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
     generator->GenerateSerializedSizeCode(printer);
   }
   printer->Print("return size;\n");
   printer->Outdent();
   printer->Print("}\n\n");
 }
 
 void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
   // Note:  These are separate from GenerateMessageSerializationMethods()
   //   because they need to be generated even for messages that are optimized
   //   for code size.
   map<string, string> vars;
   vars["class_name"] = class_name();
 
+  WriteGeneratedCodeAttributes(printer);
   printer->Print(
     vars,
     "public void MergeFrom($class_name$ other) {\n");
   printer->Indent();
   printer->Print(
     "if (other == null) {\n"
     "  return;\n"
     "}\n");
   // Merge non-oneof fields
   for (int i = 0; i < descriptor_->field_count(); i++) {
@@ skipping 16 matching lines @@
         vars,
         "case $property_name$OneofCase.$field_property_name$:\n"
         "  $field_property_name$ = other.$field_property_name$;\n"
         "  break;\n");
     }
     printer->Outdent();
     printer->Print("}\n\n");
   }
   printer->Outdent();
   printer->Print("}\n\n");
+  WriteGeneratedCodeAttributes(printer);
   printer->Print("public void MergeFrom(pb::CodedInputStream input) {\n");
   printer->Indent();
   printer->Print(
     "uint tag;\n"
     "while ((tag = input.ReadTag()) != 0) {\n"
     "  switch(tag) {\n");
   printer->Indent();
   printer->Indent();
   printer->Print(
     "default:\n"
@@ skipping 48 matching lines @@
 
 FieldGeneratorBase* MessageGenerator::CreateFieldGeneratorInternal(
     const FieldDescriptor* descriptor) {
   return CreateFieldGenerator(descriptor, GetFieldOrdinal(descriptor), this->options());
 }
 
 }  // namespace csharp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google