Update //third_party/protobuf to version 3.

third_party/protobuf/src/google/protobuf/compiler/parser.h

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// http://code.google.com/p/protobuf/
+// 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.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
@@ skipping 19 matching lines @@
 //  Sanjay Ghemawat, Jeff Dean, and others.
 //
 // Implements parsing of .proto files to FileDescriptorProtos.
 
 #ifndef GOOGLE_PROTOBUF_COMPILER_PARSER_H__
 #define GOOGLE_PROTOBUF_COMPILER_PARSER_H__
 
 #include <map>
 #include <string>
 #include <utility>
-#include <google/protobuf/stubs/common.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/io/tokenizer.h>
 
 namespace google {
 namespace protobuf { class Message; }
 
 namespace protobuf {
 namespace compiler {
@@ skipping 125 matching lines @@
 
   // Consume a token representing the end of the statement.  Comments between
   // this token and the next will be harvested for documentation.  The given
   // LocationRecorder should refer to the declaration that was just parsed;
   // it will be populated with these comments.
   //
   // TODO(kenton):  The LocationRecorder is const because historically locations
   //   have been passed around by const reference, for no particularly good
   //   reason.  We should probably go through and change them all to mutable
   //   pointer to make this more intuitive.
-  bool TryConsumeEndOfDeclaration(const char* text,
-                                  const LocationRecorder* location);
-  bool ConsumeEndOfDeclaration(const char* text,
-                               const LocationRecorder* location);
+  bool TryConsumeEndOfDeclaration(
+      const char* text, const LocationRecorder* location);
+  bool TryConsumeEndOfDeclarationFinishScope(
+      const char* text, const LocationRecorder* location);
+
+  bool ConsumeEndOfDeclaration(
+      const char* text, const LocationRecorder* location);
 
   // -----------------------------------------------------------------
   // Error logging helpers
 
   // Invokes error_collector_->AddError(), if error_collector_ is not NULL.
   void AddError(int line, int column, const string& error);
 
   // Invokes error_collector_->AddError() with the line and column number
   // of the current token.
   void AddError(const string& error);
@@ skipping 23 matching lines @@
 
     // Add a path component.  See SourceCodeInfo.Location.path in
     // descriptor.proto.
     void AddPath(int path_component);
 
     // By default the location is considered to start at the current token at
     // the time the LocationRecorder is created.  StartAt() sets the start
     // location to the given token instead.
     void StartAt(const io::Tokenizer::Token& token);
 
+    // Start at the same location as some other LocationRecorder.
+    void StartAt(const LocationRecorder& other);
+
     // By default the location is considered to end at the previous token at
     // the time the LocationRecorder is destroyed.  EndAt() sets the end
     // location to the given token instead.
     void EndAt(const io::Tokenizer::Token& token);
 
     // Records the start point of this location to the SourceLocationTable that
     // was passed to RecordSourceLocationsTo(), if any.  SourceLocationTable
     // is an older way of keeping track of source locations which is still
     // used in some places.
     void RecordLegacyLocation(const Message* descriptor,
         DescriptorPool::ErrorCollector::ErrorLocation location);
 
     // Attaches leading and trailing comments to the location.  The two strings
     // will be swapped into place, so after this is called *leading and
     // *trailing will be empty.
     //
     // TODO(kenton):  See comment on TryConsumeEndOfDeclaration(), above, for
     //   why this is const.
-    void AttachComments(string* leading, string* trailing) const;
+    void AttachComments(string* leading, string* trailing,
+                        vector<string>* detached_comments) const;
 
    private:
+    // Indexes of parent and current location in the parent
+    // SourceCodeInfo.location repeated field. For top-level elements,
+    // parent_index_ is -1.
     Parser* parser_;
     SourceCodeInfo::Location* location_;
 
     void Init(const LocationRecorder& parent);
   };
 
   // =================================================================
   // Parsers for various language constructs
 
   // Parses the "syntax = \"proto2\";" line at the top of the file.  Returns
   // false if it failed to parse or if the syntax identifier was not
   // recognized.
-  bool ParseSyntaxIdentifier();
+  bool ParseSyntaxIdentifier(const LocationRecorder& parent);
 
   // These methods parse various individual bits of code.  They return
   // false if they completely fail to parse the construct.  In this case,
   // it is probably necessary to skip the rest of the statement to recover.
   // However, if these methods return true, it does NOT mean that there
   // were no errors; only that there were no *syntax* errors.  For instance,
   // if a service method is defined using proper syntax but uses a primitive
   // type as its input or output, ParseMethodField() still returns true
   // and only reports the error by calling AddError().  In practice, this
   // makes logic much simpler for the caller.
 
   // Parse a top-level message, enum, service, etc.
   bool ParseTopLevelStatement(FileDescriptorProto* file,
                               const LocationRecorder& root_location);
 
   // Parse various language high-level language construrcts.
   bool ParseMessageDefinition(DescriptorProto* message,
-                              const LocationRecorder& message_location);
+                              const LocationRecorder& message_location,
+                              const FileDescriptorProto* containing_file);
   bool ParseEnumDefinition(EnumDescriptorProto* enum_type,
-                           const LocationRecorder& enum_location);
+                           const LocationRecorder& enum_location,
+                           const FileDescriptorProto* containing_file);
   bool ParseServiceDefinition(ServiceDescriptorProto* service,
-                              const LocationRecorder& service_location);
+                              const LocationRecorder& service_location,
+                              const FileDescriptorProto* containing_file);
   bool ParsePackage(FileDescriptorProto* file,
-                    const LocationRecorder& root_location);
+                    const LocationRecorder& root_location,
+                    const FileDescriptorProto* containing_file);
   bool ParseImport(RepeatedPtrField<string>* dependency,
                    RepeatedField<int32>* public_dependency,
                    RepeatedField<int32>* weak_dependency,
-                   const LocationRecorder& root_location);
-  bool ParseOption(Message* options,
-                   const LocationRecorder& options_location);
+                   const LocationRecorder& root_location,
+                   const FileDescriptorProto* containing_file);
 
   // These methods parse the contents of a message, enum, or service type and
   // add them to the given object.  They consume the entire block including
   // the beginning and ending brace.
   bool ParseMessageBlock(DescriptorProto* message,
-                         const LocationRecorder& message_location);
+                         const LocationRecorder& message_location,
+                         const FileDescriptorProto* containing_file);
   bool ParseEnumBlock(EnumDescriptorProto* enum_type,
-                      const LocationRecorder& enum_location);
+                      const LocationRecorder& enum_location,
+                      const FileDescriptorProto* containing_file);
   bool ParseServiceBlock(ServiceDescriptorProto* service,
-                         const LocationRecorder& service_location);
+                         const LocationRecorder& service_location,
+                         const FileDescriptorProto* containing_file);
 
-  // Parse one statement within a message, enum, or service block, inclunding
+  // Parse one statement within a message, enum, or service block, including
   // final semicolon.
   bool ParseMessageStatement(DescriptorProto* message,
-                             const LocationRecorder& message_location);
+                             const LocationRecorder& message_location,
+                             const FileDescriptorProto* containing_file);
   bool ParseEnumStatement(EnumDescriptorProto* message,
-                          const LocationRecorder& enum_location);
+                          const LocationRecorder& enum_location,
+                          const FileDescriptorProto* containing_file);
   bool ParseServiceStatement(ServiceDescriptorProto* message,
-                             const LocationRecorder& service_location);
+                             const LocationRecorder& service_location,
+                             const FileDescriptorProto* containing_file);
 
   // Parse a field of a message.  If the field is a group, its type will be
   // added to "messages".
   //
   // parent_location and location_field_number_for_nested_type are needed when
   // parsing groups -- we need to generate a nested message type within the
   // parent and record its location accordingly.  Since the parent could be
   // either a FileDescriptorProto or a DescriptorProto, we must pass in the
   // correct field number to use.
   bool ParseMessageField(FieldDescriptorProto* field,
                          RepeatedPtrField<DescriptorProto>* messages,
                          const LocationRecorder& parent_location,
                          int location_field_number_for_nested_type,
-                         const LocationRecorder& field_location);
+                         const LocationRecorder& field_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Like ParseMessageField() but expects the label has already been filled in
+  // by the caller.
+  bool ParseMessageFieldNoLabel(FieldDescriptorProto* field,
+                                RepeatedPtrField<DescriptorProto>* messages,
+                                const LocationRecorder& parent_location,
+                                int location_field_number_for_nested_type,
+                                const LocationRecorder& field_location,
+                                const FileDescriptorProto* containing_file);
 
   // Parse an "extensions" declaration.
   bool ParseExtensions(DescriptorProto* message,
-                       const LocationRecorder& extensions_location);
+                       const LocationRecorder& extensions_location,
+                       const FileDescriptorProto* containing_file);
+
+  // Parse a "reserved" declaration.
+  bool ParseReserved(DescriptorProto* message,
+                     const LocationRecorder& message_location);
+  bool ParseReservedNames(DescriptorProto* message,
+                          const LocationRecorder& parent_location);
+  bool ParseReservedNumbers(DescriptorProto* message,
+                            const LocationRecorder& parent_location);
 
   // Parse an "extend" declaration.  (See also comments for
   // ParseMessageField().)
   bool ParseExtend(RepeatedPtrField<FieldDescriptorProto>* extensions,
                    RepeatedPtrField<DescriptorProto>* messages,
                    const LocationRecorder& parent_location,
                    int location_field_number_for_nested_type,
-                   const LocationRecorder& extend_location);
+                   const LocationRecorder& extend_location,
+                   const FileDescriptorProto* containing_file);
+
+  // Parse a "oneof" declaration.  The caller is responsible for setting
+  // oneof_decl->label() since it will have had to parse the label before it
+  // knew it was parsing a oneof.
+  bool ParseOneof(OneofDescriptorProto* oneof_decl,
+                  DescriptorProto* containing_type,
+                  int oneof_index,
+                  const LocationRecorder& oneof_location,
+                  const LocationRecorder& containing_type_location,
+                  const FileDescriptorProto* containing_file);
 
   // Parse a single enum value within an enum block.
   bool ParseEnumConstant(EnumValueDescriptorProto* enum_value,
-                         const LocationRecorder& enum_value_location);
+                         const LocationRecorder& enum_value_location,
+                         const FileDescriptorProto* containing_file);
 
   // Parse enum constant options, i.e. the list in square brackets at the end
   // of the enum constant value definition.
   bool ParseEnumConstantOptions(EnumValueDescriptorProto* value,
-                                const LocationRecorder& enum_value_location);
+                                const LocationRecorder& enum_value_location,
+                                const FileDescriptorProto* containing_file);
 
   // Parse a single method within a service definition.
   bool ParseServiceMethod(MethodDescriptorProto* method,
-                          const LocationRecorder& method_location);
+                          const LocationRecorder& method_location,
+                          const FileDescriptorProto* containing_file);
 
 
   // Parse options of a single method or stream.
-  bool ParseOptions(const LocationRecorder& parent_location,
-                    const int optionsFieldNumber,
-                    Message* mutable_options);
+  bool ParseMethodOptions(const LocationRecorder& parent_location,
+                          const FileDescriptorProto* containing_file,
+                          const int optionsFieldNumber,
+                          Message* mutable_options);
 
   // Parse "required", "optional", or "repeated" and fill in "label"
-  // with the value.
-  bool ParseLabel(FieldDescriptorProto::Label* label);
+  // with the value. Returns true if such a label is consumed.
+  bool ParseLabel(FieldDescriptorProto::Label* label,
+                  const FileDescriptorProto* containing_file);
 
   // Parse a type name and fill in "type" (if it is a primitive) or
   // "type_name" (if it is not) with the type parsed.
   bool ParseType(FieldDescriptorProto::Type* type,
                  string* type_name);
   // Parse a user-defined type and fill in "type_name" with the name.
   // If a primitive type is named, it is treated as an error.
   bool ParseUserDefinedType(string* type_name);
 
   // Parses field options, i.e. the stuff in square brackets at the end
   // of a field definition.  Also parses default value.
   bool ParseFieldOptions(FieldDescriptorProto* field,
-                         const LocationRecorder& field_location);
+                         const LocationRecorder& field_location,
+                         const FileDescriptorProto* containing_file);
 
   // Parse the "default" option.  This needs special handling because its
   // type is the field's type.
   bool ParseDefaultAssignment(FieldDescriptorProto* field,
-                              const LocationRecorder& field_location);
+                              const LocationRecorder& field_location,
+                              const FileDescriptorProto* containing_file);
+
+  bool ParseJsonName(FieldDescriptorProto* field,
+                     const LocationRecorder& field_location,
+                     const FileDescriptorProto* containing_file);
 
   enum OptionStyle {
     OPTION_ASSIGNMENT,  // just "name = value"
     OPTION_STATEMENT    // "option name = value;"
   };
 
   // Parse a single option name/value pair, e.g. "ctype = CORD".  The name
   // identifies a field of the given Message, and the value of that field
   // is set to the parsed value.
   bool ParseOption(Message* options,
                    const LocationRecorder& options_location,
+                   const FileDescriptorProto* containing_file,
                    OptionStyle style);
 
   // Parses a single part of a multipart option name. A multipart name consists
   // of names separated by dots. Each name is either an identifier or a series
   // of identifiers separated by dots and enclosed in parentheses. E.g.,
   // "foo.(bar.baz).qux".
   bool ParseOptionNamePart(UninterpretedOption* uninterpreted_option,
-                           const LocationRecorder& part_location);
+                           const LocationRecorder& part_location,
+                           const FileDescriptorProto* containing_file);
 
   // Parses a string surrounded by balanced braces.  Strips off the outer
   // braces and stores the enclosed string in *value.
   // E.g.,
   //     { foo }                     *value gets 'foo'
   //     { foo { bar: box } }        *value gets 'foo { bar: box }'
   //     {}                          *value gets ''
   //
   // REQUIRES: LookingAt("{")
   // When finished successfully, we are looking at the first token past
   // the ending brace.
   bool ParseUninterpretedBlock(string* value);
 
+  struct MapField {
+    // Whether the field is a map field.
+    bool is_map_field;
+    // The types of the key and value if they are primitive types.
+    FieldDescriptorProto::Type key_type;
+    FieldDescriptorProto::Type value_type;
+    // Or the type names string if the types are customized types.
+    string key_type_name;
+    string value_type_name;
+
+    MapField() : is_map_field(false) {}
+  };
+  // Desugar the map syntax to generate a nested map entry message.
+  void GenerateMapEntry(const MapField& map_field, FieldDescriptorProto* field,
+                        RepeatedPtrField<DescriptorProto>* messages);
+
+  // Whether fields without label default to optional fields.
+  bool DefaultToOptionalFields() const {
+    return syntax_identifier_ == "proto3";
+  }
+
+
+  bool ValidateEnum(const EnumDescriptorProto* proto);
+
   // =================================================================
 
   io::Tokenizer* input_;
   io::ErrorCollector* error_collector_;
   SourceCodeInfo* source_code_info_;
   SourceLocationTable* source_location_table_;  // legacy
   bool had_errors_;
   bool require_syntax_identifier_;
   bool stop_after_syntax_identifier_;
   string syntax_identifier_;
 
   // Leading doc comments for the next declaration.  These are not complete
   // yet; use ConsumeEndOfDeclaration() to get the complete comments.
   string upcoming_doc_comments_;
 
+  // Detached comments are not connected to any syntax entities. Elements in
+  // this vector are paragraphs of comments separated by empty lines. The
+  // detached comments will be put into the leading_detached_comments field for
+  // the next element (See SourceCodeInfo.Location in descriptor.proto), when
+  // ConsumeEndOfDeclaration() is called.
+  vector<string> upcoming_detached_comments_;
+
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Parser);
 };
 
 // A table mapping (descriptor, ErrorLocation) pairs -- as reported by
 // DescriptorPool when validating descriptors -- to line and column numbers
 // within the original source code.
 //
 // This is semi-obsolete:  FileDescriptorProto.source_code_info now contains
 // far more complete information about source locations.  However, as of this
 // writing you still need to use SourceLocationTable when integrating with
@@ skipping 25 matching lines @@
     pair<const Message*, DescriptorPool::ErrorCollector::ErrorLocation>,
     pair<int, int> > LocationMap;
   LocationMap location_map_;
 };
 
 }  // namespace compiler
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_COMPILER_PARSER_H__