protobuf/src/ProtoGen/MessageGenerator.cs

#region Copyright notice and license

// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code:
// http://code.google.com/p/protobuf/
//
// 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
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#endregion

using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;

namespace Google.ProtocolBuffers.ProtoGen
{
    internal class MessageGenerator : SourceGeneratorBase<MessageDescriptor>, ISourceGenerator
    {
        private string[] _fieldNames;

        internal MessageGenerator(MessageDescriptor descriptor) : base(descriptor)
        {
        }

        private string ClassName
        {
            get { return Descriptor.Name; }
        }

        private string FullClassName
        {
            get { return GetClassName(Descriptor); }
        }

        /// <summary>
        /// Get an identifier that uniquely identifies this type within the file.
        /// This is used to declare static variables related to this type at the
        /// outermost file scope.
        /// </summary>
        private static string GetUniqueFileScopeIdentifier(IDescriptor descriptor)
        {
            return "static_" + descriptor.FullName.Replace(".", "_");
        }

        internal void GenerateStaticVariables(TextGenerator writer)
        {
            // Because descriptor.proto (Google.ProtocolBuffers.DescriptorProtos) is
            // used in the construction of descriptors, we have a tricky bootstrapping
            // problem.  To help control static initialization order, we make sure all
            // descriptors and other static data that depends on them are members of
            // the proto-descriptor class.  This way, they will be initialized in
            // a deterministic order.

            string identifier = GetUniqueFileScopeIdentifier(Descriptor);

            if (!UseLiteRuntime)
            {
                // The descriptor for this type.
                string access = Descriptor.File.CSharpOptions.NestClasses ? "private" : "internal";
                writer.WriteLine("{0} static pbd::MessageDescriptor internal__{1}__Descriptor;", access, identifier);
                writer.WriteLine(
                    "{0} static pb::FieldAccess.FieldAccessorTable<{1}, {1}.Builder> internal__{2}__FieldAccessorTable;",
                    access, FullClassName, identifier);
            }
            // Generate static members for all nested types.
            foreach (MessageDescriptor nestedMessage in Descriptor.NestedTypes)
            {
                new MessageGenerator(nestedMessage).GenerateStaticVariables(writer);
            }
        }

        internal void GenerateStaticVariableInitializers(TextGenerator writer)
        {
            string identifier = GetUniqueFileScopeIdentifier(Descriptor);

            if (!UseLiteRuntime)
            {
                writer.Write("internal__{0}__Descriptor = ", identifier);
                if (Descriptor.ContainingType == null)
                {
                    writer.WriteLine("Descriptor.MessageTypes[{0}];", Descriptor.Index);
                }
                else
                {
                    writer.WriteLine("internal__{0}__Descriptor.NestedTypes[{1}];",
                                     GetUniqueFileScopeIdentifier(Descriptor.ContainingType), Descriptor.Index);
                }

                writer.WriteLine("internal__{0}__FieldAccessorTable = ", identifier);
                writer.WriteLine(
                    "    new pb::FieldAccess.FieldAccessorTable<{1}, {1}.Builder>(internal__{0}__Descriptor,",
                    identifier, FullClassName);
                writer.Print("        new string[] { ");
                foreach (FieldDescriptor field in Descriptor.Fields)
                {
                    writer.Write("\"{0}\", ", field.CSharpOptions.PropertyName);
                }
                writer.WriteLine("});");
            }

            // Generate static member initializers for all nested types.
            foreach (MessageDescriptor nestedMessage in Descriptor.NestedTypes)
            {
                new MessageGenerator(nestedMessage).GenerateStaticVariableInitializers(writer);
            }

            foreach (FieldDescriptor extension in Descriptor.Extensions)
            {
                new ExtensionGenerator(extension).GenerateStaticVariableInitializers(writer);
            }
        }

        public string[] FieldNames
        {
            get
            {
                if (_fieldNames == null)
                {
                    List<string> names = new List<string>();
                    foreach (FieldDescriptor fieldDescriptor in Descriptor.Fields)
                    {
                        names.Add(fieldDescriptor.Name);
                    }
                    //if you change this, the search must also change in GenerateBuilderParsingMethods
                    names.Sort(StringComparer.Ordinal);
                    _fieldNames = names.ToArray();
                }
                return _fieldNames;
            }
        }

        internal int FieldOrdinal(FieldDescriptor field)
        {
            return Array.BinarySearch(FieldNames, field.Name, StringComparer.Ordinal);
        }

        private IFieldSourceGenerator CreateFieldGenerator(FieldDescriptor fieldDescriptor)
        {
            return SourceGenerators.CreateFieldGenerator(fieldDescriptor, FieldOrdinal(fieldDescriptor));
        }
        
        public void Generate(TextGenerator writer)
        {
            if (Descriptor.File.CSharpOptions.AddSerializable)
            {
                writer.WriteLine("[global::System.SerializableAttribute()]");
            }
            writer.WriteLine("[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
            WriteGeneratedCodeAttributes(writer);
            writer.WriteLine("{0} sealed partial class {1} : pb::{2}Message{3}<{1}, {1}.Builder> {{",
                             ClassAccessLevel, ClassName,
                             Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated",
                             RuntimeSuffix);
            writer.Indent();
            if (Descriptor.File.CSharpOptions.GeneratePrivateCtor)
            {
                writer.WriteLine("private {0}() {{ }}", ClassName);
            }
            // Must call MakeReadOnly() to make sure all lists are made read-only
            writer.WriteLine("private static readonly {0} defaultInstance = new {0}().MakeReadOnly();", ClassName);

            if (OptimizeSpeed)
            {
                writer.WriteLine("private static readonly string[] _{0}FieldNames = new string[] {{ {2}{1}{2} }};",
                                 NameHelpers.UnderscoresToCamelCase(ClassName), String.Join("\", \"", FieldNames),
                                 FieldNames.Length > 0 ? "\"" : "");
                List<string> tags = new List<string>();
                foreach (string name in FieldNames)
                {
                    tags.Add(WireFormat.MakeTag(Descriptor.FindFieldByName(name)).ToString());
                }

                writer.WriteLine("private static readonly uint[] _{0}FieldTags = new uint[] {{ {1} }};",
                                 NameHelpers.UnderscoresToCamelCase(ClassName), String.Join(", ", tags.ToArray()));
            }
            writer.WriteLine("public static {0} DefaultInstance {{", ClassName);
            writer.WriteLine("  get { return defaultInstance; }");
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
            writer.WriteLine("  get { return DefaultInstance; }");
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine("protected override {0} ThisMessage {{", ClassName);
            writer.WriteLine("  get { return this; }");
            writer.WriteLine("}");
            writer.WriteLine();
            if (!UseLiteRuntime)
            {
                writer.WriteLine("public static pbd::MessageDescriptor Descriptor {");
                writer.WriteLine("  get {{ return {0}.internal__{1}__Descriptor; }}",
                                 DescriptorUtil.GetFullUmbrellaClassName(Descriptor),
                                 GetUniqueFileScopeIdentifier(Descriptor));
                writer.WriteLine("}");
                writer.WriteLine();
                writer.WriteLine(
                    "protected override pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder> InternalFieldAccessors {{",
                    ClassName);
                writer.WriteLine("  get {{ return {0}.internal__{1}__FieldAccessorTable; }}",
                                 DescriptorUtil.GetFullUmbrellaClassName(Descriptor),
                                 GetUniqueFileScopeIdentifier(Descriptor));
                writer.WriteLine("}");
                writer.WriteLine();
            }

            // Extensions don't need to go in an extra nested type 
            WriteChildren(writer, null, Descriptor.Extensions);

            if (Descriptor.EnumTypes.Count + Descriptor.NestedTypes.Count > 0)
            {
                writer.WriteLine("#region Nested types");
                writer.WriteLine("[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
                WriteGeneratedCodeAttributes(writer);
                writer.WriteLine("public static partial class Types {");
                writer.Indent();
                WriteChildren(writer, null, Descriptor.EnumTypes);
                WriteChildren(writer, null, Descriptor.NestedTypes);
                writer.Outdent();
                writer.WriteLine("}");
                writer.WriteLine("#endregion");
                writer.WriteLine();
            }

            foreach (FieldDescriptor fieldDescriptor in Descriptor.Fields)
            {
                if (Descriptor.File.CSharpOptions.ClsCompliance && GetFieldConstantName(fieldDescriptor).StartsWith("_"))
                {
                    writer.WriteLine("[global::System.CLSCompliant(false)]");
                }

                // Rats: we lose the debug comment here :(
                writer.WriteLine("public const int {0} = {1};", GetFieldConstantName(fieldDescriptor),
                                 fieldDescriptor.FieldNumber);
                CreateFieldGenerator(fieldDescriptor).GenerateMembers(writer);
                writer.WriteLine();
            }

            if (OptimizeSpeed)
            {
                GenerateIsInitialized(writer);
                GenerateMessageSerializationMethods(writer);
            }
            if (UseLiteRuntime)
            {
                GenerateLiteRuntimeMethods(writer);
            }

            GenerateParseFromMethods(writer);
            GenerateBuilder(writer);

            // Force the static initialization code for the file to run, since it may
            // initialize static variables declared in this class.
            writer.WriteLine("static {0}() {{", ClassName);
            // We call object.ReferenceEquals() just to make it a valid statement on its own.
            // Another option would be GetType(), but that causes problems in DescriptorProtoFile,
            // where the bootstrapping is somewhat recursive - type initializers call
            // each other, effectively. We temporarily see Descriptor as null.
            writer.WriteLine("  object.ReferenceEquals({0}.Descriptor, null);",
                             DescriptorUtil.GetFullUmbrellaClassName(Descriptor));
            writer.WriteLine("}");

            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();
        }

        private void GenerateLiteRuntimeMethods(TextGenerator writer)
        {
            bool callbase = Descriptor.Proto.ExtensionRangeCount > 0;
            writer.WriteLine("#region Lite runtime methods");
            writer.WriteLine("public override int GetHashCode() {");
            writer.Indent();
            writer.WriteLine("int hash = GetType().GetHashCode();");
            foreach (FieldDescriptor fieldDescriptor in Descriptor.Fields)
            {
                CreateFieldGenerator(fieldDescriptor).WriteHash(writer);
            }
            if (callbase)
            {
                writer.WriteLine("hash ^= base.GetHashCode();");
            }
            writer.WriteLine("return hash;");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();

            writer.WriteLine("public override bool Equals(object obj) {");
            writer.Indent();
            writer.WriteLine("{0} other = obj as {0};", ClassName);
            writer.WriteLine("if (other == null) return false;");
            foreach (FieldDescriptor fieldDescriptor in Descriptor.Fields)
            {
                CreateFieldGenerator(fieldDescriptor).WriteEquals(writer);
            }
            if (callbase)
            {
                writer.WriteLine("if (!base.Equals(other)) return false;");
            }
            writer.WriteLine("return true;");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();

            writer.WriteLine("public override void PrintTo(global::System.IO.TextWriter writer) {");
            writer.Indent();
            List<FieldDescriptor> sorted = new List<FieldDescriptor>(Descriptor.Fields);
            sorted.Sort(
                new Comparison<FieldDescriptor>(
                    delegate(FieldDescriptor a, FieldDescriptor b) { return a.FieldNumber.CompareTo(b.FieldNumber); }));
            foreach (FieldDescriptor fieldDescriptor in sorted)
            {
                CreateFieldGenerator(fieldDescriptor).WriteToString(writer);
            }
            if (callbase)
            {
                writer.WriteLine("base.PrintTo(writer);");
            }
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine("#endregion");
            writer.WriteLine();
        }

        private void GenerateMessageSerializationMethods(TextGenerator writer)
        {
            List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields);
            sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));

            List<DescriptorProto.Types.ExtensionRange> sortedExtensions =
                new List<DescriptorProto.Types.ExtensionRange>(Descriptor.Proto.ExtensionRangeList);
            sortedExtensions.Sort((r1, r2) => (r1.Start.CompareTo(r2.Start)));

            writer.WriteLine("public override void WriteTo(pb::ICodedOutputStream output) {");
            writer.Indent();
            // Make sure we've computed the serialized length, so that packed fields are generated correctly.
            writer.WriteLine("int size = SerializedSize;");
            writer.WriteLine("string[] field_names = _{0}FieldNames;", NameHelpers.UnderscoresToCamelCase(ClassName));
            if (Descriptor.Proto.ExtensionRangeList.Count > 0)
            {
                writer.WriteLine(
                    "pb::ExtendableMessage{1}<{0}, {0}.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);",
                    ClassName, RuntimeSuffix);
            }

            // Merge the fields and the extension ranges, both sorted by field number.
            for (int i = 0, j = 0; i < Descriptor.Fields.Count || j < sortedExtensions.Count;)
            {
                if (i == Descriptor.Fields.Count)
                {
                    GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
                }
                else if (j == sortedExtensions.Count)
                {
                    GenerateSerializeOneField(writer, sortedFields[i++]);
                }
                else if (sortedFields[i].FieldNumber < sortedExtensions[j].Start)
                {
                    GenerateSerializeOneField(writer, sortedFields[i++]);
                }
                else
                {
                    GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
                }
            }

            if (!UseLiteRuntime)
            {
                if (Descriptor.Proto.Options.MessageSetWireFormat)
                {
                    writer.WriteLine("UnknownFields.WriteAsMessageSetTo(output);");
                }
                else
                {
                    writer.WriteLine("UnknownFields.WriteTo(output);");
                }
            }

            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine("private int memoizedSerializedSize = -1;");
            writer.WriteLine("public override int SerializedSize {");
            writer.Indent();
            writer.WriteLine("get {");
            writer.Indent();
            writer.WriteLine("int size = memoizedSerializedSize;");
            writer.WriteLine("if (size != -1) return size;");
            writer.WriteLine();
            writer.WriteLine("size = 0;");
            foreach (FieldDescriptor field in Descriptor.Fields)
            {
                CreateFieldGenerator(field).GenerateSerializedSizeCode(writer);
            }
            if (Descriptor.Proto.ExtensionRangeCount > 0)
            {
                writer.WriteLine("size += ExtensionsSerializedSize;");
            }

            if (!UseLiteRuntime)
            {
                if (Descriptor.Options.MessageSetWireFormat)
                {
                    writer.WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;");
                }
                else
                {
                    writer.WriteLine("size += UnknownFields.SerializedSize;");
                }
            }
            writer.WriteLine("memoizedSerializedSize = size;");
            writer.WriteLine("return size;");
            writer.Outdent();
            writer.WriteLine("}");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();
        }

        private void GenerateSerializeOneField(TextGenerator writer, FieldDescriptor fieldDescriptor)
        {
            CreateFieldGenerator(fieldDescriptor).GenerateSerializationCode(writer);
        }

        private static void GenerateSerializeOneExtensionRange(TextGenerator writer,
                                                               DescriptorProto.Types.ExtensionRange extensionRange)
        {
            writer.WriteLine("extensionWriter.WriteUntil({0}, output);", extensionRange.End);
        }

        private void GenerateParseFromMethods(TextGenerator writer)
        {
            // Note:  These are separate from GenerateMessageSerializationMethods()
            //   because they need to be generated even for messages that are optimized
            //   for code size.

            writer.WriteLine("public static {0} ParseFrom(pb::ByteString data) {{", ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine(
                "public static {0} ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {{",
                ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine("public static {0} ParseFrom(byte[] data) {{", ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine("public static {0} ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {{",
                             ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input) {{", ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine(
                "public static {0} ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {{",
                ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine("public static {0} ParseDelimitedFrom(global::System.IO.Stream input) {{", ClassName);
            writer.WriteLine("  return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine(
                "public static {0} ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {{",
                ClassName);
            writer.WriteLine("  return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine("public static {0} ParseFrom(pb::ICodedInputStream input) {{", ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
            writer.WriteLine("}");
            writer.WriteLine(
                "public static {0} ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {{",
                ClassName);
            writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
            writer.WriteLine("}");
        }

        /// <summary>
        /// Returns whether or not the specified message type has any required fields.
        /// If it doesn't, calls to check for initialization can be optimised.
        /// TODO(jonskeet): Move this into MessageDescriptor?
        /// </summary>
        private static bool HasRequiredFields(MessageDescriptor descriptor,
                                              Dictionary<MessageDescriptor, object> alreadySeen)
        {
            if (alreadySeen.ContainsKey(descriptor))
            {
                // The type is already in cache.  This means that either:
                // a. The type has no required fields.
                // b. We are in the midst of checking if the type has required fields,
                //    somewhere up the stack.  In this case, we know that if the type
                //    has any required fields, they'll be found when we return to it,
                //    and the whole call to HasRequiredFields() will return true.
                //    Therefore, we don't have to check if this type has required fields
                //    here.
                return false;
            }
            alreadySeen[descriptor] = descriptor; // Value is irrelevant

            // If the type has extensions, an extension with message type could contain
            // required fields, so we have to be conservative and assume such an
            // extension exists.
            if (descriptor.Extensions.Count > 0)
            {
                return true;
            }

            foreach (FieldDescriptor field in descriptor.Fields)
            {
                if (field.IsRequired)
                {
                    return true;
                }
                // Message or group
                if (field.MappedType == MappedType.Message)
                {
                    if (HasRequiredFields(field.MessageType, alreadySeen))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private void GenerateBuilder(TextGenerator writer)
        {
            writer.WriteLine("private {0} MakeReadOnly() {{", ClassName);
            writer.Indent();
            foreach (FieldDescriptor field in Descriptor.Fields)
            {
                CreateFieldGenerator(field).GenerateBuildingCode(writer);
            }
            writer.WriteLine("return this;");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();

            writer.WriteLine("public static Builder CreateBuilder() { return new Builder(); }");
            writer.WriteLine("public override Builder ToBuilder() { return CreateBuilder(this); }");
            writer.WriteLine("public override Builder CreateBuilderForType() { return new Builder(); }");
            writer.WriteLine("public static Builder CreateBuilder({0} prototype) {{", ClassName);
            writer.WriteLine("  return new Builder(prototype);");
            writer.WriteLine("}");
            writer.WriteLine();
            if (Descriptor.File.CSharpOptions.AddSerializable)
            {
                writer.WriteLine("[global::System.SerializableAttribute()]");
            }
            writer.WriteLine("[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
            WriteGeneratedCodeAttributes(writer);
            writer.WriteLine("{0} sealed partial class Builder : pb::{2}Builder{3}<{1}, Builder> {{",
                             ClassAccessLevel, ClassName,
                             Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated", RuntimeSuffix);
            writer.Indent();
            writer.WriteLine("protected override Builder ThisBuilder {");
            writer.WriteLine("  get { return this; }");
            writer.WriteLine("}");
            GenerateCommonBuilderMethods(writer);
            if (OptimizeSpeed)
            {
                GenerateBuilderParsingMethods(writer);
            }
            foreach (FieldDescriptor field in Descriptor.Fields)
            {
                writer.WriteLine();
                // No field comment :(
                CreateFieldGenerator(field).GenerateBuilderMembers(writer);
            }
            writer.Outdent();
            writer.WriteLine("}");
        }

        private void GenerateCommonBuilderMethods(TextGenerator writer)
        {
            //default constructor
            writer.WriteLine("public Builder() {");
            //Durring static initialization of message, DefaultInstance is expected to return null.
            writer.WriteLine("  result = DefaultInstance;");
            writer.WriteLine("  resultIsReadOnly = true;");
            writer.WriteLine("}");
            //clone constructor
            writer.WriteLine("internal Builder({0} cloneFrom) {{", ClassName);
            writer.WriteLine("  result = cloneFrom;");
            writer.WriteLine("  resultIsReadOnly = true;");
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine("private bool resultIsReadOnly;");
            writer.WriteLine("private {0} result;", ClassName);
            writer.WriteLine();
            writer.WriteLine("private {0} PrepareBuilder() {{", ClassName);
            writer.WriteLine("  if (resultIsReadOnly) {");
            writer.WriteLine("    {0} original = result;", ClassName);
            writer.WriteLine("    result = new {0}();", ClassName);
            writer.WriteLine("    resultIsReadOnly = false;");
            writer.WriteLine("    MergeFrom(original);");
            writer.WriteLine("  }");
            writer.WriteLine("  return result;");
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine("public override bool IsInitialized {");
            writer.WriteLine("  get { return result.IsInitialized; }");
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine("protected override {0} MessageBeingBuilt {{", ClassName);
            writer.WriteLine("  get { return PrepareBuilder(); }");
            writer.WriteLine("}");
            writer.WriteLine();
            //Not actually expecting that DefaultInstance would ever be null here; however, we will ensure it does not break
            writer.WriteLine("public override Builder Clear() {");
            writer.WriteLine("  result = DefaultInstance;", ClassName);
            writer.WriteLine("  resultIsReadOnly = true;");
            writer.WriteLine("  return this;");
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine("public override Builder Clone() {");
            writer.WriteLine("  if (resultIsReadOnly) {");
            writer.WriteLine("    return new Builder(result);");
            writer.WriteLine("  } else {");
            writer.WriteLine("    return new Builder().MergeFrom(result);");
            writer.WriteLine("  }");
            writer.WriteLine("}");
            writer.WriteLine();
            if (!UseLiteRuntime)
            {
                writer.WriteLine("public override pbd::MessageDescriptor DescriptorForType {");
                writer.WriteLine("  get {{ return {0}.Descriptor; }}", FullClassName);
                writer.WriteLine("}");
                writer.WriteLine();
            }
            writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
            writer.WriteLine("  get {{ return {0}.DefaultInstance; }}", FullClassName);
            writer.WriteLine("}");
            writer.WriteLine();

            writer.WriteLine("public override {0} BuildPartial() {{", ClassName);
            writer.Indent();
            writer.WriteLine("if (resultIsReadOnly) {");
            writer.WriteLine("  return result;");
            writer.WriteLine("}");
            writer.WriteLine("resultIsReadOnly = true;");
            writer.WriteLine("return result.MakeReadOnly();");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();

            if (OptimizeSpeed)
            {
                writer.WriteLine("public override Builder MergeFrom(pb::IMessage{0} other) {{", RuntimeSuffix);
                writer.WriteLine("  if (other is {0}) {{", ClassName);
                writer.WriteLine("    return MergeFrom(({0}) other);", ClassName);
                writer.WriteLine("  } else {");
                writer.WriteLine("    base.MergeFrom(other);");
                writer.WriteLine("    return this;");
                writer.WriteLine("  }");
                writer.WriteLine("}");
                writer.WriteLine();
                writer.WriteLine("public override Builder MergeFrom({0} other) {{", ClassName);
                // Optimization:  If other is the default instance, we know none of its
                // fields are set so we can skip the merge.
                writer.Indent();
                writer.WriteLine("if (other == {0}.DefaultInstance) return this;", FullClassName);
                writer.WriteLine("PrepareBuilder();");
                foreach (FieldDescriptor field in Descriptor.Fields)
                {
                    CreateFieldGenerator(field).GenerateMergingCode(writer);
                }
                // if message type has extensions
                if (Descriptor.Proto.ExtensionRangeCount > 0)
                {
                    writer.WriteLine("  this.MergeExtensionFields(other);");
                }
                if (!UseLiteRuntime)
                {
                    writer.WriteLine("this.MergeUnknownFields(other.UnknownFields);");
                }
                writer.WriteLine("return this;");
                writer.Outdent();
                writer.WriteLine("}");
                writer.WriteLine();
            }
        }

        private void GenerateBuilderParsingMethods(TextGenerator writer)
        {
            List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields);
            sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));

            writer.WriteLine("public override Builder MergeFrom(pb::ICodedInputStream input) {");
            writer.WriteLine("  return MergeFrom(input, pb::ExtensionRegistry.Empty);");
            writer.WriteLine("}");
            writer.WriteLine();
            writer.WriteLine(
                "public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {");
            writer.Indent();
            writer.WriteLine("PrepareBuilder();");
            if (!UseLiteRuntime)
            {
                writer.WriteLine("pb::UnknownFieldSet.Builder unknownFields = null;");
            }
            writer.WriteLine("uint tag;");
            writer.WriteLine("string field_name;");
            writer.WriteLine("while (input.ReadTag(out tag, out field_name)) {");
            writer.Indent();
            writer.WriteLine("if(tag == 0 && field_name != null) {");
            writer.Indent();
            //if you change from StringComparer.Ordinal, the array sort in FieldNames { get; } must also change
            writer.WriteLine(
                "int field_ordinal = global::System.Array.BinarySearch(_{0}FieldNames, field_name, global::System.StringComparer.Ordinal);",
                NameHelpers.UnderscoresToCamelCase(ClassName));
            writer.WriteLine("if(field_ordinal >= 0)");
            writer.WriteLine("  tag = _{0}FieldTags[field_ordinal];", NameHelpers.UnderscoresToCamelCase(ClassName));
            writer.WriteLine("else {");
            if (!UseLiteRuntime)
            {
                writer.WriteLine("  if (unknownFields == null) {"); // First unknown field - create builder now
                writer.WriteLine("    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);");
                writer.WriteLine("  }");
            }
            writer.WriteLine("  ParseUnknownField(input, {0}extensionRegistry, tag, field_name);",
                             UseLiteRuntime ? "" : "unknownFields, ");
            writer.WriteLine("  continue;");
            writer.WriteLine("}");
            writer.Outdent();
            writer.WriteLine("}");

            writer.WriteLine("switch (tag) {");
            writer.Indent();
            writer.WriteLine("case 0: {"); // 0 signals EOF / limit reached
            writer.WriteLine("  throw pb::InvalidProtocolBufferException.InvalidTag();");
            writer.WriteLine("}");
            writer.WriteLine("default: {");
            writer.WriteLine("  if (pb::WireFormat.IsEndGroupTag(tag)) {");
            if (!UseLiteRuntime)
            {
                writer.WriteLine("    if (unknownFields != null) {");
                writer.WriteLine("      this.UnknownFields = unknownFields.Build();");
                writer.WriteLine("    }");
            }
            writer.WriteLine("    return this;"); // it's an endgroup tag
            writer.WriteLine("  }");
            if (!UseLiteRuntime)
            {
                writer.WriteLine("  if (unknownFields == null) {"); // First unknown field - create builder now
                writer.WriteLine("    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);");
                writer.WriteLine("  }");
            }
            writer.WriteLine("  ParseUnknownField(input, {0}extensionRegistry, tag, field_name);",
                             UseLiteRuntime ? "" : "unknownFields, ");
            writer.WriteLine("  break;");
            writer.WriteLine("}");
            foreach (FieldDescriptor field in sortedFields)
            {
                WireFormat.WireType wt = WireFormat.GetWireType(field.FieldType);
                uint tag = WireFormat.MakeTag(field.FieldNumber, wt);

                if (field.IsRepeated &&
                    (wt == WireFormat.WireType.Varint || wt == WireFormat.WireType.Fixed32 ||
                     wt == WireFormat.WireType.Fixed64))
                {
                    writer.WriteLine("case {0}:",
                                     WireFormat.MakeTag(field.FieldNumber, WireFormat.WireType.LengthDelimited));
                }

                writer.WriteLine("case {0}: {{", tag);
                writer.Indent();
                CreateFieldGenerator(field).GenerateParsingCode(writer);
                writer.WriteLine("break;");
                writer.Outdent();
                writer.WriteLine("}");
            }
            writer.Outdent();
            writer.WriteLine("}");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();
            if (!UseLiteRuntime)
            {
                writer.WriteLine("if (unknownFields != null) {");
                writer.WriteLine("  this.UnknownFields = unknownFields.Build();");
                writer.WriteLine("}");
            }
            writer.WriteLine("return this;");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();
        }

        private void GenerateIsInitialized(TextGenerator writer)
        {
            writer.WriteLine("public override bool IsInitialized {");
            writer.Indent();
            writer.WriteLine("get {");
            writer.Indent();

            // Check that all required fields in this message are set.
            // TODO(kenton):  We can optimize this when we switch to putting all the
            // "has" fields into a single bitfield.
            foreach (FieldDescriptor field in Descriptor.Fields)
            {
                if (field.IsRequired)
                {
                    writer.WriteLine("if (!has{0}) return false;", field.CSharpOptions.PropertyName);
                }
            }

            // Now check that all embedded messages are initialized.
            foreach (FieldDescriptor field in Descriptor.Fields)
            {
                if (field.FieldType != FieldType.Message ||
                    !HasRequiredFields(field.MessageType, new Dictionary<MessageDescriptor, object>()))
                {
                    continue;
                }
                string propertyName = NameHelpers.UnderscoresToPascalCase(GetFieldName(field));
                if (field.IsRepeated)
                {
                    writer.WriteLine("foreach ({0} element in {1}List) {{", GetClassName(field.MessageType),
                                     propertyName);
                    writer.WriteLine("  if (!element.IsInitialized) return false;");
                    writer.WriteLine("}");
                }
                else if (field.IsOptional)
                {
                    writer.WriteLine("if (Has{0}) {{", propertyName);
                    writer.WriteLine("  if (!{0}.IsInitialized) return false;", propertyName);
                    writer.WriteLine("}");
                }
                else
                {
                    writer.WriteLine("if (!{0}.IsInitialized) return false;", propertyName);
                }
            }

            if (Descriptor.Proto.ExtensionRangeCount > 0)
            {
                writer.WriteLine("if (!ExtensionsAreInitialized) return false;");
            }
            writer.WriteLine("return true;");
            writer.Outdent();
            writer.WriteLine("}");
            writer.Outdent();
            writer.WriteLine("}");
            writer.WriteLine();
        }

        internal void GenerateExtensionRegistrationCode(TextGenerator writer)
        {
            foreach (FieldDescriptor extension in Descriptor.Extensions)
            {
                new ExtensionGenerator(extension).GenerateExtensionRegistrationCode(writer);
            }
            foreach (MessageDescriptor nestedMessage in Descriptor.NestedTypes)
            {
                new MessageGenerator(nestedMessage).GenerateExtensionRegistrationCode(writer);
            }
        }
    }
}