third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/compiler/python/python_generator.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 26 matching lines @@
 // In other words, our job is basically to output a Python equivalent
 // of the C++ *Descriptor objects, and fix up all circular references
 // within these objects.
 //
 // Note that the runtime performance of protocol message classes created in
 // this way is expected to be lousy.  The plan is to create an alternate
 // generator that outputs a Python/C extension module that lets
 // performance-minded Python code leverage the fast C++ implementation
 // directly.
 
+#include <algorithm>
 #include <google/protobuf/stubs/hash.h>
 #include <limits>
 #include <map>
 #include <memory>
 #ifndef _SHARED_PTR_H
 #include <google/protobuf/stubs/shared_ptr.h>
 #endif
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 23 matching lines @@
 string StripProto(const string& filename) {
   const char* suffix = HasSuffixString(filename, ".protodevel")
       ? ".protodevel" : ".proto";
   return StripSuffixString(filename, suffix);
 }
 
 
 // Returns the Python module name expected for a given .proto filename.
 string ModuleName(const string& filename) {
   string basename = StripProto(filename);
-  StripString(&basename, "-", '_');
-  StripString(&basename, "/", '.');
+  ReplaceCharacters(&basename, "-", '_');
+  ReplaceCharacters(&basename, "/", '.');
   return basename + "_pb2";
 }
 
 
 // Returns the alias we assign to the module of the given .proto filename
 // when importing. See testPackageInitializationImport in
 // google/protobuf/python/reflection_test.py
 // to see why we need the alias.
 string ModuleAlias(const string& filename) {
   string module_name = ModuleName(filename);
   // We can't have dots in the module name, so we replace each with _dot_.
   // But that could lead to a collision between a.b and a_dot_b, so we also
   // duplicate each underscore.
   GlobalReplaceSubstring("_", "__", &module_name);
   GlobalReplaceSubstring(".", "_dot_", &module_name);
   return module_name;
 }
 
+// Keywords reserved by the Python language.
+const char* const kKeywords[] = {
+    "False",   "None",     "True",     "and",    "as",    "assert", "break",
+    "class",   "continue", "def",      "del",    "elif",  "else",   "except",
+    "finally", "for",      "from",     "global", "if",    "import", "in",
+    "is",      "lambda",   "nonlocal", "not",    "or",    "pass",   "raise",
+    "return",  "try",      "while",    "with",   "yield",
+};
+const char* const* kKeywordsEnd =
+    kKeywords + (sizeof(kKeywords) / sizeof(kKeywords[0]));
 
-// Returns an import statement of form "from X.Y.Z import T" for the given
-// .proto filename.
-string ModuleImportStatement(const string& filename) {
-  string module_name = ModuleName(filename);
-  int last_dot_pos = module_name.rfind('.');
-  if (last_dot_pos == string::npos) {
-    // NOTE(petya): this is not tested as it would require a protocol buffer
-    // outside of any package, and I don't think that is easily achievable.
-    return "import " + module_name;
-  } else {
-    return "from " + module_name.substr(0, last_dot_pos) + " import " +
-        module_name.substr(last_dot_pos + 1);
+bool ContainsPythonKeyword(const string& module_name) {
+  std::vector<string> tokens = Split(module_name, ".");
+  for (int i = 0; i < tokens.size(); ++i) {
+    if (std::find(kKeywords, kKeywordsEnd, tokens[i]) != kKeywordsEnd) {
+      return true;
+    }
   }
+  return false;
 }
 
 
 // Returns the name of all containing types for descriptor,
 // in order from outermost to innermost, followed by descriptor's
 // own name.  Each name is separated by |separator|.
 template <typename DescriptorT>
 string NamePrefixedWithNestedTypes(const DescriptorT& descriptor,
                                    const string& separator) {
   string name = descriptor.name();
@@ skipping 83 matching lines @@
     case FieldDescriptor::CPPTYPE_INT32:
       return SimpleItoa(field.default_value_int32());
     case FieldDescriptor::CPPTYPE_UINT32:
       return SimpleItoa(field.default_value_uint32());
     case FieldDescriptor::CPPTYPE_INT64:
       return SimpleItoa(field.default_value_int64());
     case FieldDescriptor::CPPTYPE_UINT64:
       return SimpleItoa(field.default_value_uint64());
     case FieldDescriptor::CPPTYPE_DOUBLE: {
       double value = field.default_value_double();
-      if (value == numeric_limits<double>::infinity()) {
+      if (value == std::numeric_limits<double>::infinity()) {
         // Python pre-2.6 on Windows does not parse "inf" correctly.  However,
         // a numeric literal that is too big for a double will become infinity.
         return "1e10000";
-      } else if (value == -numeric_limits<double>::infinity()) {
+      } else if (value == -std::numeric_limits<double>::infinity()) {
         // See above.
         return "-1e10000";
       } else if (value != value) {
         // infinity * 0 = nan
         return "(1e10000 * 0)";
       } else {
         return "float(" + SimpleDtoa(value) + ")";
       }
     }
     case FieldDescriptor::CPPTYPE_FLOAT: {
       float value = field.default_value_float();
-      if (value == numeric_limits<float>::infinity()) {
+      if (value == std::numeric_limits<float>::infinity()) {
         // Python pre-2.6 on Windows does not parse "inf" correctly.  However,
         // a numeric literal that is too big for a double will become infinity.
         return "1e10000";
-      } else if (value == -numeric_limits<float>::infinity()) {
+      } else if (value == -std::numeric_limits<float>::infinity()) {
         // See above.
         return "-1e10000";
       } else if (value != value) {
         // infinity - infinity = nan
         return "(1e10000 * 0)";
       } else {
         return "float(" + SimpleFtoa(value) + ")";
       }
     }
     case FieldDescriptor::CPPTYPE_BOOL:
@@ skipping 49 matching lines @@
   // thread-safety constraints of the CodeGenerator interface aren't clear so
   // just be as conservative as possible.  It's easier to relax this later if
   // we need to, but I doubt it will be an issue.
   // TODO(kenton):  The proper thing to do would be to allocate any state on
   //   the stack and use that, so that the Generator class itself does not need
   //   to have any mutable members.  Then it is implicitly thread-safe.
   MutexLock lock(&mutex_);
   file_ = file;
   string module_name = ModuleName(file->name());
   string filename = module_name;
-  StripString(&filename, ".", '/');
+  ReplaceCharacters(&filename, ".", '/');
   filename += ".py";
 
   FileDescriptorProto fdp;
   file_->CopyTo(&fdp);
   fdp.SerializeToString(&file_descriptor_serialized_);
 
 
   google::protobuf::scoped_ptr<io::ZeroCopyOutputStream> output(context->Open(filename));
   GOOGLE_CHECK(output.get());
   io::Printer printer(output.get(), '$');
@@ skipping 24 matching lines @@
   printer.Print(
     "# @@protoc_insertion_point(module_scope)\n");
 
   return !printer.failed();
 }
 
 // Prints Python imports for all modules imported by |file|.
 void Generator::PrintImports() const {
   for (int i = 0; i < file_->dependency_count(); ++i) {
     const string& filename = file_->dependency(i)->name();
-    string import_statement = ModuleImportStatement(filename);
+
+    string module_name = ModuleName(filename);
     string module_alias = ModuleAlias(filename);
-    printer_->Print("$statement$ as $alias$\n", "statement",
-                    import_statement, "alias", module_alias);
+    if (ContainsPythonKeyword(module_name)) {
+      // If the module path contains a Python keyword, we have to quote the
+      // module name and import it using importlib. Otherwise the usual kind of
+      // import statement would result in a syntax error from the presence of
+      // the keyword.
+      printer_->Print("import importlib\n");
+      printer_->Print("$alias$ = importlib.import_module('$name$')\n", "alias",
+                      module_alias, "name", module_name);
+    } else {
+      int last_dot_pos = module_name.rfind('.');
+      string import_statement;
+      if (last_dot_pos == string::npos) {
+        // NOTE(petya): this is not tested as it would require a protocol buffer
+        // outside of any package, and I don't think that is easily achievable.
+        import_statement = "import " + module_name;
+      } else {
+        import_statement = "from " + module_name.substr(0, last_dot_pos) +
+                           " import " + module_name.substr(last_dot_pos + 1);
+      }
+      printer_->Print("$statement$ as $alias$\n", "statement", import_statement,
+                      "alias", module_alias);
+    }
+
     CopyPublicDependenciesAliases(module_alias, file_->dependency(i));
   }
   printer_->Print("\n");
 
   // Print public imports.
   for (int i = 0; i < file_->public_dependency_count(); ++i) {
     string module_name = ModuleName(file_->public_dependency(i)->name());
     printer_->Print("from $module$ import *\n", "module", module_name);
   }
   printer_->Print("\n");
 }
 
 // Prints the single file descriptor for this file.
 void Generator::PrintFileDescriptor() const {
-  map<string, string> m;
+  std::map<string, string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["name"] = file_->name();
   m["package"] = file_->package();
   m["syntax"] = StringifySyntax(file_->syntax());
   const char file_descriptor_template[] =
       "$descriptor_name$ = _descriptor.FileDescriptor(\n"
       "  name='$name$',\n"
       "  package='$package$',\n"
       "  syntax='$syntax$',\n";
   printer_->Print(m, file_descriptor_template);
   printer_->Indent();
   printer_->Print(
 //##!PY25      "serialized_pb=b'$value$'\n",
       "serialized_pb=_b('$value$')\n",  //##PY25
       "value", strings::CHexEscape(file_descriptor_serialized_));
   if (file_->dependency_count() != 0) {
     printer_->Print(",\ndependencies=[");
     for (int i = 0; i < file_->dependency_count(); ++i) {
       string module_alias = ModuleAlias(file_->dependency(i)->name());
       printer_->Print("$module_alias$.DESCRIPTOR,", "module_alias",
                       module_alias);
     }
     printer_->Print("]");
   }
+  if (file_->public_dependency_count() > 0) {
+    printer_->Print(",\npublic_dependencies=[");
+    for (int i = 0; i < file_->public_dependency_count(); ++i) {
+      string module_alias = ModuleAlias(file_->public_dependency(i)->name());
+      printer_->Print("$module_alias$.DESCRIPTOR,", "module_alias",
+                      module_alias);
+    }
+    printer_->Print("]");
+  }
 
   // TODO(falk): Also print options and fix the message_type, enum_type,
   //             service and extension later in the generation.
 
   printer_->Outdent();
   printer_->Print(")\n");
   printer_->Print("_sym_db.RegisterFileDescriptor($name$)\n", "name",
                   kDescriptorKey);
   printer_->Print("\n");
 }
 
 // Prints descriptors and module-level constants for all top-level
 // enums defined in |file|.
 void Generator::PrintTopLevelEnums() const {
-  vector<pair<string, int> > top_level_enum_values;
+  std::vector<std::pair<string, int> > top_level_enum_values;
   for (int i = 0; i < file_->enum_type_count(); ++i) {
     const EnumDescriptor& enum_descriptor = *file_->enum_type(i);
     PrintEnum(enum_descriptor);
     printer_->Print("$name$ = "
                     "enum_type_wrapper.EnumTypeWrapper($descriptor_name$)",
                     "name", enum_descriptor.name(),
                     "descriptor_name",
                     ModuleLevelDescriptorName(enum_descriptor));
     printer_->Print("\n");
 
@@ skipping 16 matching lines @@
 void Generator::PrintAllNestedEnumsInFile() const {
   for (int i = 0; i < file_->message_type_count(); ++i) {
     PrintNestedEnums(*file_->message_type(i));
   }
 }
 
 // Prints a Python statement assigning the appropriate module-level
 // enum name to a Python EnumDescriptor object equivalent to
 // enum_descriptor.
 void Generator::PrintEnum(const EnumDescriptor& enum_descriptor) const {
-  map<string, string> m;
+  std::map<string, string> m;
   string module_level_descriptor_name =
       ModuleLevelDescriptorName(enum_descriptor);
   m["descriptor_name"] = module_level_descriptor_name;
   m["name"] = enum_descriptor.name();
   m["full_name"] = enum_descriptor.full_name();
   m["file"] = kDescriptorKey;
   const char enum_descriptor_template[] =
       "$descriptor_name$ = _descriptor.EnumDescriptor(\n"
       "  name='$name$',\n"
       "  full_name='$full_name$',\n"
@@ skipping 73 matching lines @@
     const ServiceDescriptor& descriptor) const {
   printer_->Print("\n");
   string service_name = ModuleLevelServiceDescriptorName(descriptor);
   string options_string;
   descriptor.options().SerializeToString(&options_string);
 
   printer_->Print(
       "$service_name$ = _descriptor.ServiceDescriptor(\n",
       "service_name", service_name);
   printer_->Indent();
-  map<string, string> m;
+  std::map<string, string> m;
   m["name"] = descriptor.name();
   m["full_name"] = descriptor.full_name();
   m["file"] = kDescriptorKey;
   m["index"] = SimpleItoa(descriptor.index());
   m["options_value"] = OptionsValue("ServiceOptions", options_string);
   const char required_function_arguments[] =
       "name='$name$',\n"
       "full_name='$full_name$',\n"
       "file=$file$,\n"
       "index=$index$,\n"
@@ skipping 75 matching lines @@
 //
 // Mutually recursive with PrintNestedDescriptors().
 void Generator::PrintDescriptor(const Descriptor& message_descriptor) const {
   PrintNestedDescriptors(message_descriptor);
 
   printer_->Print("\n");
   printer_->Print("$descriptor_name$ = _descriptor.Descriptor(\n",
                   "descriptor_name",
                   ModuleLevelDescriptorName(message_descriptor));
   printer_->Indent();
-  map<string, string> m;
+  std::map<string, string> m;
   m["name"] = message_descriptor.name();
   m["full_name"] = message_descriptor.full_name();
   m["file"] = kDescriptorKey;
   const char required_function_arguments[] =
       "name='$name$',\n"
       "full_name='$full_name$',\n"
       "filename=None,\n"
       "file=$file$,\n"
       "containing_type=None,\n";
   printer_->Print(m, required_function_arguments);
@@ skipping 39 matching lines @@
         message_descriptor.extension_range(i);
     printer_->Print("($start$, $end$), ",
                     "start", SimpleItoa(range->start),
                     "end", SimpleItoa(range->end));
   }
   printer_->Print("],\n");
   printer_->Print("oneofs=[\n");
   printer_->Indent();
   for (int i = 0; i < message_descriptor.oneof_decl_count(); ++i) {
     const OneofDescriptor* desc = message_descriptor.oneof_decl(i);
-    map<string, string> m;
+    std::map<string, string> m;
     m["name"] = desc->name();
     m["full_name"] = desc->full_name();
     m["index"] = SimpleItoa(desc->index());
+    string options_string =
+        OptionsValue("OneofOptions", desc->options().SerializeAsString());
+    if (options_string == "None") {
+      m["options"] = "";
+    } else {
+      m["options"] = ", options=" + options_string;
+    }
     printer_->Print(
         m,
         "_descriptor.OneofDescriptor(\n"
         "  name='$name$', full_name='$full_name$',\n"
-        "  index=$index$, containing_type=None, fields=[]),\n");
+        "  index=$index$, containing_type=None, fields=[]$options$),\n");
   }
   printer_->Outdent();
   printer_->Print("],\n");
   // Serialization of proto
   DescriptorProto edp;
   PrintSerializedPbInterval(message_descriptor, edp);
 
   printer_->Outdent();
   printer_->Print(")\n");
 }
 
 // Prints Python Descriptor objects for all nested types contained in
 // message_descriptor.
 //
 // Mutually recursive with PrintDescriptor().
 void Generator::PrintNestedDescriptors(
     const Descriptor& containing_descriptor) const {
   for (int i = 0; i < containing_descriptor.nested_type_count(); ++i) {
     PrintDescriptor(*containing_descriptor.nested_type(i));
   }
 }
 
 // Prints all messages in |file|.
 void Generator::PrintMessages() const {
   for (int i = 0; i < file_->message_type_count(); ++i) {
-    vector<string> to_register;
+    std::vector<string> to_register;
     PrintMessage(*file_->message_type(i), "", &to_register);
     for (int j = 0; j < to_register.size(); ++j) {
       printer_->Print("_sym_db.RegisterMessage($name$)\n", "name",
                       to_register[j]);
     }
     printer_->Print("\n");
   }
 }
 
 // Prints a Python class for the given message descriptor.  We defer to the
 // metaclass to do almost all of the work of actually creating a useful class.
 // The purpose of this function and its many helper functions above is merely
 // to output a Python version of the descriptors, which the metaclass in
 // reflection.py will use to construct the meat of the class itself.
 //
 // Mutually recursive with PrintNestedMessages().
 // Collect nested message names to_register for the symbol_database.
 void Generator::PrintMessage(const Descriptor& message_descriptor,
                              const string& prefix,
-                             vector<string>* to_register) const {
+                             std::vector<string>* to_register) const {
   string qualified_name(prefix + message_descriptor.name());
   to_register->push_back(qualified_name);
   printer_->Print(
       "$name$ = _reflection.GeneratedProtocolMessageType('$name$', "
       "(_message.Message,), dict(\n",
       "name", message_descriptor.name());
   printer_->Indent();
 
   PrintNestedMessages(message_descriptor, qualified_name + ".", to_register);
-  map<string, string> m;
+  std::map<string, string> m;
   m["descriptor_key"] = kDescriptorKey;
   m["descriptor_name"] = ModuleLevelDescriptorName(message_descriptor);
   printer_->Print(m, "$descriptor_key$ = $descriptor_name$,\n");
   printer_->Print("__module__ = '$module_name$'\n",
                   "module_name", ModuleName(file_->name()));
   printer_->Print("# @@protoc_insertion_point(class_scope:$full_name$)\n",
                   "full_name", message_descriptor.full_name());
   printer_->Print("))\n");
   printer_->Outdent();
 }
 
 // Prints all nested messages within |containing_descriptor|.
 // Mutually recursive with PrintMessage().
 void Generator::PrintNestedMessages(const Descriptor& containing_descriptor,
                                     const string& prefix,
-                                    vector<string>* to_register) const {
+                                    std::vector<string>* to_register) const {
   for (int i = 0; i < containing_descriptor.nested_type_count(); ++i) {
     printer_->Print("\n");
     PrintMessage(*containing_descriptor.nested_type(i), prefix, to_register);
     printer_->Print(",\n");
   }
 }
 
 // Recursively fixes foreign fields in all nested types in |descriptor|, then
 // sets the message_type and enum_type of all message and enum fields to point
 // to their respective descriptors.
@@ skipping 12 matching lines @@
     const FieldDescriptor& field_descriptor = *descriptor.field(i);
     FixForeignFieldsInField(&descriptor, field_descriptor, "fields_by_name");
   }
 
   FixContainingTypeInDescriptor(descriptor, containing_descriptor);
   for (int i = 0; i < descriptor.enum_type_count(); ++i) {
     const EnumDescriptor& enum_descriptor = *descriptor.enum_type(i);
     FixContainingTypeInDescriptor(enum_descriptor, &descriptor);
   }
   for (int i = 0; i < descriptor.oneof_decl_count(); ++i) {
-    map<string, string> m;
+    std::map<string, string> m;
     const OneofDescriptor* oneof = descriptor.oneof_decl(i);
     m["descriptor_name"] = ModuleLevelDescriptorName(descriptor);
     m["oneof_name"] = oneof->name();
     for (int j = 0; j < oneof->field_count(); ++j) {
       m["field_name"] = oneof->field(j)->name();
       printer_->Print(
           m,
           "$descriptor_name$.oneofs_by_name['$oneof_name$'].fields.append(\n"
           "  $descriptor_name$.fields_by_name['$field_name$'])\n");
       printer_->Print(
           m,
           "$descriptor_name$.fields_by_name['$field_name$'].containing_oneof = "
           "$descriptor_name$.oneofs_by_name['$oneof_name$']\n");
     }
   }
 }
 
 void Generator::AddMessageToFileDescriptor(const Descriptor& descriptor) const {
-  map<string, string> m;
+  std::map<string, string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["message_name"] = descriptor.name();
   m["message_descriptor_name"] = ModuleLevelDescriptorName(descriptor);
   const char file_descriptor_template[] =
       "$descriptor_name$.message_types_by_name['$message_name$'] = "
       "$message_descriptor_name$\n";
   printer_->Print(m, file_descriptor_template);
 }
 
 void Generator::AddEnumToFileDescriptor(
     const EnumDescriptor& descriptor) const {
-  map<string, string> m;
+  std::map<string, string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["enum_name"] = descriptor.name();
   m["enum_descriptor_name"] = ModuleLevelDescriptorName(descriptor);
   const char file_descriptor_template[] =
       "$descriptor_name$.enum_types_by_name['$enum_name$'] = "
       "$enum_descriptor_name$\n";
   printer_->Print(m, file_descriptor_template);
 }
 
 void Generator::AddExtensionToFileDescriptor(
     const FieldDescriptor& descriptor) const {
-  map<string, string> m;
+  std::map<string, string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["field_name"] = descriptor.name();
   const char file_descriptor_template[] =
       "$descriptor_name$.extensions_by_name['$field_name$'] = "
       "$field_name$\n";
   printer_->Print(m, file_descriptor_template);
 }
 
 // Sets any necessary message_type and enum_type attributes
 // for the Python version of |field|.
 //
 // containing_type may be NULL, in which case this is a module-level field.
 //
 // python_dict_name is the name of the Python dict where we should
 // look the field up in the containing type.  (e.g., fields_by_name
 // or extensions_by_name).  We ignore python_dict_name if containing_type
 // is NULL.
 void Generator::FixForeignFieldsInField(const Descriptor* containing_type,
                                         const FieldDescriptor& field,
                                         const string& python_dict_name) const {
   const string field_referencing_expression = FieldReferencingExpression(
       containing_type, field, python_dict_name);
-  map<string, string> m;
+  std::map<string, string> m;
   m["field_ref"] = field_referencing_expression;
   const Descriptor* foreign_message_type = field.message_type();
   if (foreign_message_type) {
     m["foreign_type"] = ModuleLevelDescriptorName(*foreign_message_type);
     printer_->Print(m, "$field_ref$.message_type = $foreign_type$\n");
   }
   const EnumDescriptor* enum_type = field.enum_type();
   if (enum_type) {
     m["enum_type"] = ModuleLevelDescriptorName(*enum_type);
     printer_->Print(m, "$field_ref$.enum_type = $enum_type$\n");
@@ skipping 78 matching lines @@
 }
 
 void Generator::FixForeignFieldsInExtension(
     const FieldDescriptor& extension_field) const {
   GOOGLE_CHECK(extension_field.is_extension());
   // extension_scope() will be NULL for top-level extensions, which is
   // exactly what FixForeignFieldsInField() wants.
   FixForeignFieldsInField(extension_field.extension_scope(), extension_field,
                           "extensions_by_name");
 
-  map<string, string> m;
+  std::map<string, string> m;
   // Confusingly, for FieldDescriptors that happen to be extensions,
   // containing_type() means "extended type."
   // On the other hand, extension_scope() will give us what we normally
   // mean by containing_type().
   m["extended_message_class"] = ModuleLevelMessageName(
       *extension_field.containing_type());
   m["field"] = FieldReferencingExpression(extension_field.extension_scope(),
                                           extension_field,
                                           "extensions_by_name");
   printer_->Print(m, "$extended_message_class$.RegisterExtension($field$)\n");
@@ skipping 12 matching lines @@
 }
 
 // Returns a Python expression that instantiates a Python EnumValueDescriptor
 // object for the given C++ descriptor.
 void Generator::PrintEnumValueDescriptor(
     const EnumValueDescriptor& descriptor) const {
   // TODO(robinson): Fix up EnumValueDescriptor "type" fields.
   // More circular references.  ::sigh::
   string options_string;
   descriptor.options().SerializeToString(&options_string);
-  map<string, string> m;
+  std::map<string, string> m;
   m["name"] = descriptor.name();
   m["index"] = SimpleItoa(descriptor.index());
   m["number"] = SimpleItoa(descriptor.number());
   m["options"] = OptionsValue("EnumValueOptions", options_string);
   printer_->Print(
       m,
       "_descriptor.EnumValueDescriptor(\n"
       "  name='$name$', index=$index$, number=$number$,\n"
       "  options=$options$,\n"
       "  type=None)");
@@ skipping 12 matching lines @@
     return "_descriptor._ParseOptions(" + full_class_name + "(), _b('"  //##PY25
         + CEscape(serialized_options)+ "'))";  //##PY25
   }
 }
 
 // Prints an expression for a Python FieldDescriptor for |field|.
 void Generator::PrintFieldDescriptor(
     const FieldDescriptor& field, bool is_extension) const {
   string options_string;
   field.options().SerializeToString(&options_string);
-  map<string, string> m;
+  std::map<string, string> m;
   m["name"] = field.name();
   m["full_name"] = field.full_name();
   m["index"] = SimpleItoa(field.index());
   m["number"] = SimpleItoa(field.number());
   m["type"] = SimpleItoa(field.type());
   m["cpp_type"] = SimpleItoa(field.cpp_type());
   m["label"] = SimpleItoa(field.label());
   m["has_default_value"] = field.has_default_value() ? "True" : "False";
   m["default_value"] = StringifyDefaultValue(field);
   m["is_extension"] = is_extension ? "True" : "False";
   m["options"] = OptionsValue("FieldOptions", options_string);
+  m["json_name"] = field.has_json_name() ?
+      ", json_name='" + field.json_name() + "'": "";
   // We always set message_type and enum_type to None at this point, and then
   // these fields in correctly after all referenced descriptors have been
   // defined and/or imported (see FixForeignFieldsInDescriptors()).
   const char field_descriptor_decl[] =
     "_descriptor.FieldDescriptor(\n"
     "  name='$name$', full_name='$full_name$', index=$index$,\n"
     "  number=$number$, type=$type$, cpp_type=$cpp_type$, label=$label$,\n"
     "  has_default_value=$has_default_value$, default_value=$default_value$,\n"
     "  message_type=None, enum_type=None, containing_type=None,\n"
     "  is_extension=$is_extension$, extension_scope=None,\n"
-    "  options=$options$)";
+    "  options=$options$$json_name$)";
   printer_->Print(m, field_descriptor_decl);
 }
 
 // Helper for Print{Fields,Extensions}InDescriptor().
 void Generator::PrintFieldDescriptorsInDescriptor(
     const Descriptor& message_descriptor,
     bool is_extension,
     const string& list_variable_name,
     int (Descriptor::*CountFn)() const,
     const FieldDescriptor* (Descriptor::*GetterFn)(int) const) const {
@@ skipping 145 matching lines @@
     const FieldDescriptor& field = *file_->extension(i);
     FixOptionsForField(field);
   }
   // Prints expressions that set the options for all messages, nested enums,
   // nested extensions and message fields.
   for (int i = 0; i < file_->message_type_count(); ++i) {
     FixOptionsForMessage(*file_->message_type(i));
   }
 }
 
+void Generator::FixOptionsForOneof(const OneofDescriptor& oneof) const {
+  string oneof_options = OptionsValue(
+      "OneofOptions", oneof.options().SerializeAsString());
+  if (oneof_options != "None") {
+    string oneof_name = strings::Substitute(
+        "$0.$1['$2']",
+        ModuleLevelDescriptorName(*oneof.containing_type()),
+        "oneofs_by_name", oneof.name());
+    PrintDescriptorOptionsFixingCode(oneof_name, oneof_options, printer_);
+  }
+}
+
 // Prints expressions that set the options for an enum descriptor and its
 // value descriptors.
 void Generator::FixOptionsForEnum(const EnumDescriptor& enum_descriptor) const {
   string descriptor_name = ModuleLevelDescriptorName(enum_descriptor);
   string enum_options = OptionsValue(
       "EnumOptions", enum_descriptor.options().SerializeAsString());
   if (enum_options != "None") {
     PrintDescriptorOptionsFixingCode(descriptor_name, enum_options, printer_);
   }
   for (int i = 0; i < enum_descriptor.value_count(); ++i) {
@@ skipping 33 matching lines @@
   }
 }
 
 // Prints expressions that set the options for a message and all its inner
 // types (nested messages, nested enums, extensions, fields).
 void Generator::FixOptionsForMessage(const Descriptor& descriptor) const {
   // Nested messages.
   for (int i = 0; i < descriptor.nested_type_count(); ++i) {
     FixOptionsForMessage(*descriptor.nested_type(i));
   }
+  // Oneofs.
+  for (int i = 0; i < descriptor.oneof_decl_count(); ++i) {
+    FixOptionsForOneof(*descriptor.oneof_decl(i));
+  }
   // Enums.
   for (int i = 0; i < descriptor.enum_type_count(); ++i) {
     FixOptionsForEnum(*descriptor.enum_type(i));
   }
   // Fields.
   for (int i = 0; i < descriptor.field_count(); ++i) {
     const FieldDescriptor& field = *descriptor.field(i);
     FixOptionsForField(field);
   }
   // Extensions.
@@ skipping 21 matching lines @@
     printer_->Print("$alias$ = $copy_from$.$alias$\n", "alias", module_alias,
                     "copy_from", copy_from);
     CopyPublicDependenciesAliases(copy_from, file->public_dependency(i));
   }
 }
 
 }  // namespace python
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google