third_party/protobuf: Update to HEAD (5f65ee6ac7)

third_party/protobuf/src/google/protobuf/descriptor.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 51 matching lines @@
 #include <google/protobuf/stubs/once.h>
 #include <google/protobuf/stubs/stringprintf.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/substitute.h>
 #include <google/protobuf/stubs/map_util.h>
 #include <google/protobuf/stubs/stl_util.h>
 
 #undef PACKAGE  // autoheader #defines this.  :(
 
 namespace google {
+
 namespace protobuf {
 
 const FieldDescriptor::CppType
 FieldDescriptor::kTypeToCppTypeMap[MAX_TYPE + 1] = {
   static_cast<CppType>(0),  // 0 is reserved for errors
 
   CPPTYPE_DOUBLE,   // TYPE_DOUBLE
   CPPTYPE_FLOAT,    // TYPE_FLOAT
   CPPTYPE_INT64,    // TYPE_INT64
   CPPTYPE_UINT64,   // TYPE_UINT64
@@ skipping 75 matching lines @@
 static const char * const kNonLinkedWeakMessageReplacementName = "google.protobuf.Empty";
 
 #if !defined(_MSC_VER) || _MSC_VER >= 1900
 const int FieldDescriptor::kMaxNumber;
 const int FieldDescriptor::kFirstReservedNumber;
 const int FieldDescriptor::kLastReservedNumber;
 #endif
 
 namespace {
 
+// Note:  I distrust ctype.h due to locales.
+char ToUpper(char ch) {
+  return (ch >= 'a' && ch <= 'z') ? (ch - 'a' + 'A') : ch;
+}
+
+char ToLower(char ch) {
+  return (ch >= 'A' && ch <= 'Z') ? (ch - 'A' + 'a') : ch;
+}
+
 string ToCamelCase(const string& input, bool lower_first) {
   bool capitalize_next = !lower_first;
   string result;
   result.reserve(input.size());
 
   for (int i = 0; i < input.size(); i++) {
     if (input[i] == '_') {
       capitalize_next = true;
     } else if (capitalize_next) {
-      // Note:  I distrust ctype.h due to locales.
-      if ('a' <= input[i] && input[i] <= 'z') {
-        result.push_back(input[i] - 'a' + 'A');
-      } else {
-        result.push_back(input[i]);
-      }
+      result.push_back(ToUpper(input[i]));
       capitalize_next = false;
     } else {
       result.push_back(input[i]);
     }
   }
 
   // Lower-case the first letter.
-  if (lower_first && !result.empty() && 'A' <= result[0] && result[0] <= 'Z') {
-      result[0] = result[0] - 'A' + 'a';
+  if (lower_first && !result.empty()) {
+    result[0] = ToLower(result[0]);
   }
 
   return result;
 }
 
+string ToJsonName(const string& input) {
+  bool capitalize_next = false;
+  string result;
+  result.reserve(input.size());
+
+  for (int i = 0; i < input.size(); i++) {
+    if (input[i] == '_') {
+      capitalize_next = true;
+    } else if (capitalize_next) {
+      result.push_back(ToUpper(input[i]));
+      capitalize_next = false;
+    } else {
+      result.push_back(input[i]);
+    }
+  }
+
+  return result;
+}
+
+string EnumValueToPascalCase(const string& input) {
+  bool next_upper = true;
+  string result;
+  result.reserve(input.size());
+
+  for (int i = 0; i < input.size(); i++) {
+    if (input[i] == '_') {
+      next_upper = true;
+    } else {
+      if (next_upper) {
+        result.push_back(ToUpper(input[i]));
+      } else {
+        result.push_back(ToLower(input[i]));
+      }
+      next_upper = false;
+    }
+  }
+
+  return result;
+}
+
+// Class to remove an enum prefix from enum values.
+class PrefixRemover {
+ public:
+  PrefixRemover(StringPiece prefix) {
+    // Strip underscores and lower-case the prefix.
+    for (int i = 0; i < prefix.size(); i++) {
+      if (prefix[i] != '_') {
+        prefix_ += ascii_tolower(prefix[i]);
+      }
+    }
+  }
+
+  // Tries to remove the enum prefix from this enum value.
+  // If this is not possible, returns the input verbatim.
+  string MaybeRemove(StringPiece str) {
+    // We can't just lowercase and strip str and look for a prefix.
+    // We need to properly recognize the difference between:
+    //
+    //   enum Foo {
+    //     FOO_BAR_BAZ = 0;
+    //     FOO_BARBAZ = 1;
+    //   }
+    //
+    // This is acceptable (though perhaps not advisable) because even when
+    // we PascalCase, these two will still be distinct (BarBaz vs. Barbaz).
+    size_t i, j;
+
+    // Skip past prefix_ in str if we can.
+    for (i = 0, j = 0; i < str.size() && j < prefix_.size(); i++) {
+      if (str[i] == '_') {
+        continue;
+      }
+
+      if (ascii_tolower(str[i]) != prefix_[j++]) {
+        return str.as_string();
+      }
+    }
+
+    // If we didn't make it through the prefix, we've failed to strip the
+    // prefix.
+    if (j < prefix_.size()) {
+      return str.as_string();
+    }
+
+    // Skip underscores between prefix and further characters.
+    while (i < str.size() && str[i] == '_') {
+      i++;
+    }
+
+    // Enum label can't be the empty string.
+    if (i == str.size()) {
+      return str.as_string();
+    }
+
+    // We successfully stripped the prefix.
+    str.remove_prefix(i);
+    return str.as_string();
+  }
+
+ private:
+  string prefix_;
+};
+
 // A DescriptorPool contains a bunch of hash_maps to implement the
 // various Find*By*() methods.  Since hashtable lookups are O(1), it's
 // most efficient to construct a fixed set of large hash_maps used by
 // all objects in the pool rather than construct one or more small
 // hash_maps for each object.
 //
 // The keys to these hash_maps are (parent, name) or (parent, number)
 // pairs.  Unfortunately STL doesn't provide hash functions for pair<>,
 // so we must invent our own.
 //
 // TODO(kenton):  Use StringPiece rather than const char* in keys?  It would
 //   be a lot cleaner but we'd just have to convert it back to const char*
 //   for the open source release.
 
-typedef pair<const void*, const char*> PointerStringPair;
+typedef std::pair<const void*, const char*> PointerStringPair;
 
 struct PointerStringPairEqual {
   inline bool operator()(const PointerStringPair& a,
                          const PointerStringPair& b) const {
     return a.first == b.first && strcmp(a.second, b.second) == 0;
   }
 };
 
 template<typename PairType>
 struct PointerIntegerPairHash {
   size_t operator()(const PairType& p) const {
     // FIXME(kenton):  What is the best way to compute this hash?  I have
     // no idea!  This seems a bit better than an XOR.
     return reinterpret_cast<intptr_t>(p.first) * ((1 << 16) - 1) + p.second;
   }
 
 #ifdef _MSC_VER
   // Used only by MSVC and platforms where hash_map is not available.
   static const size_t bucket_size = 4;
   static const size_t min_buckets = 8;
 #endif
   inline bool operator()(const PairType& a, const PairType& b) const {
     return a.first < b.first ||
           (a.first == b.first && a.second < b.second);
   }
 };
 
-typedef pair<const Descriptor*, int> DescriptorIntPair;
-typedef pair<const EnumDescriptor*, int> EnumIntPair;
+typedef std::pair<const Descriptor*, int> DescriptorIntPair;
+typedef std::pair<const EnumDescriptor*, int> EnumIntPair;
 
 struct PointerStringPairHash {
   size_t operator()(const PointerStringPair& p) const {
     // FIXME(kenton):  What is the best way to compute this hash?  I have
     // no idea!  This seems a bit better than an XOR.
     hash<const char*> cstring_hash;
     return reinterpret_cast<intptr_t>(p.first) * ((1 << 16) - 1) +
            cstring_hash(p.second);
   }
 
@@ skipping 87 matching lines @@
 typedef hash_map<DescriptorIntPair, const FieldDescriptor*,
                  PointerIntegerPairHash<DescriptorIntPair> >
   FieldsByNumberMap;
 typedef hash_map<EnumIntPair, const EnumValueDescriptor*,
                  PointerIntegerPairHash<EnumIntPair> >
   EnumValuesByNumberMap;
 // This is a map rather than a hash_map, since we use it to iterate
 // through all the extensions that extend a given Descriptor, and an
 // ordered data structure that implements lower_bound is convenient
 // for that.
-typedef map<DescriptorIntPair, const FieldDescriptor*>
+typedef std::map<DescriptorIntPair, const FieldDescriptor*>
   ExtensionsGroupedByDescriptorMap;
 typedef hash_map<string, const SourceCodeInfo_Location*> LocationsByPathMap;
 
-set<string>* allowed_proto3_extendees_ = NULL;
+std::set<string>* allowed_proto3_extendees_ = NULL;
 GOOGLE_PROTOBUF_DECLARE_ONCE(allowed_proto3_extendees_init_);
 
 void DeleteAllowedProto3Extendee() {
   delete allowed_proto3_extendees_;
 }
 
 void InitAllowedProto3Extendee() {
-  allowed_proto3_extendees_ = new set<string>;
+  allowed_proto3_extendees_ = new std::set<string>;
   const char* kOptionNames[] = {
       "FileOptions",      "MessageOptions", "FieldOptions", "EnumOptions",
       "EnumValueOptions", "ServiceOptions", "MethodOptions"};
   for (int i = 0; i < GOOGLE_ARRAYSIZE(kOptionNames); ++i) {
     // descriptor.proto has a different package name in opensource. We allow
     // both so the opensource protocol compiler can also compile internal
     // proto3 files with custom options. See: b/27567912
     allowed_proto3_extendees_->insert(string("google.protobuf.") +
                                       kOptionNames[i]);
     // Split the word to trick the opensource processing scripts so they
@@ skipping 57 matching lines @@
   // checkpoints that were pushed onto the stack after it and marked as cleared.
   void ClearLastCheckpoint();
 
   // Roll back the Tables to the state of the checkpoint at the top of the
   // stack, removing everything that was added after that point.
   void RollbackToLastCheckpoint();
 
   // The stack of files which are currently being built.  Used to detect
   // cyclic dependencies when loading files from a DescriptorDatabase.  Not
   // used when fallback_database_ == NULL.
-  vector<string> pending_files_;
+  std::vector<string> pending_files_;
 
   // A set of files which we have tried to load from the fallback database
   // and encountered errors.  We will not attempt to load them again during
   // execution of the current public API call, but for compatibility with
   // legacy clients, this is cleared at the beginning of each public API call.
   // Not used when fallback_database_ == NULL.
   hash_set<string> known_bad_files_;
 
   // A set of symbols which we have tried to load from the fallback database
   // and encountered errors. We will not attempt to load them again during
@@ skipping 17 matching lines @@
   // declaring Symbol in descriptor.h, which would drag all kinds of other
   // stuff into the header.  Yay C++.
   Symbol FindByNameHelper(
     const DescriptorPool* pool, const string& name);
 
   // These return NULL if not found.
   inline const FileDescriptor* FindFile(const string& key) const;
   inline const FieldDescriptor* FindExtension(const Descriptor* extendee,
                                               int number);
   inline void FindAllExtensions(const Descriptor* extendee,
-                                vector<const FieldDescriptor*>* out) const;
+                                std::vector<const FieldDescriptor*>* out) const;
 
   // -----------------------------------------------------------------
   // Adding items.
 
   // These add items to the corresponding tables.  They return false if
   // the key already exists in the table.  For AddSymbol(), the string passed
   // in must be one that was constructed using AllocateString(), as it will
   // be used as a key in the symbols_by_name_ map without copying.
   bool AddSymbol(const string& full_name, Symbol symbol);
   bool AddFile(const FileDescriptor* file);
@@ skipping 19 matching lines @@
   // Allocate a protocol message object.  Some older versions of GCC have
   // trouble understanding explicit template instantiations in some cases, so
   // in those cases we have to pass a dummy pointer of the right type as the
   // parameter instead of specifying the type explicitly.
   template<typename Type> Type* AllocateMessage(Type* dummy = NULL);
 
   // Allocate a FileDescriptorTables object.
   FileDescriptorTables* AllocateFileTables();
 
  private:
-  vector<string*> strings_;    // All strings in the pool.
-  vector<Message*> messages_;  // All messages in the pool.
-  vector<FileDescriptorTables*> file_tables_;  // All file tables in the pool.
-  vector<void*> allocations_;  // All other memory allocated in the pool.
+  std::vector<string*> strings_;    // All strings in the pool.
+  std::vector<Message*> messages_;  // All messages in the pool.
+  std::vector<FileDescriptorTables*>
+      file_tables_;                 // All file tables in the pool.
+  std::vector<void*> allocations_;  // All other memory allocated in the pool.
 
   SymbolsByNameMap      symbols_by_name_;
   FilesByNameMap        files_by_name_;
   ExtensionsGroupedByDescriptorMap extensions_;
 
   struct CheckPoint {
     explicit CheckPoint(const Tables* tables)
       : strings_before_checkpoint(tables->strings_.size()),
         messages_before_checkpoint(tables->messages_.size()),
         file_tables_before_checkpoint(tables->file_tables_.size()),
         allocations_before_checkpoint(tables->allocations_.size()),
         pending_symbols_before_checkpoint(
             tables->symbols_after_checkpoint_.size()),
         pending_files_before_checkpoint(
             tables->files_after_checkpoint_.size()),
         pending_extensions_before_checkpoint(
             tables->extensions_after_checkpoint_.size()) {
     }
     int strings_before_checkpoint;
     int messages_before_checkpoint;
     int file_tables_before_checkpoint;
     int allocations_before_checkpoint;
     int pending_symbols_before_checkpoint;
     int pending_files_before_checkpoint;
     int pending_extensions_before_checkpoint;
   };
-  vector<CheckPoint> checkpoints_;
-  vector<const char*      > symbols_after_checkpoint_;
-  vector<const char*      > files_after_checkpoint_;
-  vector<DescriptorIntPair> extensions_after_checkpoint_;
+  std::vector<CheckPoint> checkpoints_;
+  std::vector<const char*      > symbols_after_checkpoint_;
+  std::vector<const char*      > files_after_checkpoint_;
+  std::vector<DescriptorIntPair> extensions_after_checkpoint_;
 
   // Allocate some bytes which will be reclaimed when the pool is
   // destroyed.
   void* AllocateBytes(int size);
 };
 
 // Contains tables specific to a particular file.  These tables are not
 // modified once the file has been constructed, so they need not be
 // protected by a mutex.  This makes operations that depend only on the
 // contents of a single file -- e.g. Descriptor::FindFieldByName() --
@@ skipping 46 matching lines @@
   bool AddFieldByNumber(const FieldDescriptor* field);
   bool AddEnumValueByNumber(const EnumValueDescriptor* value);
 
   // Adds the field to the lowercase_name and camelcase_name maps.  Never
   // fails because we allow duplicates; the first field by the name wins.
   void AddFieldByStylizedNames(const FieldDescriptor* field);
 
   // Populates p->first->locations_by_path_ from p->second.
   // Unusual signature dictated by GoogleOnceDynamic.
   static void BuildLocationsByPath(
-      pair<const FileDescriptorTables*, const SourceCodeInfo*>* p);
+      std::pair<const FileDescriptorTables*, const SourceCodeInfo*>* p);
 
   // Returns the location denoted by the specified path through info,
   // or NULL if not found.
   // The value of info must be that of the corresponding FileDescriptor.
   // (Conceptually a pure function, but stateful as an optimisation.)
   const SourceCodeInfo_Location* GetSourceLocation(
-      const vector<int>& path, const SourceCodeInfo* info) const;
+      const std::vector<int>& path, const SourceCodeInfo* info) const;
 
  private:
   SymbolsByParentMap    symbols_by_parent_;
   FieldsByNameMap       fields_by_lowercase_name_;
   FieldsByNameMap       fields_by_camelcase_name_;
   FieldsByNumberMap     fields_by_number_;       // Not including extensions.
   EnumValuesByNumberMap enum_values_by_number_;
   mutable EnumValuesByNumberMap unknown_enum_values_by_number_
       GOOGLE_GUARDED_BY(unknown_enum_values_mu_);
 
@@ skipping 260 matching lines @@
   }
 }
 
 
 inline const FieldDescriptor* DescriptorPool::Tables::FindExtension(
     const Descriptor* extendee, int number) {
   return FindPtrOrNull(extensions_, std::make_pair(extendee, number));
 }
 
 inline void DescriptorPool::Tables::FindAllExtensions(
-    const Descriptor* extendee, vector<const FieldDescriptor*>* out) const {
+    const Descriptor* extendee,
+    std::vector<const FieldDescriptor*>* out) const {
   ExtensionsGroupedByDescriptorMap::const_iterator it =
       extensions_.lower_bound(std::make_pair(extendee, 0));
   for (; it != extensions_.end() && it->first.first == extendee; ++it) {
     out->push_back(it->second);
   }
 }
 
 // -------------------------------------------------------------------
 
 bool DescriptorPool::Tables::AddSymbol(
@@ skipping 99 matching lines @@
   // internal use we could easily plug in one of our existing memory pool
   // allocators...
   if (size == 0) return NULL;
 
   void* result = operator new(size);
   allocations_.push_back(result);
   return result;
 }
 
 void FileDescriptorTables::BuildLocationsByPath(
-    pair<const FileDescriptorTables*, const SourceCodeInfo*>* p) {
+    std::pair<const FileDescriptorTables*, const SourceCodeInfo*>* p) {
   for (int i = 0, len = p->second->location_size(); i < len; ++i) {
     const SourceCodeInfo_Location* loc = &p->second->location().Get(i);
     p->first->locations_by_path_[Join(loc->path(), ",")] = loc;
   }
 }
 
 const SourceCodeInfo_Location* FileDescriptorTables::GetSourceLocation(
-    const vector<int>& path, const SourceCodeInfo* info) const {
-  pair<const FileDescriptorTables*, const SourceCodeInfo*> p(
+    const std::vector<int>& path, const SourceCodeInfo* info) const {
+  std::pair<const FileDescriptorTables*, const SourceCodeInfo*> p(
       std::make_pair(this, info));
   locations_by_path_once_.Init(&FileDescriptorTables::BuildLocationsByPath, &p);
   return FindPtrOrNull(locations_by_path_, Join(path, ","));
 }
 
 // ===================================================================
 // DescriptorPool
 
 DescriptorPool::ErrorCollector::~ErrorCollector() {}
 
@@ skipping 81 matching lines @@
 }
 
 }  // anonymous namespace
 
 const DescriptorPool* DescriptorPool::generated_pool() {
   InitGeneratedPoolOnce();
   return generated_pool_;
 }
 
 
+
 DescriptorPool* DescriptorPool::internal_generated_pool() {
   InitGeneratedPoolOnce();
   return generated_pool_;
 }
 
 void DescriptorPool::InternalAddGeneratedFile(
     const void* encoded_file_descriptor, int size) {
   // So, this function is called in the process of initializing the
   // descriptors for generated proto classes.  Each generated .pb.cc file
   // has an internal procedure called AddDescriptors() which is called at
@@ skipping 138 matching lines @@
   if (TryFindExtensionInFallbackDatabase(extendee, number)) {
     result = tables_->FindExtension(extendee, number);
     if (result != NULL) {
       return result;
     }
   }
   return NULL;
 }
 
 void DescriptorPool::FindAllExtensions(
-    const Descriptor* extendee, vector<const FieldDescriptor*>* out) const {
+    const Descriptor* extendee,
+    std::vector<const FieldDescriptor*>* out) const {
   MutexLockMaybe lock(mutex_);
   tables_->known_bad_symbols_.clear();
   tables_->known_bad_files_.clear();
 
   // Initialize tables_->extensions_ from the fallback database first
   // (but do this only once per descriptor).
   if (fallback_database_ != NULL &&
       tables_->extensions_loaded_from_db_.count(extendee) == 0) {
-    vector<int> numbers;
+    std::vector<int> numbers;
     if (fallback_database_->FindAllExtensionNumbers(extendee->full_name(),
                                                     &numbers)) {
       for (int i = 0; i < numbers.size(); ++i) {
         int number = numbers[i];
         if (tables_->FindExtension(extendee, number) == NULL) {
           TryFindExtensionInFallbackDatabase(extendee, number);
         }
       }
       tables_->extensions_loaded_from_db_.insert(extendee);
     }
@@ skipping 577 matching lines @@
     proto->mutable_options()->CopyFrom(options());
   }
 }
 
 void FieldDescriptor::CopyJsonNameTo(FieldDescriptorProto* proto) const {
   proto->set_json_name(json_name());
 }
 
 void OneofDescriptor::CopyTo(OneofDescriptorProto* proto) const {
   proto->set_name(name());
+  if (&options() != &OneofOptions::default_instance()) {
+    proto->mutable_options()->CopyFrom(options());
+  }
 }
 
 void EnumDescriptor::CopyTo(EnumDescriptorProto* proto) const {
   proto->set_name(name());
 
   for (int i = 0; i < value_count(); i++) {
     value(i)->CopyTo(proto->add_value());
   }
 
   if (&options() != &EnumOptions::default_instance()) {
@@ skipping 44 matching lines @@
   }
   if (server_streaming_) {
     proto->set_server_streaming(true);
   }
 }
 
 // DebugString methods ===============================================
 
 namespace {
 
-// Used by each of the option formatters.
-bool RetrieveOptions(int depth,
-                     const Message &options,
-                     vector<string> *option_entries) {
+bool RetrieveOptionsAssumingRightPool(int depth, const Message& options,
+                                      std::vector<string>* option_entries) {
   option_entries->clear();
   const Reflection* reflection = options.GetReflection();
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   reflection->ListFields(options, &fields);
   for (int i = 0; i < fields.size(); i++) {
     int count = 1;
     bool repeated = false;
     if (fields[i]->is_repeated()) {
       count = reflection->FieldSize(options, fields[i]);
       repeated = true;
     }
     for (int j = 0; j < count; j++) {
       string fieldval;
@@ skipping 16 matching lines @@
         name = "(." + fields[i]->full_name() + ")";
       } else {
         name = fields[i]->name();
       }
       option_entries->push_back(name + " = " + fieldval);
     }
   }
   return !option_entries->empty();
 }
 
+// Used by each of the option formatters.
+bool RetrieveOptions(int depth, const Message& options,
+                     const DescriptorPool* pool,
+                     std::vector<string>* option_entries) {
+  // When printing custom options for a descriptor, we must use an options
+  // message built on top of the same DescriptorPool where the descriptor
+  // is coming from. This is to ensure we are interpreting custom options
+  // against the right pool.
+  if (options.GetDescriptor()->file()->pool() == pool) {
+    return RetrieveOptionsAssumingRightPool(depth, options, option_entries);
+  } else {
+    const Descriptor* option_descriptor =
+        pool->FindMessageTypeByName(options.GetDescriptor()->full_name());
+    if (option_descriptor == NULL) {
+      // google/protobuf/descriptor.proto is not in the pool. This means no
+      // custom options are used so we are safe to proceed with the compiled
+      // options message type.
+      return RetrieveOptionsAssumingRightPool(depth, options, option_entries);
+    }
+    DynamicMessageFactory factory;
+    google::protobuf::scoped_ptr<Message> dynamic_options(
+        factory.GetPrototype(option_descriptor)->New());
+    if (dynamic_options->ParseFromString(options.SerializeAsString())) {
+      return RetrieveOptionsAssumingRightPool(depth, *dynamic_options,
+                                              option_entries);
+    } else {
+      GOOGLE_LOG(ERROR) << "Found invalid proto option data for: "
+                 << options.GetDescriptor()->full_name();
+      return RetrieveOptionsAssumingRightPool(depth, options, option_entries);
+    }
+  }
+}
+
 // Formats options that all appear together in brackets. Does not include
 // brackets.
-bool FormatBracketedOptions(int depth, const Message &options, string *output) {
-  vector<string> all_options;
-  if (RetrieveOptions(depth, options, &all_options)) {
+bool FormatBracketedOptions(int depth, const Message& options,
+                            const DescriptorPool* pool, string* output) {
+  std::vector<string> all_options;
+  if (RetrieveOptions(depth, options, pool, &all_options)) {
     output->append(Join(all_options, ", "));
   }
   return !all_options.empty();
 }
 
 // Formats options one per line
-bool FormatLineOptions(int depth, const Message &options, string *output) {
+bool FormatLineOptions(int depth, const Message& options,
+                       const DescriptorPool* pool, string* output) {
   string prefix(depth * 2, ' ');
-  vector<string> all_options;
-  if (RetrieveOptions(depth, options, &all_options)) {
+  std::vector<string> all_options;
+  if (RetrieveOptions(depth, options, pool, &all_options)) {
     for (int i = 0; i < all_options.size(); i++) {
       strings::SubstituteAndAppend(output, "$0option $1;\n",
                                    prefix, all_options[i]);
     }
   }
   return !all_options.empty();
 }
 
 class SourceLocationCommentPrinter {
  public:
   template<typename DescType>
   SourceLocationCommentPrinter(const DescType* desc,
                                const string& prefix,
                                const DebugStringOptions& options)
       : options_(options), prefix_(prefix) {
     // Perform the SourceLocation lookup only if we're including user comments,
     // because the lookup is fairly expensive.
     have_source_loc_ = options.include_comments &&
         desc->GetSourceLocation(&source_loc_);
   }
   SourceLocationCommentPrinter(const FileDescriptor* file,
-                               const vector<int>& path,
+                               const std::vector<int>& path,
                                const string& prefix,
                                const DebugStringOptions& options)
       : options_(options), prefix_(prefix) {
     // Perform the SourceLocation lookup only if we're including user comments,
     // because the lookup is fairly expensive.
     have_source_loc_ = options.include_comments &&
         file->GetSourceLocation(path, &source_loc_);
   }
   void AddPreComment(string* output) {
     if (have_source_loc_) {
@@ skipping 12 matching lines @@
     if (have_source_loc_ && source_loc_.trailing_comments.size() > 0) {
       *output += FormatComment(source_loc_.trailing_comments);
     }
   }
 
   // Format comment such that each line becomes a full-line C++-style comment in
   // the DebugString() output.
   string FormatComment(const string& comment_text) {
     string stripped_comment = comment_text;
     StripWhitespace(&stripped_comment);
-    vector<string> lines = Split(stripped_comment, "\n");
+    std::vector<string> lines = Split(stripped_comment, "\n");
     string output;
     for (int i = 0; i < lines.size(); ++i) {
       const string& line = lines[i];
       strings::SubstituteAndAppend(&output, "$0// $1\n", prefix_, line);
     }
     return output;
   }
 
  private:
 
   bool have_source_loc_;
   SourceLocation source_loc_;
   DebugStringOptions options_;
   string prefix_;
 };
 
 }  // anonymous namespace
 
 string FileDescriptor::DebugString() const {
   DebugStringOptions options;  // default options
   return DebugStringWithOptions(options);
 }
 
 string FileDescriptor::DebugStringWithOptions(
     const DebugStringOptions& debug_string_options) const {
   string contents;
   {
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(FileDescriptorProto::kSyntaxFieldNumber);
     SourceLocationCommentPrinter syntax_comment(
         this, path, "", debug_string_options);
     syntax_comment.AddPreComment(&contents);
     strings::SubstituteAndAppend(&contents, "syntax = \"$0\";\n\n",
                                  SyntaxName(syntax()));
     syntax_comment.AddPostComment(&contents);
   }
 
   SourceLocationCommentPrinter
       comment_printer(this, "", debug_string_options);
   comment_printer.AddPreComment(&contents);
 
-  set<int> public_dependencies;
-  set<int> weak_dependencies;
+  std::set<int> public_dependencies;
+  std::set<int> weak_dependencies;
   public_dependencies.insert(public_dependencies_,
                              public_dependencies_ + public_dependency_count_);
   weak_dependencies.insert(weak_dependencies_,
                            weak_dependencies_ + weak_dependency_count_);
 
   for (int i = 0; i < dependency_count(); i++) {
     if (public_dependencies.count(i) > 0) {
       strings::SubstituteAndAppend(&contents, "import public \"$0\";\n",
                                    dependency(i)->name());
     } else if (weak_dependencies.count(i) > 0) {
       strings::SubstituteAndAppend(&contents, "import weak \"$0\";\n",
                                    dependency(i)->name());
     } else {
       strings::SubstituteAndAppend(&contents, "import \"$0\";\n",
                                    dependency(i)->name());
     }
   }
 
   if (!package().empty()) {
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(FileDescriptorProto::kPackageFieldNumber);
     SourceLocationCommentPrinter package_comment(
         this, path, "", debug_string_options);
     package_comment.AddPreComment(&contents);
     strings::SubstituteAndAppend(&contents, "package $0;\n\n", package());
     package_comment.AddPostComment(&contents);
   }
 
-  if (FormatLineOptions(0, options(), &contents)) {
+  if (FormatLineOptions(0, options(), pool(), &contents)) {
     contents.append("\n");  // add some space if we had options
   }
 
   for (int i = 0; i < enum_type_count(); i++) {
     enum_type(i)->DebugString(0, &contents, debug_string_options);
     contents.append("\n");
   }
 
   // Find all the 'group' type extensions; we will not output their nested
   // definitions (those will be done with their group field descriptor).
-  set<const Descriptor*> groups;
+  std::set<const Descriptor*> groups;
   for (int i = 0; i < extension_count(); i++) {
     if (extension(i)->type() == FieldDescriptor::TYPE_GROUP) {
       groups.insert(extension(i)->message_type());
     }
   }
 
   for (int i = 0; i < message_type_count(); i++) {
     if (groups.count(message_type(i)) == 0) {
       message_type(i)->DebugString(0, &contents, debug_string_options,
                                    /* include_opening_clause */ true);
@@ skipping 49 matching lines @@
 
   SourceLocationCommentPrinter
       comment_printer(this, prefix, debug_string_options);
   comment_printer.AddPreComment(contents);
 
   if (include_opening_clause) {
     strings::SubstituteAndAppend(contents, "$0message $1", prefix, name());
   }
   contents->append(" {\n");
 
-  FormatLineOptions(depth, options(), contents);
+  FormatLineOptions(depth, options(), file()->pool(), contents);
 
   // Find all the 'group' types for fields and extensions; we will not output
   // their nested definitions (those will be done with their group field
   // descriptor).
-  set<const Descriptor*> groups;
+  std::set<const Descriptor*> groups;
   for (int i = 0; i < field_count(); i++) {
     if (field(i)->type() == FieldDescriptor::TYPE_GROUP) {
       groups.insert(field(i)->message_type());
     }
   }
   for (int i = 0; i < extension_count(); i++) {
     if (extension(i)->type() == FieldDescriptor::TYPE_GROUP) {
       groups.insert(extension(i)->message_type());
     }
   }
@@ skipping 112 matching lines @@
   // Special case map fields.
   if (is_map()) {
     strings::SubstituteAndAppend(
         &field_type, "map<$0, $1>",
         message_type()->field(0)->FieldTypeNameDebugString(),
         message_type()->field(1)->FieldTypeNameDebugString());
   } else {
     field_type = FieldTypeNameDebugString();
   }
 
+  bool print_label = true;
+  // Determine whether to omit label:
+  //   1. For an optional field, omit label if it's in oneof or in proto3.
+  //   2. For a repeated field, omit label if it's a map.
+  if (is_optional() && (print_label_flag == OMIT_LABEL ||
+                        file()->syntax() == FileDescriptor::SYNTAX_PROTO3)) {
+    print_label = false;
+  } else if (is_map()) {
+    print_label = false;
+  }
   string label;
-  if (print_label_flag == PRINT_LABEL && !is_map()) {
+  if (print_label) {
     label = kLabelToName[this->label()];
     label.push_back(' ');
   }
 
   SourceLocationCommentPrinter
       comment_printer(this, prefix, debug_string_options);
   comment_printer.AddPreComment(contents);
 
   strings::SubstituteAndAppend(contents, "$0$1$2 $3 = $4",
                                prefix,
                                label,
                                field_type,
                                type() == TYPE_GROUP ? message_type()->name() :
                                                       name(),
                                number());
 
   bool bracketed = false;
   if (has_default_value()) {
     bracketed = true;
     strings::SubstituteAndAppend(contents, " [default = $0",
                                  DefaultValueAsString(true));
   }
+  if (has_json_name_) {
+    if (!bracketed) {
+      bracketed = true;
+      contents->append("[");
+    } else {
+      contents->append(", ");
+    }
+    contents->append("json_name = \"");
+    contents->append(CEscape(json_name()));
+    contents->append("\"");
+  }
 
   string formatted_options;
-  if (FormatBracketedOptions(depth, options(), &formatted_options)) {
+  if (FormatBracketedOptions(depth, options(), file()->pool(),
+                             &formatted_options)) {
     contents->append(bracketed ? ", " : " [");
     bracketed = true;
     contents->append(formatted_options);
   }
 
   if (bracketed) {
     contents->append("]");
   }
 
   if (type() == TYPE_GROUP) {
@@ skipping 23 matching lines @@
 }
 
 void OneofDescriptor::DebugString(int depth, string* contents,
                                   const DebugStringOptions&
                                   debug_string_options) const {
   string prefix(depth * 2, ' ');
   ++depth;
   SourceLocationCommentPrinter
       comment_printer(this, prefix, debug_string_options);
   comment_printer.AddPreComment(contents);
-  strings::SubstituteAndAppend(
-      contents, "$0 oneof $1 {", prefix, name());
+  strings::SubstituteAndAppend(contents, "$0oneof $1 {", prefix, name());
+
+  FormatLineOptions(depth, options(), containing_type()->file()->pool(),
+                    contents);
+
   if (debug_string_options.elide_oneof_body) {
     contents->append(" ... }\n");
   } else {
+    contents->append("\n");
     for (int i = 0; i < field_count(); i++) {
       field(i)->DebugString(depth, FieldDescriptor::OMIT_LABEL, contents,
                             debug_string_options);
     }
     strings::SubstituteAndAppend(contents, "$0}\n", prefix);
   }
   comment_printer.AddPostComment(contents);
 }
 
 string EnumDescriptor::DebugString() const {
@@ skipping 14 matching lines @@
   string prefix(depth * 2, ' ');
   ++depth;
 
   SourceLocationCommentPrinter
       comment_printer(this, prefix, debug_string_options);
   comment_printer.AddPreComment(contents);
 
   strings::SubstituteAndAppend(contents, "$0enum $1 {\n",
                                prefix, name());
 
-  FormatLineOptions(depth, options(), contents);
+  FormatLineOptions(depth, options(), file()->pool(), contents);
 
   for (int i = 0; i < value_count(); i++) {
     value(i)->DebugString(depth, contents, debug_string_options);
   }
   strings::SubstituteAndAppend(contents, "$0}\n", prefix);
 
   comment_printer.AddPostComment(contents);
 }
 
 string EnumValueDescriptor::DebugString() const {
@@ skipping 14 matching lines @@
   string prefix(depth * 2, ' ');
 
   SourceLocationCommentPrinter
       comment_printer(this, prefix, debug_string_options);
   comment_printer.AddPreComment(contents);
 
   strings::SubstituteAndAppend(contents, "$0$1 = $2",
                                prefix, name(), number());
 
   string formatted_options;
-  if (FormatBracketedOptions(depth, options(), &formatted_options)) {
+  if (FormatBracketedOptions(depth, options(), type()->file()->pool(),
+                             &formatted_options)) {
     strings::SubstituteAndAppend(contents, " [$0]", formatted_options);
   }
   contents->append(";\n");
 
   comment_printer.AddPostComment(contents);
 }
 
 string ServiceDescriptor::DebugString() const {
   DebugStringOptions options;  // default values
   return DebugStringWithOptions(options);
 }
 
 string ServiceDescriptor::DebugStringWithOptions(
     const DebugStringOptions& options) const {
   string contents;
   DebugString(&contents, options);
   return contents;
 }
 
 void ServiceDescriptor::DebugString(string *contents,
                                     const DebugStringOptions&
                                     debug_string_options) const {
   SourceLocationCommentPrinter
       comment_printer(this, /* prefix */ "", debug_string_options);
   comment_printer.AddPreComment(contents);
 
   strings::SubstituteAndAppend(contents, "service $0 {\n", name());
 
-  FormatLineOptions(1, options(), contents);
+  FormatLineOptions(1, options(), file()->pool(), contents);
 
   for (int i = 0; i < method_count(); i++) {
     method(i)->DebugString(1, contents, debug_string_options);
   }
 
   contents->append("}\n");
 
   comment_printer.AddPostComment(contents);
 }
 
@@ skipping 20 matching lines @@
   comment_printer.AddPreComment(contents);
 
   strings::SubstituteAndAppend(contents, "$0rpc $1($4.$2) returns ($5.$3)",
                                prefix, name(),
                                input_type()->full_name(),
                                output_type()->full_name(),
                                client_streaming() ? "stream " : "",
                                server_streaming() ? "stream " : "");
 
   string formatted_options;
-  if (FormatLineOptions(depth, options(), &formatted_options)) {
+  if (FormatLineOptions(depth, options(), service()->file()->pool(),
+                        &formatted_options)) {
     strings::SubstituteAndAppend(contents, " {\n$0$1}\n",
                                  formatted_options, prefix);
   } else {
     contents->append(";\n");
   }
 
   comment_printer.AddPostComment(contents);
 }
 
 
 // Location methods ===============================================
 
-bool FileDescriptor::GetSourceLocation(const vector<int>& path,
+bool FileDescriptor::GetSourceLocation(const std::vector<int>& path,
                                        SourceLocation* out_location) const {
   GOOGLE_CHECK_NOTNULL(out_location);
   if (source_code_info_) {
     if (const SourceCodeInfo_Location* loc =
         tables_->GetSourceLocation(path, source_code_info_)) {
       const RepeatedField<int32>& span = loc->span();
       if (span.size() == 3 || span.size() == 4) {
         out_location->start_line   = span.Get(0);
         out_location->start_column = span.Get(1);
         out_location->end_line     = span.Get(span.size() == 3 ? 0 : 2);
         out_location->end_column   = span.Get(span.size() - 1);
 
         out_location->leading_comments = loc->leading_comments();
         out_location->trailing_comments = loc->trailing_comments();
         out_location->leading_detached_comments.assign(
             loc->leading_detached_comments().begin(),
             loc->leading_detached_comments().end());
         return true;
       }
     }
   }
   return false;
 }
 
 bool FileDescriptor::GetSourceLocation(SourceLocation* out_location) const {
-  vector<int> path;  // empty path for root FileDescriptor
+  std::vector<int> path;  // empty path for root FileDescriptor
   return GetSourceLocation(path, out_location);
 }
 
 bool FieldDescriptor::is_packed() const {
   if (!is_packable()) return false;
   if (file_->syntax() == FileDescriptor::SYNTAX_PROTO2) {
     return (options_ != NULL) && options_->packed();
   } else {
     return options_ == NULL || !options_->has_packed() || options_->packed();
   }
 }
 
 bool Descriptor::GetSourceLocation(SourceLocation* out_location) const {
-  vector<int> path;
+  std::vector<int> path;
   GetLocationPath(&path);
   return file()->GetSourceLocation(path, out_location);
 }
 
 bool FieldDescriptor::GetSourceLocation(SourceLocation* out_location) const {
-  vector<int> path;
+  std::vector<int> path;
   GetLocationPath(&path);
   return file()->GetSourceLocation(path, out_location);
 }
 
 bool OneofDescriptor::GetSourceLocation(SourceLocation* out_location) const {
-  vector<int> path;
+  std::vector<int> path;
   GetLocationPath(&path);
   return containing_type()->file()->GetSourceLocation(path, out_location);
 }
 
 bool EnumDescriptor::GetSourceLocation(SourceLocation* out_location) const {
-  vector<int> path;
+  std::vector<int> path;
   GetLocationPath(&path);
   return file()->GetSourceLocation(path, out_location);
 }
 
 bool MethodDescriptor::GetSourceLocation(SourceLocation* out_location) const {
-  vector<int> path;
+  std::vector<int> path;
   GetLocationPath(&path);
   return service()->file()->GetSourceLocation(path, out_location);
 }
 
 bool ServiceDescriptor::GetSourceLocation(SourceLocation* out_location) const {
-  vector<int> path;
+  std::vector<int> path;
   GetLocationPath(&path);
   return file()->GetSourceLocation(path, out_location);
 }
 
 bool EnumValueDescriptor::GetSourceLocation(
     SourceLocation* out_location) const {
-  vector<int> path;
+  std::vector<int> path;
   GetLocationPath(&path);
   return type()->file()->GetSourceLocation(path, out_location);
 }
 
-void Descriptor::GetLocationPath(vector<int>* output) const {
+void Descriptor::GetLocationPath(std::vector<int>* output) const {
   if (containing_type()) {
     containing_type()->GetLocationPath(output);
     output->push_back(DescriptorProto::kNestedTypeFieldNumber);
     output->push_back(index());
   } else {
     output->push_back(FileDescriptorProto::kMessageTypeFieldNumber);
     output->push_back(index());
   }
 }
 
-void FieldDescriptor::GetLocationPath(vector<int>* output) const {
+void FieldDescriptor::GetLocationPath(std::vector<int>* output) const {
   if (is_extension()) {
     if (extension_scope() == NULL) {
       output->push_back(FileDescriptorProto::kExtensionFieldNumber);
       output->push_back(index());
     } else {
       extension_scope()->GetLocationPath(output);
       output->push_back(DescriptorProto::kExtensionFieldNumber);
       output->push_back(index());
     }
   } else {
     containing_type()->GetLocationPath(output);
     output->push_back(DescriptorProto::kFieldFieldNumber);
     output->push_back(index());
   }
 }
 
-void OneofDescriptor::GetLocationPath(vector<int>* output) const {
+void OneofDescriptor::GetLocationPath(std::vector<int>* output) const {
   containing_type()->GetLocationPath(output);
   output->push_back(DescriptorProto::kOneofDeclFieldNumber);
   output->push_back(index());
 }
 
-void EnumDescriptor::GetLocationPath(vector<int>* output) const {
+void EnumDescriptor::GetLocationPath(std::vector<int>* output) const {
   if (containing_type()) {
     containing_type()->GetLocationPath(output);
     output->push_back(DescriptorProto::kEnumTypeFieldNumber);
     output->push_back(index());
   } else {
     output->push_back(FileDescriptorProto::kEnumTypeFieldNumber);
     output->push_back(index());
   }
 }
 
-void EnumValueDescriptor::GetLocationPath(vector<int>* output) const {
+void EnumValueDescriptor::GetLocationPath(std::vector<int>* output) const {
   type()->GetLocationPath(output);
   output->push_back(EnumDescriptorProto::kValueFieldNumber);
   output->push_back(index());
 }
 
-void ServiceDescriptor::GetLocationPath(vector<int>* output) const {
+void ServiceDescriptor::GetLocationPath(std::vector<int>* output) const {
   output->push_back(FileDescriptorProto::kServiceFieldNumber);
   output->push_back(index());
 }
 
-void MethodDescriptor::GetLocationPath(vector<int>* output) const {
+void MethodDescriptor::GetLocationPath(std::vector<int>* output) const {
   service()->GetLocationPath(output);
   output->push_back(ServiceDescriptorProto::kMethodFieldNumber);
   output->push_back(index());
 }
 
 // ===================================================================
 
 namespace {
 
 // Represents an options message to interpret. Extension names in the option
@@ skipping 34 matching lines @@
   // Non-recursive part of BuildFile functionality.
   const FileDescriptor* BuildFileImpl(const FileDescriptorProto& proto);
 
   const DescriptorPool* pool_;
   DescriptorPool::Tables* tables_;  // for convenience
   DescriptorPool::ErrorCollector* error_collector_;
 
   // As we build descriptors we store copies of the options messages in
   // them. We put pointers to those copies in this vector, as we build, so we
   // can later (after cross-linking) interpret those options.
-  vector<OptionsToInterpret> options_to_interpret_;
+  std::vector<OptionsToInterpret> options_to_interpret_;
 
   bool had_errors_;
   string filename_;
   FileDescriptor* file_;
   FileDescriptorTables* file_tables_;
-  set<const FileDescriptor*> dependencies_;
+  std::set<const FileDescriptor*> dependencies_;
 
   // unused_dependency_ is used to record the unused imported files.
   // Note: public import is not considered.
-  set<const FileDescriptor*> unused_dependency_;
+  std::set<const FileDescriptor*> unused_dependency_;
 
   // If LookupSymbol() finds a symbol that is in a file which is not a declared
   // dependency of this file, it will fail, but will set
   // possible_undeclared_dependency_ to point at that file.  This is only used
   // by AddNotDefinedError() to report a more useful error message.
   // possible_undeclared_dependency_name_ is the name of the symbol that was
   // actually found in possible_undeclared_dependency_, which may be a parent
   // of the symbol actually looked for.
   const FileDescriptor* possible_undeclared_dependency_;
   string possible_undeclared_dependency_name_;
@@ skipping 160 matching lines @@
   }
   void BuildExtensionRange(const DescriptorProto::ExtensionRange& proto,
                            const Descriptor* parent,
                            Descriptor::ExtensionRange* result);
   void BuildReservedRange(const DescriptorProto::ReservedRange& proto,
                            const Descriptor* parent,
                            Descriptor::ReservedRange* result);
   void BuildOneof(const OneofDescriptorProto& proto,
                   Descriptor* parent,
                   OneofDescriptor* result);
+  void CheckEnumValueUniqueness(const EnumDescriptorProto& proto,
+                                const EnumDescriptor* result);
   void BuildEnum(const EnumDescriptorProto& proto,
                  const Descriptor* parent,
                  EnumDescriptor* result);
   void BuildEnumValue(const EnumValueDescriptorProto& proto,
                       const EnumDescriptor* parent,
                       EnumValueDescriptor* result);
   void BuildService(const ServiceDescriptorProto& proto,
                     const void* dummy,
                     ServiceDescriptor* result);
   void BuildMethod(const MethodDescriptorProto& proto,
@@ skipping 50 matching lines @@
     // Adds the uninterpreted_option to the given options message verbatim.
     // Used when AllowUnknownDependencies() is in effect and we can't find
     // the option's definition.
     void AddWithoutInterpreting(const UninterpretedOption& uninterpreted_option,
                                 Message* options);
 
     // A recursive helper function that drills into the intermediate fields
     // in unknown_fields to check if field innermost_field is set on the
     // innermost message. Returns false and sets an error if so.
     bool ExamineIfOptionIsSet(
-        vector<const FieldDescriptor*>::const_iterator intermediate_fields_iter,
-        vector<const FieldDescriptor*>::const_iterator intermediate_fields_end,
+        std::vector<const FieldDescriptor*>::const_iterator
+            intermediate_fields_iter,
+        std::vector<const FieldDescriptor*>::const_iterator
+            intermediate_fields_end,
         const FieldDescriptor* innermost_field, const string& debug_msg_name,
         const UnknownFieldSet& unknown_fields);
 
     // Validates the value for the option field of the currently interpreted
     // option and then sets it on the unknown_field.
     bool SetOptionValue(const FieldDescriptor* option_field,
                         UnknownFieldSet* unknown_fields);
 
     // Parses an aggregate value for a CPPTYPE_MESSAGE option and
     // saves it into *unknown_fields.
@@ skipping 305 matching lines @@
 
   if (result.type == Symbol::PACKAGE) {
     // Arg, this is overcomplicated.  The symbol is a package name.  It could
     // be that the package was defined in multiple files.  result.GetFile()
     // returns the first file we saw that used this package.  We've determined
     // that that file is not a direct dependency of the file we are currently
     // building, but it could be that some other file which *is* a direct
     // dependency also defines the same package.  We can't really rule out this
     // symbol unless none of the dependencies define it.
     if (IsInPackage(file_, name)) return result;
-    for (set<const FileDescriptor*>::const_iterator it = dependencies_.begin();
+    for (std::set<const FileDescriptor*>::const_iterator it =
+             dependencies_.begin();
          it != dependencies_.end(); ++it) {
       // Note:  A dependency may be NULL if it was not found or had errors.
       if (*it != NULL && IsInPackage(*it, name)) return result;
     }
   }
 
   possible_undeclared_dependency_ = file;
   possible_undeclared_dependency_name_ = name;
   return kNullSymbol;
 }
@@ skipping 198 matching lines @@
 
 bool DescriptorBuilder::AddSymbol(
     const string& full_name, const void* parent, const string& name,
     const Message& proto, Symbol symbol) {
   // If the caller passed NULL for the parent, the symbol is at file scope.
   // Use its file as the parent instead.
   if (parent == NULL) parent = file_;
 
   if (tables_->AddSymbol(full_name, symbol)) {
     if (!file_tables_->AddAliasUnderParent(parent, name, symbol)) {
-      GOOGLE_LOG(DFATAL) << "\"" << full_name << "\" not previously defined in "
-                     "symbols_by_name_, but was defined in symbols_by_parent_; "
-                     "this shouldn't be possible.";
+      // This is only possible if there was already an error adding something of
+      // the same name.
+      if (!had_errors_) {
+        GOOGLE_LOG(DFATAL) << "\"" << full_name << "\" not previously defined in "
+                       "symbols_by_name_, but was defined in "
+                       "symbols_by_parent_; this shouldn't be possible.";
+      }
       return false;
     }
     return true;
   } else {
     const FileDescriptor* other_file = tables_->FindSymbol(full_name).GetFile();
     if (other_file == file_) {
       string::size_type dot_pos = full_name.find_last_of('.');
       if (dot_pos == string::npos) {
         AddError(full_name, proto, DescriptorPool::ErrorCollector::NAME,
                  "\"" + full_name + "\" is already defined.");
@@ skipping 297 matching lines @@
     // Bail out early so that if this is actually the exact same file, we
     // don't end up reporting that every single symbol is already defined.
     tables_->RollbackToLastCheckpoint();
     return NULL;
   }
   if (!result->package().empty()) {
     AddPackage(result->package(), proto, result);
   }
 
   // Make sure all dependencies are loaded.
-  set<string> seen_dependencies;
+  std::set<string> seen_dependencies;
   result->dependency_count_ = proto.dependency_size();
   result->dependencies_ =
     tables_->AllocateArray<const FileDescriptor*>(proto.dependency_size());
   unused_dependency_.clear();
-  set<int> weak_deps;
+  std::set<int> weak_deps;
   for (int i = 0; i < proto.weak_dependency_size(); ++i) {
     weak_deps.insert(proto.weak_dependency(i));
   }
   for (int i = 0; i < proto.dependency_size(); i++) {
     if (!seen_dependencies.insert(proto.dependency(i)).second) {
       AddTwiceListedError(proto, i);
     }
 
     const FileDescriptor* dependency = tables_->FindFile(proto.dependency(i));
     if (dependency == NULL && pool_->underlay_ != NULL) {
@@ skipping 78 matching lines @@
   // Note that the following steps must occur in exactly the specified order.
 
   // Cross-link.
   CrossLinkFile(result, proto);
 
   // Interpret any remaining uninterpreted options gathered into
   // options_to_interpret_ during descriptor building.  Cross-linking has made
   // extension options known, so all interpretations should now succeed.
   if (!had_errors_) {
     OptionInterpreter option_interpreter(this);
-    for (vector<OptionsToInterpret>::iterator iter =
+    for (std::vector<OptionsToInterpret>::iterator iter =
              options_to_interpret_.begin();
          iter != options_to_interpret_.end(); ++iter) {
       option_interpreter.InterpretOptions(&(*iter));
     }
     options_to_interpret_.clear();
   }
 
   // Validate options.
   if (!had_errors_) {
     ValidateFileOptions(result, proto);
@@ skipping 127 matching lines @@
     }
   }
 
   // Check that extension ranges don't overlap and don't include
   // reserved field numbers.
   for (int i = 0; i < result->extension_range_count(); i++) {
     const Descriptor::ExtensionRange* range1 = result->extension_range(i);
     for (int j = 0; j < result->reserved_range_count(); j++) {
       const Descriptor::ReservedRange* range2 = result->reserved_range(j);
       if (range1->end > range2->start && range2->end > range1->start) {
-        AddError(result->full_name(), proto.extension_range(j),
+        AddError(result->full_name(), proto.extension_range(i),
                  DescriptorPool::ErrorCollector::NUMBER,
                  strings::Substitute("Extension range $0 to $1 overlaps with "
                                      "reserved range $2 to $3.",
                                      range1->start, range1->end - 1,
                                      range2->start, range2->end - 1));
       }
     }
     for (int j = i + 1; j < result->extension_range_count(); j++) {
       const Descriptor::ExtensionRange* range2 = result->extension_range(j);
       if (range1->end > range2->start && range2->end > range1->start) {
-        AddError(result->full_name(), proto.extension_range(j),
+        AddError(result->full_name(), proto.extension_range(i),
                  DescriptorPool::ErrorCollector::NUMBER,
                  strings::Substitute("Extension range $0 to $1 overlaps with "
                                      "already-defined range $2 to $3.",
                                      range2->start, range2->end - 1,
                                      range1->start, range1->end - 1));
       }
     }
   }
 }
 
@@ skipping 32 matching lines @@
   // format, so the optimization wouldn't help much.
   result->camelcase_name_ =
       tables_->AllocateString(ToCamelCase(proto.name(),
                                           /* lower_first = */ true));
 
   if (proto.has_json_name()) {
     result->has_json_name_ = true;
     result->json_name_ = tables_->AllocateString(proto.json_name());
   } else {
     result->has_json_name_ = false;
-    result->json_name_ = result->camelcase_name_;
+    result->json_name_ = tables_->AllocateString(ToJsonName(proto.name()));
   }
 
   // Some compilers do not allow static_cast directly between two enum types,
   // so we must cast to int first.
   result->type_  = static_cast<FieldDescriptor::Type>(
                      implicit_cast<int>(proto.type()));
   result->label_ = static_cast<FieldDescriptor::Label>(
                      implicit_cast<int>(proto.label()));
 
   // An extension cannot have a required field (b/13365836).
@@ skipping 37 matching lines @@
         case FieldDescriptor::CPPTYPE_UINT32:
           result->default_value_uint32_ =
             strtoul(proto.default_value().c_str(), &end_pos, 0);
           break;
         case FieldDescriptor::CPPTYPE_UINT64:
           result->default_value_uint64_ =
             strtou64(proto.default_value().c_str(), &end_pos, 0);
           break;
         case FieldDescriptor::CPPTYPE_FLOAT:
           if (proto.default_value() == "inf") {
-            result->default_value_float_ = numeric_limits<float>::infinity();
+            result->default_value_float_ =
+                std::numeric_limits<float>::infinity();
           } else if (proto.default_value() == "-inf") {
-            result->default_value_float_ = -numeric_limits<float>::infinity();
+            result->default_value_float_ =
+                -std::numeric_limits<float>::infinity();
           } else if (proto.default_value() == "nan") {
-            result->default_value_float_ = numeric_limits<float>::quiet_NaN();
+            result->default_value_float_ =
+                std::numeric_limits<float>::quiet_NaN();
           } else  {
             result->default_value_float_ = io::SafeDoubleToFloat(
                 io::NoLocaleStrtod(proto.default_value().c_str(), &end_pos));
           }
           break;
         case FieldDescriptor::CPPTYPE_DOUBLE:
           if (proto.default_value() == "inf") {
-            result->default_value_double_ = numeric_limits<double>::infinity();
+            result->default_value_double_ =
+                std::numeric_limits<double>::infinity();
           } else if (proto.default_value() == "-inf") {
-            result->default_value_double_ = -numeric_limits<double>::infinity();
+            result->default_value_double_ =
+                -std::numeric_limits<double>::infinity();
           } else if (proto.default_value() == "nan") {
-            result->default_value_double_ = numeric_limits<double>::quiet_NaN();
+            result->default_value_double_ =
+                std::numeric_limits<double>::quiet_NaN();
           } else  {
             result->default_value_double_ =
                 io::NoLocaleStrtod(proto.default_value().c_str(), &end_pos);
           }
           break;
         case FieldDescriptor::CPPTYPE_BOOL:
           if (proto.default_value() == "true") {
             result->default_value_bool_ = true;
           } else if (proto.default_value() == "false") {
             result->default_value_bool_ = false;
@@ skipping 202 matching lines @@
 
   result->name_ = tables_->AllocateString(proto.name());
   result->full_name_ = full_name;
 
   result->containing_type_ = parent;
 
   // We need to fill these in later.
   result->field_count_ = 0;
   result->fields_ = NULL;
 
+  // Copy options.
+  if (!proto.has_options()) {
+    result->options_ = NULL;  // Will set to default_instance later.
+  } else {
+    AllocateOptions(proto.options(), result);
+  }
+
   AddSymbol(result->full_name(), parent, result->name(),
             proto, Symbol(result));
 }
 
+void DescriptorBuilder::CheckEnumValueUniqueness(
+    const EnumDescriptorProto& proto, const EnumDescriptor* result) {
+
+  // Check that enum labels are still unique when we remove the enum prefix from
+  // values that have it.
+  //
+  // This will fail for something like:
+  //
+  //   enum MyEnum {
+  //     MY_ENUM_FOO = 0;
+  //     FOO = 1;
+  //   }
+  //
+  // By enforcing this reasonable constraint, we allow code generators to strip
+  // the prefix and/or PascalCase it without creating conflicts.  This can lead
+  // to much nicer language-specific enums like:
+  //
+  //   enum NameType {
+  //     FirstName = 1,
+  //     LastName = 2,
+  //   }
+  //
+  // Instead of:
+  //
+  //   enum NameType {
+  //     NAME_TYPE_FIRST_NAME = 1,
+  //     NAME_TYPE_LAST_NAME = 2,
+  //   }
+  PrefixRemover remover(result->name());
+  std::map<string, const google::protobuf::EnumValueDescriptor*> values;
+  for (int i = 0; i < result->value_count(); i++) {
+    const google::protobuf::EnumValueDescriptor* value = result->value(i);
+    string stripped =
+        EnumValueToPascalCase(remover.MaybeRemove(value->name()));
+    std::pair<std::map<string, const google::protobuf::EnumValueDescriptor*>::iterator,
+              bool>
+        insert_result = values.insert(std::make_pair(stripped, value));
+    bool inserted = insert_result.second;
+
+    // We don't throw the error if the two conflicting symbols are identical, or
+    // if they map to the same number.  In the former case, the normal symbol
+    // duplication error will fire so we don't need to (and its error message
+    // will make more sense). We allow the latter case so users can create
+    // aliases which add or remove the prefix (code generators that do prefix
+    // stripping should de-dup the labels in this case).
+    if (!inserted && insert_result.first->second->name() != value->name() &&
+        insert_result.first->second->number() != value->number()) {
+      string error_message =
+          "When enum name is stripped and label is PascalCased (" + stripped +
+          "), this value label conflicts with " + values[stripped]->name() +
+          ". This will make the proto fail to compile for some languages, such "
+          "as C#.";
+      // There are proto2 enums out there with conflicting names, so to preserve
+      // compatibility we issue only a warning for proto2.
+      if (result->file()->syntax() == FileDescriptor::SYNTAX_PROTO2) {
+        AddWarning(value->full_name(), proto.value(i),
+                   DescriptorPool::ErrorCollector::NAME, error_message);
+      } else {
+        AddError(value->full_name(), proto.value(i),
+                 DescriptorPool::ErrorCollector::NAME, error_message);
+      }
+    }
+  }
+}
+
 void DescriptorBuilder::BuildEnum(const EnumDescriptorProto& proto,
                                   const Descriptor* parent,
                                   EnumDescriptor* result) {
   const string& scope = (parent == NULL) ?
     file_->package() : parent->full_name();
   string* full_name = tables_->AllocateString(scope);
   if (!full_name->empty()) full_name->append(1, '.');
   full_name->append(proto.name());
 
   ValidateSymbolName(proto.name(), *full_name, proto);
 
   result->name_            = tables_->AllocateString(proto.name());
   result->full_name_       = full_name;
   result->file_            = file_;
   result->containing_type_ = parent;
   result->is_placeholder_  = false;
   result->is_unqualified_placeholder_ = false;
 
   if (proto.value_size() == 0) {
     // We cannot allow enums with no values because this would mean there
     // would be no valid default value for fields of this type.
     AddError(result->full_name(), proto,
              DescriptorPool::ErrorCollector::NAME,
              "Enums must contain at least one value.");
   }
 
   BUILD_ARRAY(proto, result, value, BuildEnumValue, result);
 
+  CheckEnumValueUniqueness(proto, result);
+
   // Copy options.
   if (!proto.has_options()) {
     result->options_ = NULL;  // Will set to default_instance later.
   } else {
     AllocateOptions(proto.options(), result);
   }
 
   AddSymbol(result->full_name(), parent, result->name(),
             proto, Symbol(result));
 }
@@ skipping 208 matching lines @@
     if (oneof_decl->field_count() == 0) {
       AddError(message->full_name() + "." + oneof_decl->name(),
                proto.oneof_decl(i),
                DescriptorPool::ErrorCollector::NAME,
                "Oneof must have at least one field.");
     }
 
     oneof_decl->fields_ =
       tables_->AllocateArray<const FieldDescriptor*>(oneof_decl->field_count_);
     oneof_decl->field_count_ = 0;
+
+    if (oneof_decl->options_ == NULL) {
+      oneof_decl->options_ = &OneofOptions::default_instance();
+    }
   }
 
   // Then fill them in.
   for (int i = 0; i < message->field_count(); i++) {
     const OneofDescriptor* oneof_decl = message->field(i)->containing_oneof();
     if (oneof_decl != NULL) {
       OneofDescriptor* mutable_oneof_decl =
           &message->oneof_decls_[oneof_decl->index()];
       message->fields_[i].index_in_oneof_ = mutable_oneof_decl->field_count_;
       mutable_oneof_decl->fields_[mutable_oneof_decl->field_count_++] =
@@ skipping 163 matching lines @@
     }
   }
 
   // Add the field to the fields-by-number table.
   // Note:  We have to do this *after* cross-linking because extensions do not
   //   know their containing type until now.
   if (!file_tables_->AddFieldByNumber(field)) {
     const FieldDescriptor* conflicting_field =
       file_tables_->FindFieldByNumber(field->containing_type(),
                                       field->number());
+    string containing_type_name = field->containing_type() == NULL
+                                      ? "unknown"
+                                      : field->containing_type()->full_name();
     if (field->is_extension()) {
       AddError(field->full_name(), proto,
                DescriptorPool::ErrorCollector::NUMBER,
                strings::Substitute("Extension number $0 has already been used "
                                    "in \"$1\" by extension \"$2\".",
                                    field->number(),
-                                   field->containing_type()->full_name(),
+                                   containing_type_name,
                                    conflicting_field->full_name()));
     } else {
       AddError(field->full_name(), proto,
                DescriptorPool::ErrorCollector::NUMBER,
                strings::Substitute("Field number $0 has already been used in "
                                    "\"$1\" by field \"$2\".",
                                    field->number(),
-                                   field->containing_type()->full_name(),
+                                   containing_type_name,
                                    conflicting_field->name()));
     }
   } else {
     if (field->is_extension()) {
       if (!tables_->AddExtension(field)) {
         const FieldDescriptor* conflicting_field =
             tables_->FindExtension(field->containing_type(), field->number());
         string error_msg = strings::Substitute(
             "Extension number $0 has already been used in \"$1\" by extension "
             "\"$2\" defined in $3.",
@@ skipping 173 matching lines @@
   if (message->options().message_set_wire_format()) {
     // Using MessageSet doesn't make sense since we disallow extensions.
     AddError(message->full_name(), proto,
              DescriptorPool::ErrorCollector::OTHER,
              "MessageSet is not supported in proto3.");
   }
 
   // In proto3, we reject field names if they conflict in camelCase.
   // Note that we currently enforce a stricter rule: Field names must be
   // unique after being converted to lowercase with underscores removed.
-  map<string, const FieldDescriptor*> name_to_field;
+  std::map<string, const FieldDescriptor*> name_to_field;
   for (int i = 0; i < message->field_count(); ++i) {
     string lowercase_name = ToLowercaseWithoutUnderscores(
         message->field(i)->name());
     if (name_to_field.find(lowercase_name) != name_to_field.end()) {
       AddError(message->full_name(), proto,
                DescriptorPool::ErrorCollector::OTHER,
-               "The JSON camcel-case name of field \"" +
+               "The JSON camel-case name of field \"" +
                message->field(i)->name() + "\" conflicts with field \"" +
                name_to_field[lowercase_name]->name() + "\". This is not " +
                "allowed in proto3.");
     } else {
       name_to_field[lowercase_name] = message->field(i);
     }
   }
 }
 
 void DescriptorBuilder::ValidateProto3Field(
@@ skipping 123 matching lines @@
                "ValueType> instead.");
     }
   }
 
 }
 
 void DescriptorBuilder::ValidateEnumOptions(EnumDescriptor* enm,
                                             const EnumDescriptorProto& proto) {
   VALIDATE_OPTIONS_FROM_ARRAY(enm, value, EnumValue);
   if (!enm->options().has_allow_alias() || !enm->options().allow_alias()) {
-    map<int, string> used_values;
+    std::map<int, string> used_values;
     for (int i = 0; i < enm->value_count(); ++i) {
       const EnumValueDescriptor* enum_value = enm->value(i);
       if (used_values.find(enum_value->number()) != used_values.end()) {
         string error =
             "\"" + enum_value->full_name() +
             "\" uses the same enum value as \"" +
             used_values[enum_value->number()] + "\". If this is intended, set "
             "'option allow_alias = true;' to the enum definition.";
         if (!enm->options().allow_alias()) {
           // Generate error if duplicated enum values are explicitly disallowed.
@@ skipping 106 matching lines @@
           field->full_name(), proto, DescriptorPool::ErrorCollector::TYPE,
           "Enum value in map must define 0 as the first value.");
     }
   }
 
   return true;
 }
 
 void DescriptorBuilder::DetectMapConflicts(const Descriptor* message,
                                            const DescriptorProto& proto) {
-  map<string, const Descriptor*> seen_types;
+  std::map<string, const Descriptor*> seen_types;
   for (int i = 0; i < message->nested_type_count(); ++i) {
     const Descriptor* nested = message->nested_type(i);
-    pair<map<string, const Descriptor*>::iterator, bool> result =
+    std::pair<std::map<string, const Descriptor*>::iterator, bool> result =
         seen_types.insert(std::make_pair(nested->name(), nested));
     if (!result.second) {
       if (result.first->second->options().map_entry() ||
           nested->options().map_entry()) {
         AddError(message->full_name(), proto,
                  DescriptorPool::ErrorCollector::NAME,
                  "Expanded map entry type " + nested->name() +
                  " conflicts with an existing nested message type.");
       }
     }
     // Recursively test on the nested types.
     DetectMapConflicts(message->nested_type(i), proto.nested_type(i));
   }
   // Check for conflicted field names.
   for (int i = 0; i < message->field_count(); ++i) {
     const FieldDescriptor* field = message->field(i);
-    map<string, const Descriptor*>::iterator iter =
+    std::map<string, const Descriptor*>::iterator iter =
         seen_types.find(field->name());
     if (iter != seen_types.end() && iter->second->options().map_entry()) {
       AddError(message->full_name(), proto,
                DescriptorPool::ErrorCollector::NAME,
                "Expanded map entry type " + iter->second->name() +
                " conflicts with an existing field.");
     }
   }
   // Check for conflicted enum names.
   for (int i = 0; i < message->enum_type_count(); ++i) {
     const EnumDescriptor* enum_desc = message->enum_type(i);
-    map<string, const Descriptor*>::iterator iter =
+    std::map<string, const Descriptor*>::iterator iter =
         seen_types.find(enum_desc->name());
     if (iter != seen_types.end() && iter->second->options().map_entry()) {
       AddError(message->full_name(), proto,
                DescriptorPool::ErrorCollector::NAME,
                "Expanded map entry type " + iter->second->name() +
                " conflicts with an existing enum type.");
     }
   }
   // Check for conflicted oneof names.
   for (int i = 0; i < message->oneof_decl_count(); ++i) {
     const OneofDescriptor* oneof_desc = message->oneof_decl(i);
-    map<string, const Descriptor*>::iterator iter =
+    std::map<string, const Descriptor*>::iterator iter =
         seen_types.find(oneof_desc->name());
     if (iter != seen_types.end() && iter->second->options().map_entry()) {
       AddError(message->full_name(), proto,
                DescriptorPool::ErrorCollector::NAME,
                "Expanded map entry type " + iter->second->name() +
                " conflicts with an existing oneof type.");
     }
   }
 }
 
@@ skipping 114 matching lines @@
   GOOGLE_CHECK(options_descriptor);
 
   // We iterate over the name parts to drill into the submessages until we find
   // the leaf field for the option. As we drill down we remember the current
   // submessage's descriptor in |descriptor| and the next field in that
   // submessage in |field|. We also track the fields we're drilling down
   // through in |intermediate_fields|. As we go, we reconstruct the full option
   // name in |debug_msg_name|, for use in error messages.
   const Descriptor* descriptor = options_descriptor;
   const FieldDescriptor* field = NULL;
-  vector<const FieldDescriptor*> intermediate_fields;
+  std::vector<const FieldDescriptor*> intermediate_fields;
   string debug_msg_name = "";
 
   for (int i = 0; i < uninterpreted_option_->name_size(); ++i) {
     const string& name_part = uninterpreted_option_->name(i).name_part();
     if (debug_msg_name.size() > 0) {
       debug_msg_name += ".";
     }
     if (uninterpreted_option_->name(i).is_extension()) {
       debug_msg_name += "(" + name_part + ")";
       // Search for the extension's descriptor as an extension in the builder's
@@ skipping 87 matching lines @@
 
   // First set the value on the UnknownFieldSet corresponding to the
   // innermost message.
   google::protobuf::scoped_ptr<UnknownFieldSet> unknown_fields(new UnknownFieldSet());
   if (!SetOptionValue(field, unknown_fields.get())) {
     return false;  // SetOptionValue() already added the error.
   }
 
   // Now wrap the UnknownFieldSet with UnknownFieldSets corresponding to all
   // the intermediate messages.
-  for (vector<const FieldDescriptor*>::reverse_iterator iter =
+  for (std::vector<const FieldDescriptor*>::reverse_iterator iter =
            intermediate_fields.rbegin();
        iter != intermediate_fields.rend(); ++iter) {
     google::protobuf::scoped_ptr<UnknownFieldSet> parent_unknown_fields(
         new UnknownFieldSet());
     switch ((*iter)->type()) {
       case FieldDescriptor::TYPE_MESSAGE: {
         io::StringOutputStream outstr(
             parent_unknown_fields->AddLengthDelimited((*iter)->number()));
         io::CodedOutputStream out(&outstr);
         internal::WireFormat::SerializeUnknownFields(*unknown_fields, &out);
@@ skipping 29 matching lines @@
     const UninterpretedOption& uninterpreted_option, Message* options) {
   const FieldDescriptor* field =
     options->GetDescriptor()->FindFieldByName("uninterpreted_option");
   GOOGLE_CHECK(field != NULL);
 
   options->GetReflection()->AddMessage(options, field)
     ->CopyFrom(uninterpreted_option);
 }
 
 bool DescriptorBuilder::OptionInterpreter::ExamineIfOptionIsSet(
-    vector<const FieldDescriptor*>::const_iterator intermediate_fields_iter,
-    vector<const FieldDescriptor*>::const_iterator intermediate_fields_end,
+    std::vector<const FieldDescriptor*>::const_iterator
+        intermediate_fields_iter,
+    std::vector<const FieldDescriptor*>::const_iterator intermediate_fields_end,
     const FieldDescriptor* innermost_field, const string& debug_msg_name,
     const UnknownFieldSet& unknown_fields) {
   // We do linear searches of the UnknownFieldSet and its sub-groups.  This
   // should be fine since it's unlikely that any one options structure will
   // contain more than a handful of options.
 
   if (intermediate_fields_iter == intermediate_fields_end) {
     // We're at the innermost submessage.
     for (int i = 0; i < unknown_fields.field_count(); i++) {
       if (unknown_fields.field(i).number() == innermost_field->number()) {
@@ skipping 439 matching lines @@
   if (!unused_dependency_.empty()) {
     std::set<string> annotation_extensions;
     annotation_extensions.insert("google.protobuf.MessageOptions");
     annotation_extensions.insert("google.protobuf.FileOptions");
     annotation_extensions.insert("google.protobuf.FieldOptions");
     annotation_extensions.insert("google.protobuf.EnumOptions");
     annotation_extensions.insert("google.protobuf.EnumValueOptions");
     annotation_extensions.insert("google.protobuf.ServiceOptions");
     annotation_extensions.insert("google.protobuf.MethodOptions");
     annotation_extensions.insert("google.protobuf.StreamOptions");
-    for (set<const FileDescriptor*>::const_iterator
+    for (std::set<const FileDescriptor*>::const_iterator
              it = unused_dependency_.begin();
          it != unused_dependency_.end(); ++it) {
       // Do not log warnings for proto files which extend annotations.
       int i;
       for (i = 0 ; i < (*it)->extension_count(); ++i) {
         if (annotation_extensions.find(
                 (*it)->extension(i)->containing_type()->full_name())
             != annotation_extensions.end()) {
           break;
         }
       }
       // Log warnings for unused imported files.
       if (i == (*it)->extension_count()) {
         string error_message = "Import " + (*it)->name() + " but not used.";
         AddWarning((*it)->name(), proto, DescriptorPool::ErrorCollector::OTHER,
                    error_message);
       }
     }
   }
 }
 
 }  // namespace protobuf
 }  // namespace google