A few performance tweaks of the ICodedOutputStream interface/implementation

4 files changed, 513 insertions, 285 deletions

diff --git a/src/ProtocolBuffers/CodedOutputStream.cs b/src/ProtocolBuffers/CodedOutputStream.cs
index 39523c96..31032058 100644
--- a/src/ProtocolBuffers/CodedOutputStream.cs
+++ b/src/ProtocolBuffers/CodedOutputStream.cs
@@ -35,6 +35,7 @@
 #endregion

 

 using System;

+using System.Collections.Generic;

 using System.Globalization;

 using System.IO;

 using System.Text;

@@ -315,23 +316,103 @@ namespace Google.ProtocolBuffers
             WriteBytes(WireFormat.MessageSetField.Message, "message", value);

             WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup);

         }

-

+        

         public void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list)

         {

             foreach (object element in list)

                 WriteField(fieldType, fieldNumber, fieldName, element);

         }

 

+        public void WriteArray<T>(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable<T> list)

+        {

+            switch (fieldType)

+            {

+                case FieldType.String:

+                    foreach (string value in ((IEnumerable<string>)list))

+                        WriteString(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Message:

+                    foreach (T value in list)

+                        WriteMessage(fieldNumber, fieldName, (IMessageLite)value);

+                    break;

+                case FieldType.Group:

+                    foreach (T value in list)

+                        WriteGroup(fieldNumber, fieldName, (IMessageLite)value);

+                    break;

+                case FieldType.Bytes:

+                    foreach (ByteString value in ((IEnumerable<ByteString>)list))

+                        WriteBytes(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Bool:

+                    foreach (bool value in ((IEnumerable<bool>)list))

+                        WriteBool(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Enum:

+                    foreach (T value in list)

+                    {

+                        if (value is System.Enum)

+                            WriteEnum(fieldNumber, fieldName, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture), null/*not used*/);

+                        else

+                            WriteEnum(fieldNumber, fieldName, ((IEnumLite)value).Number, null/*not used*/);

+                    }

+                    break;

+                case FieldType.Int32:

+                    foreach (int value in ((IEnumerable<int>)list))

+                        WriteInt32(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Int64:

+                    foreach (long value in ((IEnumerable<long>)list))

+                        WriteInt64(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.UInt32:

+                    foreach (uint value in ((IEnumerable<uint>)list))

+                        WriteUInt32(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.UInt64:

+                    foreach (ulong value in ((IEnumerable<ulong>)list))

+                        WriteUInt64(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.SInt32:

+                    foreach (int value in ((IEnumerable<int>)list))

+                        WriteSInt32(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.SInt64:

+                    foreach (long value in ((IEnumerable<long>)list))

+                        WriteSInt64(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Fixed32:

+                    foreach (uint value in ((IEnumerable<uint>)list))

+                        WriteFixed32(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Fixed64:

+                    foreach (ulong value in ((IEnumerable<ulong>)list))

+                        WriteFixed64(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.SFixed32:

+                    foreach (int value in ((IEnumerable<int>)list))

+                        WriteSFixed32(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.SFixed64:

+                    foreach (long value in ((IEnumerable<long>)list))

+                        WriteSFixed64(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Double:

+                    foreach (double value in ((IEnumerable<double>)list))

+                        WriteDouble(fieldNumber, fieldName, value);

+                    break;

+                case FieldType.Float:

+                    foreach (float value in ((IEnumerable<float>)list))

+                        WriteFloat(fieldNumber, fieldName, value);

+                    break;

+            }

+        }

+

         public void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list)

         {

             int calculatedSize = 0;

             foreach (object element in list)

                 calculatedSize += CodedOutputStream.ComputeFieldSizeNoTag(fieldType, element);

-            WritePackedArray(fieldType, fieldNumber, fieldName, calculatedSize, list);

-        }

-

-        public void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, int calculatedSize, System.Collections.IEnumerable list)

-        {

+            

             WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);

             WriteRawVarint32((uint)calculatedSize);

             

@@ -339,66 +420,153 @@ namespace Google.ProtocolBuffers
                 WriteFieldNoTag(fieldType, element);

         }

 

-        public void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value)

+        public void WritePackedArray<T>(FieldType fieldType, int fieldNumber, string fieldName, int calculatedSize, System.Collections.Generic.IEnumerable<T> list)

         {

+            WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);

+            WriteRawVarint32((uint)calculatedSize);

+

             switch (fieldType)

             {

-                case FieldType.Double:

-                    WriteDouble(fieldNumber, fieldName, (double) value);

+                case FieldType.String:

+                    foreach (string value in ((IEnumerable<string>)list))

+                        WriteStringNoTag(value);

                     break;

-                case FieldType.Float:

-                    WriteFloat(fieldNumber, fieldName, (float) value);

+                case FieldType.Message:

+                    foreach (T value in list)

+                        WriteMessageNoTag((IMessageLite)value);

+                    break;

+                case FieldType.Group:

+                    foreach (T value in list)

+                        WriteGroupNoTag((IMessageLite)value);

+                    break;

+                case FieldType.Bytes:

+                    foreach (ByteString value in ((IEnumerable<ByteString>)list))

+                        WriteBytesNoTag(value);

+                    break;

+                case FieldType.Bool:

+                    foreach (bool value in ((IEnumerable<bool>)list))

+                        WriteBoolNoTag(value);

+                    break;

+                case FieldType.Enum:

+                    foreach (T value in list)

+                    {

+                        if (value is System.Enum)

+                            WriteEnumNoTag(((IConvertible)value).ToInt32(CultureInfo.InvariantCulture));

+                        else

+                            WriteEnumNoTag(((IEnumLite)value).Number);

+                    }

+                    break;

+                case FieldType.Int32:

+                    foreach (int value in ((IEnumerable<int>)list))

+                        WriteInt32NoTag(value);

                     break;

                 case FieldType.Int64:

-                    WriteInt64(fieldNumber, fieldName, (long) value);

+                    foreach (long value in ((IEnumerable<long>)list))

+                        WriteInt64NoTag(value);

+                    break;

+                case FieldType.UInt32:

+                    foreach (uint value in ((IEnumerable<uint>)list))

+                        WriteUInt32NoTag(value);

                     break;

                 case FieldType.UInt64:

-                    WriteUInt64(fieldNumber, fieldName, (ulong) value);

+                    foreach (ulong value in ((IEnumerable<ulong>)list))

+                        WriteUInt64NoTag(value);

                     break;

-                case FieldType.Int32:

-                    WriteInt32(fieldNumber, fieldName, (int) value);

+                case FieldType.SInt32:

+                    foreach (int value in ((IEnumerable<int>)list))

+                        WriteSInt32NoTag(value);

                     break;

-                case FieldType.Fixed64:

-                    WriteFixed64(fieldNumber, fieldName, (ulong) value);

+                case FieldType.SInt64:

+                    foreach (long value in ((IEnumerable<long>)list))

+                        WriteSInt64NoTag(value);

                     break;

                 case FieldType.Fixed32:

-                    WriteFixed32(fieldNumber, fieldName, (uint) value);

+                    foreach (uint value in ((IEnumerable<uint>)list))

+                        WriteFixed32NoTag(value);

                     break;

-                case FieldType.Bool:

-                    WriteBool(fieldNumber, fieldName, (bool) value);

+                case FieldType.Fixed64:

+                    foreach (ulong value in ((IEnumerable<ulong>)list))

+                        WriteFixed64NoTag(value);

                     break;

-                case FieldType.String:

-                    WriteString(fieldNumber, fieldName, (string) value);

+                case FieldType.SFixed32:

+                    foreach (int value in ((IEnumerable<int>)list))

+                        WriteSFixed32NoTag(value);

                     break;

-                case FieldType.Group:

-                    WriteGroup(fieldNumber, fieldName, (IMessageLite) value);

+                case FieldType.SFixed64:

+                    foreach (long value in ((IEnumerable<long>)list))

+                        WriteSFixed64NoTag(value);

+                    break;

+                case FieldType.Double:

+                    foreach (double value in ((IEnumerable<double>)list))

+                        WriteDoubleNoTag(value);

+                    break;

+                case FieldType.Float:

+                    foreach (float value in ((IEnumerable<float>)list))

+                        WriteFloatNoTag(value);

+                    break;

+            }

+        }

+

+        public void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value)

+        {

+            switch (fieldType)

+            {

+                case FieldType.String:

+                    WriteString(fieldNumber, fieldName, (string)value);

                     break;

                 case FieldType.Message:

-                    WriteMessage(fieldNumber, fieldName, (IMessageLite) value);

+                    WriteMessage(fieldNumber, fieldName, (IMessageLite)value);

+                    break;

+                case FieldType.Group:

+                    WriteGroup(fieldNumber, fieldName, (IMessageLite)value);

                     break;

                 case FieldType.Bytes:

-                    WriteBytes(fieldNumber, fieldName, (ByteString) value);

+                    WriteBytes(fieldNumber, fieldName, (ByteString)value);

+                    break;

+                case FieldType.Bool:

+                    WriteBool(fieldNumber, fieldName, (bool)value);

+                    break;

+                case FieldType.Enum:

+                    if (value is System.Enum)

+                        WriteEnum(fieldNumber, fieldName, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture), null/*not used*/);

+                    else

+                        WriteEnum(fieldNumber, fieldName, ((IEnumLite)value).Number, null/*not used*/);

+                    break;

+                case FieldType.Int32:

+                    WriteInt32(fieldNumber, fieldName, (int) value);

+                    break;

+                case FieldType.Int64:

+                    WriteInt64(fieldNumber, fieldName, (long) value);

                     break;

                 case FieldType.UInt32:

                     WriteUInt32(fieldNumber, fieldName, (uint) value);

                     break;

+                case FieldType.UInt64:

+                    WriteUInt64(fieldNumber, fieldName, (ulong) value);

+                    break;

+                case FieldType.SInt32:

+                    WriteSInt32(fieldNumber, fieldName, (int)value);

+                    break;

+                case FieldType.SInt64:

+                    WriteSInt64(fieldNumber, fieldName, (long)value);

+                    break;

+                case FieldType.Fixed32:

+                    WriteFixed32(fieldNumber, fieldName, (uint) value);

+                    break;

+                case FieldType.Fixed64:

+                    WriteFixed64(fieldNumber, fieldName, (ulong) value);

+                    break;

                 case FieldType.SFixed32:

                     WriteSFixed32(fieldNumber, fieldName, (int) value);

                     break;

                 case FieldType.SFixed64:

                     WriteSFixed64(fieldNumber, fieldName, (long) value);

                     break;

-                case FieldType.SInt32:

-                    WriteSInt32(fieldNumber, fieldName, (int) value);

-                    break;

-                case FieldType.SInt64:

-                    WriteSInt64(fieldNumber, fieldName, (long) value);

+                case FieldType.Double:

+                    WriteDouble(fieldNumber, fieldName, (double)value);

                     break;

-                case FieldType.Enum:

-                    if(value is System.Enum)

-                        WriteEnum(fieldNumber, fieldName, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture), null/*not used*/);

-                    else

-                        WriteEnum(fieldNumber, fieldName, ((IEnumLite) value).Number, null/*not used*/);

+                case FieldType.Float:

+                    WriteFloat(fieldNumber, fieldName, (float)value);

                     break;

             }

         }

@@ -407,44 +575,50 @@ namespace Google.ProtocolBuffers
         {

             switch (fieldType)

             {

-                case FieldType.Double:

-                    WriteDoubleNoTag((double) value);

+                case FieldType.String:

+                    WriteStringNoTag((string)value);

                     break;

-                case FieldType.Float:

-                    WriteFloatNoTag((float) value);

+                case FieldType.Message:

+                    WriteMessageNoTag((IMessageLite)value);

                     break;

-                case FieldType.Int64:

-                    WriteInt64NoTag((long) value);

+                case FieldType.Group:

+                    WriteGroupNoTag((IMessageLite)value);

                     break;

-                case FieldType.UInt64:

-                    WriteUInt64NoTag((ulong) value);

+                case FieldType.Bytes:

+                    WriteBytesNoTag((ByteString)value);

+                    break;

+                case FieldType.Bool:

+                    WriteBoolNoTag((bool)value);

+                    break;

+                case FieldType.Enum:

+                    if (value is System.Enum)

+                        WriteEnumNoTag(((IConvertible)value).ToInt32(CultureInfo.InvariantCulture));

+                    else

+                        WriteEnumNoTag(((IEnumLite)value).Number);

                     break;

                 case FieldType.Int32:

                     WriteInt32NoTag((int) value);

                     break;

-                case FieldType.Fixed64:

-                    WriteFixed64NoTag((ulong) value);

-                    break;

-                case FieldType.Fixed32:

-                    WriteFixed32NoTag((uint) value);

+                case FieldType.Int64:

+                    WriteInt64NoTag((long) value);

                     break;

-                case FieldType.Bool:

-                    WriteBoolNoTag((bool) value);

+                case FieldType.UInt32:

+                    WriteUInt32NoTag((uint) value);

                     break;

-                case FieldType.String:

-                    WriteStringNoTag((string) value);

+                case FieldType.UInt64:

+                    WriteUInt64NoTag((ulong) value);

                     break;

-                case FieldType.Group:

-                    WriteGroupNoTag((IMessageLite) value);

+                case FieldType.SInt32:

+                    WriteSInt32NoTag((int) value);

                     break;

-                case FieldType.Message:

-                    WriteMessageNoTag((IMessageLite) value);

+                case FieldType.SInt64:

+                    WriteSInt64NoTag((long) value);

                     break;

-                case FieldType.Bytes:

-                    WriteBytesNoTag((ByteString) value);

+                case FieldType.Fixed32:

+                    WriteFixed32NoTag((uint) value);

                     break;

-                case FieldType.UInt32:

-                    WriteUInt32NoTag((uint) value);

+                case FieldType.Fixed64:

+                    WriteFixed64NoTag((ulong) value);

                     break;

                 case FieldType.SFixed32:

                     WriteSFixed32NoTag((int) value);

@@ -452,17 +626,11 @@ namespace Google.ProtocolBuffers
                 case FieldType.SFixed64:

                     WriteSFixed64NoTag((long) value);

                     break;

-                case FieldType.SInt32:

-                    WriteSInt32NoTag((int) value);

-                    break;

-                case FieldType.SInt64:

-                    WriteSInt64NoTag((long) value);

+                case FieldType.Double:

+                    WriteDoubleNoTag((double)value);

                     break;

-                case FieldType.Enum:

-                    if (value is System.Enum)

-                        WriteEnumNoTag(((IConvertible)value).ToInt32(CultureInfo.InvariantCulture));

-                    else

-                        WriteEnumNoTag(((IEnumLite) value).Number);

+                case FieldType.Float:

+                    WriteFloatNoTag((float)value);

                     break;

             }

         }

@@ -641,6 +809,7 @@ namespace Google.ProtocolBuffers
             WriteRawVarint32(WireFormat.MakeTag(fieldNumber, type));

         }

 

+#if false

         private void SlowWriteRawVarint32(uint value)

         {

             while (true)

@@ -657,7 +826,7 @@ namespace Google.ProtocolBuffers
                 }

             }

         }

-

+#endif

         /// <summary>

         /// Writes a 32 bit value as a varint. The fast route is taken when

         /// there's enough buffer space left to whizz through without checking

@@ -666,6 +835,22 @@ namespace Google.ProtocolBuffers
         [CLSCompliant(false)]

         public void WriteRawVarint32(uint value)

         {

+#if true

+            while (value > 127 && position < limit)

+            {

+                buffer[position++] = (byte)((value & 0x7F) | 0x80);

+                value >>= 7;

+            }

+            while (value > 127)

+            {

+                WriteRawByte((byte)((value & 0x7F) | 0x80));

+                value >>= 7;

+            }

+            if(position < limit)

+                buffer[position++] = (byte)value;

+            else

+                WriteRawByte((byte)value);

+#else

             if (position + 5 > limit)

             {

                 SlowWriteRawVarint32(value);

@@ -685,11 +870,28 @@ namespace Google.ProtocolBuffers
                     value >>= 7;

                 }

             }

+#endif

         }

 

         [CLSCompliant(false)]

         public void WriteRawVarint64(ulong value)

         {

+#if true

+            while (value > 127 && position < limit)

+            {

+                buffer[position++] = (byte)((value & 0x7F) | 0x80);

+                value >>= 7;

+            }

+            while (value > 127)

+            {

+                WriteRawByte((byte)((value & 0x7F) | 0x80));

+                value >>= 7;

+            }

+            if(position < limit)

+                buffer[position++] = (byte)value;

+            else

+                WriteRawByte((byte)value);

+#else

             while (true)

             {

                 if ((value & ~0x7FUL) == 0)

@@ -703,28 +905,53 @@ namespace Google.ProtocolBuffers
                     value >>= 7;

                 }

             }

+#endif

         }

 

         [CLSCompliant(false)]

         public void WriteRawLittleEndian32(uint value)

         {

-            WriteRawByte((byte) value);

-            WriteRawByte((byte) (value >> 8));

-            WriteRawByte((byte) (value >> 16));

-            WriteRawByte((byte) (value >> 24));

+            if (position + 4 > limit)

+            {

+                WriteRawByte((byte) value);

+                WriteRawByte((byte) (value >> 8));

+                WriteRawByte((byte) (value >> 16));

+                WriteRawByte((byte) (value >> 24));

+            }

+            else

+            {

+                buffer[position++] = ((byte)value);

+                buffer[position++] = ((byte)(value >> 8));

+                buffer[position++] = ((byte)(value >> 16));

+                buffer[position++] = ((byte)(value >> 24));

+            }

         }

 

         [CLSCompliant(false)]

         public void WriteRawLittleEndian64(ulong value)

         {

-            WriteRawByte((byte) value);

-            WriteRawByte((byte) (value >> 8));

-            WriteRawByte((byte) (value >> 16));

-            WriteRawByte((byte) (value >> 24));

-            WriteRawByte((byte) (value >> 32));

-            WriteRawByte((byte) (value >> 40));

-            WriteRawByte((byte) (value >> 48));

-            WriteRawByte((byte) (value >> 56));

+            if (position + 8 > limit)

+            {

+                WriteRawByte((byte) value);

+                WriteRawByte((byte) (value >> 8));

+                WriteRawByte((byte) (value >> 16));

+                WriteRawByte((byte) (value >> 24));

+                WriteRawByte((byte) (value >> 32));

+                WriteRawByte((byte) (value >> 40));

+                WriteRawByte((byte) (value >> 48));

+                WriteRawByte((byte) (value >> 56));

+            }

+            else

+            {

+                buffer[position++] = ((byte)value);

+                buffer[position++] = ((byte)(value >> 8));

+                buffer[position++] = ((byte)(value >> 16));

+                buffer[position++] = ((byte)(value >> 24));

+                buffer[position++] = ((byte)(value >> 32));

+                buffer[position++] = ((byte)(value >> 40));

+                buffer[position++] = ((byte)(value >> 48));

+                buffer[position++] = ((byte)(value >> 56));

+            }

         }

 

         public void WriteRawByte(byte value)

diff --git a/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs b/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
index a27e1904..164e6c60 100644
--- a/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
+++ b/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
@@ -282,43 +282,43 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasNamespace) {

+      if (hasNamespace) {

         output.WriteString(1, "namespace", Namespace);

       }

-      if (HasUmbrellaClassname) {

+      if (hasUmbrellaClassname) {

         output.WriteString(2, "umbrella_classname", UmbrellaClassname);

       }

-      if (HasPublicClasses) {

+      if (hasPublicClasses) {

         output.WriteBool(3, "public_classes", PublicClasses);

       }

-      if (HasMultipleFiles) {

+      if (hasMultipleFiles) {

         output.WriteBool(4, "multiple_files", MultipleFiles);

       }

-      if (HasNestClasses) {

+      if (hasNestClasses) {

         output.WriteBool(5, "nest_classes", NestClasses);

       }

-      if (HasCodeContracts) {

+      if (hasCodeContracts) {

         output.WriteBool(6, "code_contracts", CodeContracts);

       }

-      if (HasExpandNamespaceDirectories) {

+      if (hasExpandNamespaceDirectories) {

         output.WriteBool(7, "expand_namespace_directories", ExpandNamespaceDirectories);

       }

-      if (HasClsCompliance) {

+      if (hasClsCompliance) {

         output.WriteBool(8, "cls_compliance", ClsCompliance);

       }

-      if (HasFileExtension) {

+      if (hasFileExtension) {

         output.WriteString(221, "file_extension", FileExtension);

       }

-      if (HasUmbrellaNamespace) {

+      if (hasUmbrellaNamespace) {

         output.WriteString(222, "umbrella_namespace", UmbrellaNamespace);

       }

-      if (HasOutputDirectory) {

+      if (hasOutputDirectory) {

         output.WriteString(223, "output_directory", OutputDirectory);

       }

-      if (HasIgnoreGoogleProtobuf) {

+      if (hasIgnoreGoogleProtobuf) {

         output.WriteBool(224, "ignore_google_protobuf", IgnoreGoogleProtobuf);

       }

-      if (HasServiceGeneratorType) {

+      if (hasServiceGeneratorType) {

         output.WriteEnum(225, "service_generator_type", (int) ServiceGeneratorType, ServiceGeneratorType.ToString());

       }

       UnknownFields.WriteTo(output);

@@ -331,43 +331,43 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasNamespace) {

+        if (hasNamespace) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Namespace);

         }

-        if (HasUmbrellaClassname) {

+        if (hasUmbrellaClassname) {

           size += pb::CodedOutputStream.ComputeStringSize(2, UmbrellaClassname);

         }

-        if (HasPublicClasses) {

+        if (hasPublicClasses) {

           size += pb::CodedOutputStream.ComputeBoolSize(3, PublicClasses);

         }

-        if (HasMultipleFiles) {

+        if (hasMultipleFiles) {

           size += pb::CodedOutputStream.ComputeBoolSize(4, MultipleFiles);

         }

-        if (HasNestClasses) {

+        if (hasNestClasses) {

           size += pb::CodedOutputStream.ComputeBoolSize(5, NestClasses);

         }

-        if (HasCodeContracts) {

+        if (hasCodeContracts) {

           size += pb::CodedOutputStream.ComputeBoolSize(6, CodeContracts);

         }

-        if (HasExpandNamespaceDirectories) {

+        if (hasExpandNamespaceDirectories) {

           size += pb::CodedOutputStream.ComputeBoolSize(7, ExpandNamespaceDirectories);

         }

-        if (HasClsCompliance) {

+        if (hasClsCompliance) {

           size += pb::CodedOutputStream.ComputeBoolSize(8, ClsCompliance);

         }

-        if (HasFileExtension) {

+        if (hasFileExtension) {

           size += pb::CodedOutputStream.ComputeStringSize(221, FileExtension);

         }

-        if (HasUmbrellaNamespace) {

+        if (hasUmbrellaNamespace) {

           size += pb::CodedOutputStream.ComputeStringSize(222, UmbrellaNamespace);

         }

-        if (HasOutputDirectory) {

+        if (hasOutputDirectory) {

           size += pb::CodedOutputStream.ComputeStringSize(223, OutputDirectory);

         }

-        if (HasIgnoreGoogleProtobuf) {

+        if (hasIgnoreGoogleProtobuf) {

           size += pb::CodedOutputStream.ComputeBoolSize(224, IgnoreGoogleProtobuf);

         }

-        if (HasServiceGeneratorType) {

+        if (hasServiceGeneratorType) {

           size += pb::CodedOutputStream.ComputeEnumSize(225, (int) ServiceGeneratorType);

         }

         size += UnknownFields.SerializedSize;

@@ -605,7 +605,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasNamespace {

-        get { return result.HasNamespace; }

+        get { return result.hasNamespace; }

       }

       public string Namespace {

         get { return result.Namespace; }

@@ -624,7 +624,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasUmbrellaClassname {

-        get { return result.HasUmbrellaClassname; }

+        get { return result.hasUmbrellaClassname; }

       }

       public string UmbrellaClassname {

         get { return result.UmbrellaClassname; }

@@ -643,7 +643,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasPublicClasses {

-        get { return result.HasPublicClasses; }

+        get { return result.hasPublicClasses; }

       }

       public bool PublicClasses {

         get { return result.PublicClasses; }

@@ -661,7 +661,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasMultipleFiles {

-        get { return result.HasMultipleFiles; }

+        get { return result.hasMultipleFiles; }

       }

       public bool MultipleFiles {

         get { return result.MultipleFiles; }

@@ -679,7 +679,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasNestClasses {

-        get { return result.HasNestClasses; }

+        get { return result.hasNestClasses; }

       }

       public bool NestClasses {

         get { return result.NestClasses; }

@@ -697,7 +697,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasCodeContracts {

-        get { return result.HasCodeContracts; }

+        get { return result.hasCodeContracts; }

       }

       public bool CodeContracts {

         get { return result.CodeContracts; }

@@ -715,7 +715,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasExpandNamespaceDirectories {

-        get { return result.HasExpandNamespaceDirectories; }

+        get { return result.hasExpandNamespaceDirectories; }

       }

       public bool ExpandNamespaceDirectories {

         get { return result.ExpandNamespaceDirectories; }

@@ -733,7 +733,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasClsCompliance {

-        get { return result.HasClsCompliance; }

+        get { return result.hasClsCompliance; }

       }

       public bool ClsCompliance {

         get { return result.ClsCompliance; }

@@ -751,7 +751,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasFileExtension {

-        get { return result.HasFileExtension; }

+        get { return result.hasFileExtension; }

       }

       public string FileExtension {

         get { return result.FileExtension; }

@@ -770,7 +770,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasUmbrellaNamespace {

-        get { return result.HasUmbrellaNamespace; }

+        get { return result.hasUmbrellaNamespace; }

       }

       public string UmbrellaNamespace {

         get { return result.UmbrellaNamespace; }

@@ -789,7 +789,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOutputDirectory {

-        get { return result.HasOutputDirectory; }

+        get { return result.hasOutputDirectory; }

       }

       public string OutputDirectory {

         get { return result.OutputDirectory; }

@@ -808,7 +808,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasIgnoreGoogleProtobuf {

-        get { return result.HasIgnoreGoogleProtobuf; }

+        get { return result.hasIgnoreGoogleProtobuf; }

       }

       public bool IgnoreGoogleProtobuf {

         get { return result.IgnoreGoogleProtobuf; }

@@ -826,7 +826,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasServiceGeneratorType {

-       get { return result.HasServiceGeneratorType; }

+       get { return result.hasServiceGeneratorType; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType ServiceGeneratorType {

         get { return result.ServiceGeneratorType; }

@@ -891,7 +891,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasPropertyName) {

+      if (hasPropertyName) {

         output.WriteString(1, "property_name", PropertyName);

       }

       UnknownFields.WriteTo(output);

@@ -904,7 +904,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasPropertyName) {

+        if (hasPropertyName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, PropertyName);

         }

         size += UnknownFields.SerializedSize;

@@ -1050,7 +1050,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasPropertyName {

-        get { return result.HasPropertyName; }

+        get { return result.hasPropertyName; }

       }

       public string PropertyName {

         get { return result.PropertyName; }

@@ -1116,7 +1116,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasInterfaceId) {

+      if (hasInterfaceId) {

         output.WriteString(1, "interface_id", InterfaceId);

       }

       UnknownFields.WriteTo(output);

@@ -1129,7 +1129,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasInterfaceId) {

+        if (hasInterfaceId) {

           size += pb::CodedOutputStream.ComputeStringSize(1, InterfaceId);

         }

         size += UnknownFields.SerializedSize;

@@ -1275,7 +1275,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasInterfaceId {

-        get { return result.HasInterfaceId; }

+        get { return result.hasInterfaceId; }

       }

       public string InterfaceId {

         get { return result.InterfaceId; }

@@ -1341,7 +1341,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasDispatchId) {

+      if (hasDispatchId) {

         output.WriteInt32(1, "dispatch_id", DispatchId);

       }

       UnknownFields.WriteTo(output);

@@ -1354,7 +1354,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasDispatchId) {

+        if (hasDispatchId) {

           size += pb::CodedOutputStream.ComputeInt32Size(1, DispatchId);

         }

         size += UnknownFields.SerializedSize;

@@ -1500,7 +1500,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasDispatchId {

-        get { return result.HasDispatchId; }

+        get { return result.hasDispatchId; }

       }

       public int DispatchId {

         get { return result.DispatchId; }

diff --git a/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs b/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
index 3bacc235..0ab12e31 100644
--- a/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
+++ b/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
@@ -615,10 +615,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasName) {

+      if (hasName) {

         output.WriteString(1, "name", Name);

       }

-      if (HasPackage) {

+      if (hasPackage) {

         output.WriteString(2, "package", Package);

       }

       if (dependency_.Count > 0) {

@@ -636,7 +636,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       if (extension_.Count > 0) {

         output.WriteArray(pbd::FieldType.Message, 7, "extension", extension_);

       }

-      if (HasOptions) {

+      if (hasOptions) {

         output.WriteMessage(8, "options", Options);

       }

       UnknownFields.WriteTo(output);

@@ -649,10 +649,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasName) {

+        if (hasName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Name);

         }

-        if (HasPackage) {

+        if (hasPackage) {

           size += pb::CodedOutputStream.ComputeStringSize(2, Package);

         }

         {

@@ -675,7 +675,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {

           size += pb::CodedOutputStream.ComputeMessageSize(7, element);

         }

-        if (HasOptions) {

+        if (hasOptions) {

           size += pb::CodedOutputStream.ComputeMessageSize(8, Options);

         }

         size += UnknownFields.SerializedSize;

@@ -862,7 +862,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             }

             case 66: {

               global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder();

-              if (HasOptions) {

+              if (result.hasOptions) {

                 subBuilder.MergeFrom(Options);

               }

               input.ReadMessage(subBuilder, extensionRegistry);

@@ -880,7 +880,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasName {

-        get { return result.HasName; }

+        get { return result.hasName; }

       }

       public string Name {

         get { return result.Name; }

@@ -899,7 +899,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasPackage {

-        get { return result.HasPackage; }

+        get { return result.hasPackage; }

       }

       public string Package {

         get { return result.Package; }

@@ -1098,7 +1098,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptions {

-       get { return result.HasOptions; }

+       get { return result.hasOptions; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions Options {

         get { return result.Options; }

@@ -1118,7 +1118,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) {

         pb::ThrowHelper.ThrowIfNull(value, "value");

-        if (result.HasOptions &&

+        if (result.hasOptions &&

             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance) {

             result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();

         } else {

@@ -1221,10 +1221,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         

         public override void WriteTo(pb::ICodedOutputStream output) {

           int size = SerializedSize;

-          if (HasStart) {

+          if (hasStart) {

             output.WriteInt32(1, "start", Start);

           }

-          if (HasEnd) {

+          if (hasEnd) {

             output.WriteInt32(2, "end", End);

           }

           UnknownFields.WriteTo(output);

@@ -1237,10 +1237,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             if (size != -1) return size;

             

             size = 0;

-            if (HasStart) {

+            if (hasStart) {

               size += pb::CodedOutputStream.ComputeInt32Size(1, Start);

             }

-            if (HasEnd) {

+            if (hasEnd) {

               size += pb::CodedOutputStream.ComputeInt32Size(2, End);

             }

             size += UnknownFields.SerializedSize;

@@ -1393,7 +1393,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           

           

           public bool HasStart {

-            get { return result.HasStart; }

+            get { return result.hasStart; }

           }

           public int Start {

             get { return result.Start; }

@@ -1411,7 +1411,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           }

           

           public bool HasEnd {

-            get { return result.HasEnd; }

+            get { return result.hasEnd; }

           }

           public int End {

             get { return result.End; }

@@ -1539,7 +1539,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasName) {

+      if (hasName) {

         output.WriteString(1, "name", Name);

       }

       if (field_.Count > 0) {

@@ -1557,7 +1557,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       if (extension_.Count > 0) {

         output.WriteArray(pbd::FieldType.Message, 6, "extension", extension_);

       }

-      if (HasOptions) {

+      if (hasOptions) {

         output.WriteMessage(7, "options", Options);

       }

       UnknownFields.WriteTo(output);

@@ -1570,7 +1570,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasName) {

+        if (hasName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Name);

         }

         foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) {

@@ -1588,7 +1588,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in ExtensionRangeList) {

           size += pb::CodedOutputStream.ComputeMessageSize(5, element);

         }

-        if (HasOptions) {

+        if (hasOptions) {

           size += pb::CodedOutputStream.ComputeMessageSize(7, Options);

         }

         size += UnknownFields.SerializedSize;

@@ -1768,7 +1768,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             }

             case 58: {

               global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder();

-              if (HasOptions) {

+              if (result.hasOptions) {

                 subBuilder.MergeFrom(Options);

               }

               input.ReadMessage(subBuilder, extensionRegistry);

@@ -1786,7 +1786,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasName {

-        get { return result.HasName; }

+        get { return result.hasName; }

       }

       public string Name {

         get { return result.Name; }

@@ -1995,7 +1995,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptions {

-       get { return result.HasOptions; }

+       get { return result.hasOptions; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions Options {

         get { return result.Options; }

@@ -2015,7 +2015,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions value) {

         pb::ThrowHelper.ThrowIfNull(value, "value");

-        if (result.HasOptions &&

+        if (result.hasOptions &&

             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance) {

             result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();

         } else {

@@ -2190,28 +2190,28 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasName) {

+      if (hasName) {

         output.WriteString(1, "name", Name);

       }

-      if (HasExtendee) {

+      if (hasExtendee) {

         output.WriteString(2, "extendee", Extendee);

       }

-      if (HasNumber) {

+      if (hasNumber) {

         output.WriteInt32(3, "number", Number);

       }

-      if (HasLabel) {

+      if (hasLabel) {

         output.WriteEnum(4, "label", (int) Label, Label.ToString());

       }

-      if (HasType) {

+      if (hasType) {

         output.WriteEnum(5, "type", (int) Type, Type.ToString());

       }

-      if (HasTypeName) {

+      if (hasTypeName) {

         output.WriteString(6, "type_name", TypeName);

       }

-      if (HasDefaultValue) {

+      if (hasDefaultValue) {

         output.WriteString(7, "default_value", DefaultValue);

       }

-      if (HasOptions) {

+      if (hasOptions) {

         output.WriteMessage(8, "options", Options);

       }

       UnknownFields.WriteTo(output);

@@ -2224,28 +2224,28 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasName) {

+        if (hasName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Name);

         }

-        if (HasNumber) {

+        if (hasNumber) {

           size += pb::CodedOutputStream.ComputeInt32Size(3, Number);

         }

-        if (HasLabel) {

+        if (hasLabel) {

           size += pb::CodedOutputStream.ComputeEnumSize(4, (int) Label);

         }

-        if (HasType) {

+        if (hasType) {

           size += pb::CodedOutputStream.ComputeEnumSize(5, (int) Type);

         }

-        if (HasTypeName) {

+        if (hasTypeName) {

           size += pb::CodedOutputStream.ComputeStringSize(6, TypeName);

         }

-        if (HasExtendee) {

+        if (hasExtendee) {

           size += pb::CodedOutputStream.ComputeStringSize(2, Extendee);

         }

-        if (HasDefaultValue) {

+        if (hasDefaultValue) {

           size += pb::CodedOutputStream.ComputeStringSize(7, DefaultValue);

         }

-        if (HasOptions) {

+        if (hasOptions) {

           size += pb::CodedOutputStream.ComputeMessageSize(8, Options);

         }

         size += UnknownFields.SerializedSize;

@@ -2443,7 +2443,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             }

             case 66: {

               global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder();

-              if (HasOptions) {

+              if (result.hasOptions) {

                 subBuilder.MergeFrom(Options);

               }

               input.ReadMessage(subBuilder, extensionRegistry);

@@ -2461,7 +2461,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasName {

-        get { return result.HasName; }

+        get { return result.hasName; }

       }

       public string Name {

         get { return result.Name; }

@@ -2480,7 +2480,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasNumber {

-        get { return result.HasNumber; }

+        get { return result.hasNumber; }

       }

       public int Number {

         get { return result.Number; }

@@ -2498,7 +2498,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasLabel {

-       get { return result.HasLabel; }

+       get { return result.hasLabel; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label {

         get { return result.Label; }

@@ -2516,7 +2516,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasType {

-       get { return result.HasType; }

+       get { return result.hasType; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type {

         get { return result.Type; }

@@ -2534,7 +2534,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasTypeName {

-        get { return result.HasTypeName; }

+        get { return result.hasTypeName; }

       }

       public string TypeName {

         get { return result.TypeName; }

@@ -2553,7 +2553,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasExtendee {

-        get { return result.HasExtendee; }

+        get { return result.hasExtendee; }

       }

       public string Extendee {

         get { return result.Extendee; }

@@ -2572,7 +2572,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasDefaultValue {

-        get { return result.HasDefaultValue; }

+        get { return result.hasDefaultValue; }

       }

       public string DefaultValue {

         get { return result.DefaultValue; }

@@ -2591,7 +2591,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptions {

-       get { return result.HasOptions; }

+       get { return result.hasOptions; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions Options {

         get { return result.Options; }

@@ -2611,7 +2611,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions value) {

         pb::ThrowHelper.ThrowIfNull(value, "value");

-        if (result.HasOptions &&

+        if (result.hasOptions &&

             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance) {

             result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();

         } else {

@@ -2702,13 +2702,13 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasName) {

+      if (hasName) {

         output.WriteString(1, "name", Name);

       }

       if (value_.Count > 0) {

         output.WriteArray(pbd::FieldType.Message, 2, "value", value_);

       }

-      if (HasOptions) {

+      if (hasOptions) {

         output.WriteMessage(3, "options", Options);

       }

       UnknownFields.WriteTo(output);

@@ -2721,13 +2721,13 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasName) {

+        if (hasName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Name);

         }

         foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto element in ValueList) {

           size += pb::CodedOutputStream.ComputeMessageSize(2, element);

         }

-        if (HasOptions) {

+        if (hasOptions) {

           size += pb::CodedOutputStream.ComputeMessageSize(3, Options);

         }

         size += UnknownFields.SerializedSize;

@@ -2875,7 +2875,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             }

             case 26: {

               global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder();

-              if (HasOptions) {

+              if (result.hasOptions) {

                 subBuilder.MergeFrom(Options);

               }

               input.ReadMessage(subBuilder, extensionRegistry);

@@ -2893,7 +2893,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasName {

-        get { return result.HasName; }

+        get { return result.hasName; }

       }

       public string Name {

         get { return result.Name; }

@@ -2950,7 +2950,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptions {

-       get { return result.HasOptions; }

+       get { return result.hasOptions; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions Options {

         get { return result.Options; }

@@ -2970,7 +2970,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions value) {

         pb::ThrowHelper.ThrowIfNull(value, "value");

-        if (result.HasOptions &&

+        if (result.hasOptions &&

             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance) {

             result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();

         } else {

@@ -3056,13 +3056,13 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasName) {

+      if (hasName) {

         output.WriteString(1, "name", Name);

       }

-      if (HasNumber) {

+      if (hasNumber) {

         output.WriteInt32(2, "number", Number);

       }

-      if (HasOptions) {

+      if (hasOptions) {

         output.WriteMessage(3, "options", Options);

       }

       UnknownFields.WriteTo(output);

@@ -3075,13 +3075,13 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasName) {

+        if (hasName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Name);

         }

-        if (HasNumber) {

+        if (hasNumber) {

           size += pb::CodedOutputStream.ComputeInt32Size(2, Number);

         }

-        if (HasOptions) {

+        if (hasOptions) {

           size += pb::CodedOutputStream.ComputeMessageSize(3, Options);

         }

         size += UnknownFields.SerializedSize;

@@ -3228,7 +3228,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             }

             case 26: {

               global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder();

-              if (HasOptions) {

+              if (result.hasOptions) {

                 subBuilder.MergeFrom(Options);

               }

               input.ReadMessage(subBuilder, extensionRegistry);

@@ -3246,7 +3246,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasName {

-        get { return result.HasName; }

+        get { return result.hasName; }

       }

       public string Name {

         get { return result.Name; }

@@ -3265,7 +3265,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasNumber {

-        get { return result.HasNumber; }

+        get { return result.hasNumber; }

       }

       public int Number {

         get { return result.Number; }

@@ -3283,7 +3283,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptions {

-       get { return result.HasOptions; }

+       get { return result.hasOptions; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions Options {

         get { return result.Options; }

@@ -3303,7 +3303,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions value) {

         pb::ThrowHelper.ThrowIfNull(value, "value");

-        if (result.HasOptions &&

+        if (result.hasOptions &&

             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance) {

             result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();

         } else {

@@ -3394,13 +3394,13 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasName) {

+      if (hasName) {

         output.WriteString(1, "name", Name);

       }

       if (method_.Count > 0) {

         output.WriteArray(pbd::FieldType.Message, 2, "method", method_);

       }

-      if (HasOptions) {

+      if (hasOptions) {

         output.WriteMessage(3, "options", Options);

       }

       UnknownFields.WriteTo(output);

@@ -3413,13 +3413,13 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasName) {

+        if (hasName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Name);

         }

         foreach (global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto element in MethodList) {

           size += pb::CodedOutputStream.ComputeMessageSize(2, element);

         }

-        if (HasOptions) {

+        if (hasOptions) {

           size += pb::CodedOutputStream.ComputeMessageSize(3, Options);

         }

         size += UnknownFields.SerializedSize;

@@ -3567,7 +3567,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             }

             case 26: {

               global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder();

-              if (HasOptions) {

+              if (result.hasOptions) {

                 subBuilder.MergeFrom(Options);

               }

               input.ReadMessage(subBuilder, extensionRegistry);

@@ -3585,7 +3585,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasName {

-        get { return result.HasName; }

+        get { return result.hasName; }

       }

       public string Name {

         get { return result.Name; }

@@ -3642,7 +3642,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptions {

-       get { return result.HasOptions; }

+       get { return result.hasOptions; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions Options {

         get { return result.Options; }

@@ -3662,7 +3662,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions value) {

         pb::ThrowHelper.ThrowIfNull(value, "value");

-        if (result.HasOptions &&

+        if (result.hasOptions &&

             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance) {

             result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();

         } else {

@@ -3758,16 +3758,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     

     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

-      if (HasName) {

+      if (hasName) {

         output.WriteString(1, "name", Name);

       }

-      if (HasInputType) {

+      if (hasInputType) {

         output.WriteString(2, "input_type", InputType);

       }

-      if (HasOutputType) {

+      if (hasOutputType) {

         output.WriteString(3, "output_type", OutputType);

       }

-      if (HasOptions) {

+      if (hasOptions) {

         output.WriteMessage(4, "options", Options);

       }

       UnknownFields.WriteTo(output);

@@ -3780,16 +3780,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasName) {

+        if (hasName) {

           size += pb::CodedOutputStream.ComputeStringSize(1, Name);

         }

-        if (HasInputType) {

+        if (hasInputType) {

           size += pb::CodedOutputStream.ComputeStringSize(2, InputType);

         }

-        if (HasOutputType) {

+        if (hasOutputType) {

           size += pb::CodedOutputStream.ComputeStringSize(3, OutputType);

         }

-        if (HasOptions) {

+        if (hasOptions) {

           size += pb::CodedOutputStream.ComputeMessageSize(4, Options);

         }

         size += UnknownFields.SerializedSize;

@@ -3943,7 +3943,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             }

             case 34: {

               global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder();

-              if (HasOptions) {

+              if (result.hasOptions) {

                 subBuilder.MergeFrom(Options);

               }

               input.ReadMessage(subBuilder, extensionRegistry);

@@ -3961,7 +3961,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasName {

-        get { return result.HasName; }

+        get { return result.hasName; }

       }

       public string Name {

         get { return result.Name; }

@@ -3980,7 +3980,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasInputType {

-        get { return result.HasInputType; }

+        get { return result.hasInputType; }

       }

       public string InputType {

         get { return result.InputType; }

@@ -3999,7 +3999,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOutputType {

-        get { return result.HasOutputType; }

+        get { return result.hasOutputType; }

       }

       public string OutputType {

         get { return result.OutputType; }

@@ -4018,7 +4018,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptions {

-       get { return result.HasOptions; }

+       get { return result.hasOptions; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions Options {

         get { return result.Options; }

@@ -4038,7 +4038,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions value) {

         pb::ThrowHelper.ThrowIfNull(value, "value");

-        if (result.HasOptions &&

+        if (result.hasOptions &&

             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance) {

             result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();

         } else {

@@ -4194,25 +4194,25 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

       pb::ExtendableMessage<FileOptions, FileOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);

-      if (HasJavaPackage) {

+      if (hasJavaPackage) {

         output.WriteString(1, "java_package", JavaPackage);

       }

-      if (HasJavaOuterClassname) {

+      if (hasJavaOuterClassname) {

         output.WriteString(8, "java_outer_classname", JavaOuterClassname);

       }

-      if (HasOptimizeFor) {

+      if (hasOptimizeFor) {

         output.WriteEnum(9, "optimize_for", (int) OptimizeFor, OptimizeFor.ToString());

       }

-      if (HasJavaMultipleFiles) {

+      if (hasJavaMultipleFiles) {

         output.WriteBool(10, "java_multiple_files", JavaMultipleFiles);

       }

-      if (HasCcGenericServices) {

+      if (hasCcGenericServices) {

         output.WriteBool(16, "cc_generic_services", CcGenericServices);

       }

-      if (HasJavaGenericServices) {

+      if (hasJavaGenericServices) {

         output.WriteBool(17, "java_generic_services", JavaGenericServices);

       }

-      if (HasPyGenericServices) {

+      if (hasPyGenericServices) {

         output.WriteBool(18, "py_generic_services", PyGenericServices);

       }

       if (uninterpretedOption_.Count > 0) {

@@ -4229,25 +4229,25 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasJavaPackage) {

+        if (hasJavaPackage) {

           size += pb::CodedOutputStream.ComputeStringSize(1, JavaPackage);

         }

-        if (HasJavaOuterClassname) {

+        if (hasJavaOuterClassname) {

           size += pb::CodedOutputStream.ComputeStringSize(8, JavaOuterClassname);

         }

-        if (HasJavaMultipleFiles) {

+        if (hasJavaMultipleFiles) {

           size += pb::CodedOutputStream.ComputeBoolSize(10, JavaMultipleFiles);

         }

-        if (HasOptimizeFor) {

+        if (hasOptimizeFor) {

           size += pb::CodedOutputStream.ComputeEnumSize(9, (int) OptimizeFor);

         }

-        if (HasCcGenericServices) {

+        if (hasCcGenericServices) {

           size += pb::CodedOutputStream.ComputeBoolSize(16, CcGenericServices);

         }

-        if (HasJavaGenericServices) {

+        if (hasJavaGenericServices) {

           size += pb::CodedOutputStream.ComputeBoolSize(17, JavaGenericServices);

         }

-        if (HasPyGenericServices) {

+        if (hasPyGenericServices) {

           size += pb::CodedOutputStream.ComputeBoolSize(18, PyGenericServices);

         }

         foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {

@@ -4456,7 +4456,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasJavaPackage {

-        get { return result.HasJavaPackage; }

+        get { return result.hasJavaPackage; }

       }

       public string JavaPackage {

         get { return result.JavaPackage; }

@@ -4475,7 +4475,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasJavaOuterClassname {

-        get { return result.HasJavaOuterClassname; }

+        get { return result.hasJavaOuterClassname; }

       }

       public string JavaOuterClassname {

         get { return result.JavaOuterClassname; }

@@ -4494,7 +4494,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasJavaMultipleFiles {

-        get { return result.HasJavaMultipleFiles; }

+        get { return result.hasJavaMultipleFiles; }

       }

       public bool JavaMultipleFiles {

         get { return result.JavaMultipleFiles; }

@@ -4512,7 +4512,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasOptimizeFor {

-       get { return result.HasOptimizeFor; }

+       get { return result.hasOptimizeFor; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor {

         get { return result.OptimizeFor; }

@@ -4530,7 +4530,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasCcGenericServices {

-        get { return result.HasCcGenericServices; }

+        get { return result.hasCcGenericServices; }

       }

       public bool CcGenericServices {

         get { return result.CcGenericServices; }

@@ -4548,7 +4548,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasJavaGenericServices {

-        get { return result.HasJavaGenericServices; }

+        get { return result.hasJavaGenericServices; }

       }

       public bool JavaGenericServices {

         get { return result.JavaGenericServices; }

@@ -4566,7 +4566,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasPyGenericServices {

-        get { return result.HasPyGenericServices; }

+        get { return result.hasPyGenericServices; }

       }

       public bool PyGenericServices {

         get { return result.PyGenericServices; }

@@ -4696,10 +4696,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

       pb::ExtendableMessage<MessageOptions, MessageOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);

-      if (HasMessageSetWireFormat) {

+      if (hasMessageSetWireFormat) {

         output.WriteBool(1, "message_set_wire_format", MessageSetWireFormat);

       }

-      if (HasNoStandardDescriptorAccessor) {

+      if (hasNoStandardDescriptorAccessor) {

         output.WriteBool(2, "no_standard_descriptor_accessor", NoStandardDescriptorAccessor);

       }

       if (uninterpretedOption_.Count > 0) {

@@ -4716,10 +4716,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasMessageSetWireFormat) {

+        if (hasMessageSetWireFormat) {

           size += pb::CodedOutputStream.ComputeBoolSize(1, MessageSetWireFormat);

         }

-        if (HasNoStandardDescriptorAccessor) {

+        if (hasNoStandardDescriptorAccessor) {

           size += pb::CodedOutputStream.ComputeBoolSize(2, NoStandardDescriptorAccessor);

         }

         foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {

@@ -4885,7 +4885,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasMessageSetWireFormat {

-        get { return result.HasMessageSetWireFormat; }

+        get { return result.hasMessageSetWireFormat; }

       }

       public bool MessageSetWireFormat {

         get { return result.MessageSetWireFormat; }

@@ -4903,7 +4903,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasNoStandardDescriptorAccessor {

-        get { return result.HasNoStandardDescriptorAccessor; }

+        get { return result.hasNoStandardDescriptorAccessor; }

       }

       public bool NoStandardDescriptorAccessor {

         get { return result.NoStandardDescriptorAccessor; }

@@ -5069,16 +5069,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     public override void WriteTo(pb::ICodedOutputStream output) {

       int size = SerializedSize;

       pb::ExtendableMessage<FieldOptions, FieldOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);

-      if (HasCtype) {

+      if (hasCtype) {

         output.WriteEnum(1, "ctype", (int) Ctype, Ctype.ToString());

       }

-      if (HasPacked) {

+      if (hasPacked) {

         output.WriteBool(2, "packed", Packed);

       }

-      if (HasDeprecated) {

+      if (hasDeprecated) {

         output.WriteBool(3, "deprecated", Deprecated);

       }

-      if (HasExperimentalMapKey) {

+      if (hasExperimentalMapKey) {

         output.WriteString(9, "experimental_map_key", ExperimentalMapKey);

       }

       if (uninterpretedOption_.Count > 0) {

@@ -5095,16 +5095,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;

         

         size = 0;

-        if (HasCtype) {

+        if (hasCtype) {

           size += pb::CodedOutputStream.ComputeEnumSize(1, (int) Ctype);

         }

-        if (HasPacked) {

+        if (hasPacked) {

           size += pb::CodedOutputStream.ComputeBoolSize(2, Packed);

         }

-        if (HasDeprecated) {

+        if (hasDeprecated) {

           size += pb::CodedOutputStream.ComputeBoolSize(3, Deprecated);

         }

-        if (HasExperimentalMapKey) {

+        if (hasExperimentalMapKey) {

           size += pb::CodedOutputStream.ComputeStringSize(9, ExperimentalMapKey);

         }

         foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {

@@ -5292,7 +5292,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       

       

       public bool HasCtype {

-       get { return result.HasCtype; }

+       get { return result.hasCtype; }

       }

       public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype {

         get { return result.Ctype; }

@@ -5310,7 +5310,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasPacked {

-        get { return result.HasPacked; }

+        get { return result.hasPacked; }

       }

       public bool Packed {

         get { return result.Packed; }

@@ -5328,7 +5328,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasDeprecated {

-        get { return result.HasDeprecated; }

+        get { return result.hasDeprecated; }

       }

       public bool Deprecated {

         get { return result.Deprecated; }

@@ -5346,7 +5346,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasExperimentalMapKey {

-        get { return result.HasExperimentalMapKey; }

+        get { return result.hasExperimentalMapKey; }

       }

       public string ExperimentalMapKey {

         get { return result.ExperimentalMapKey; }

@@ -6512,10 +6512,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         

         public override void WriteTo(pb::ICodedOutputStream output) {

           int size = SerializedSize;

-          if (HasNamePart_) {

+          if (hasNamePart_) {

             output.WriteString(1, "name_part", NamePart_);

           }

-          if (HasIsExtension) {

+          if (hasIsExtension) {

             output.WriteBool(2, "is_extension", IsExtension);

           }

           UnknownFields.WriteTo(output);

@@ -6528,10 +6528,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             if (size != -1) return size;

             

             size = 0;

-            if (HasNamePart_) {

+            if (hasNamePart_) {

               size += pb::CodedOutputStream.ComputeStringSize(1, NamePart_);

             }

-            if (HasIsExtension) {

+            if (hasIsExtension) {

               size += pb::CodedOutputStream.ComputeBoolSize(2, IsExtension);

             }

             size += UnknownFields.SerializedSize;

@@ -6684,7 +6684,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           

           

           public bool HasNamePart_ {

-            get { return result.HasNamePart_; }

+            get { return result.hasNamePart_; }

           }

           public string NamePart_ {

             get { return result.NamePart_; }

@@ -6703,7 +6703,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           }

           

           public bool HasIsExtension {

-            get { return result.HasIsExtension; }

+            get { return result.hasIsExtension; }

           }

           public bool IsExtension {

             get { return result.IsExtension; }

@@ -6805,19 +6805,19 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       if (name_.Count > 0) {

         output.WriteArray(pbd::FieldType.Message, 2, "name", name_);

       }

-      if (HasIdentifierValue) {

+      if (hasIdentifierValue) {

         output.WriteString(3, "identifier_value", IdentifierValue);

       }

-      if (HasPositiveIntValue) {

+      if (hasPositiveIntValue) {

         output.WriteUInt64(4, "positive_int_value", PositiveIntValue);

       }

-      if (HasNegativeIntValue) {

+      if (hasNegativeIntValue) {

         output.WriteInt64(5, "negative_int_value", NegativeIntValue);

       }

-      if (HasDoubleValue) {

+      if (hasDoubleValue) {

         output.WriteDouble(6, "double_value", DoubleValue);

       }

-      if (HasStringValue) {

+      if (hasStringValue) {

         output.WriteBytes(7, "string_value", StringValue);

       }

       UnknownFields.WriteTo(output);

@@ -6833,19 +6833,19 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart element in NameList) {

           size += pb::CodedOutputStream.ComputeMessageSize(2, element);

         }

-        if (HasIdentifierValue) {

+        if (hasIdentifierValue) {

           size += pb::CodedOutputStream.ComputeStringSize(3, IdentifierValue);

         }

-        if (HasPositiveIntValue) {

+        if (hasPositiveIntValue) {

           size += pb::CodedOutputStream.ComputeUInt64Size(4, PositiveIntValue);

         }

-        if (HasNegativeIntValue) {

+        if (hasNegativeIntValue) {

           size += pb::CodedOutputStream.ComputeInt64Size(5, NegativeIntValue);

         }

-        if (HasDoubleValue) {

+        if (hasDoubleValue) {

           size += pb::CodedOutputStream.ComputeDoubleSize(6, DoubleValue);

         }

-        if (HasStringValue) {

+        if (hasStringValue) {

           size += pb::CodedOutputStream.ComputeBytesSize(7, StringValue);

         }

         size += UnknownFields.SerializedSize;

@@ -7065,7 +7065,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasIdentifierValue {

-        get { return result.HasIdentifierValue; }

+        get { return result.hasIdentifierValue; }

       }

       public string IdentifierValue {

         get { return result.IdentifierValue; }

@@ -7084,7 +7084,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasPositiveIntValue {

-        get { return result.HasPositiveIntValue; }

+        get { return result.hasPositiveIntValue; }

       }

       [global::System.CLSCompliant(false)]

       public ulong PositiveIntValue {

@@ -7104,7 +7104,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasNegativeIntValue {

-        get { return result.HasNegativeIntValue; }

+        get { return result.hasNegativeIntValue; }

       }

       public long NegativeIntValue {

         get { return result.NegativeIntValue; }

@@ -7122,7 +7122,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasDoubleValue {

-        get { return result.HasDoubleValue; }

+        get { return result.hasDoubleValue; }

       }

       public double DoubleValue {

         get { return result.DoubleValue; }

@@ -7140,7 +7140,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }

       

       public bool HasStringValue {

-        get { return result.HasStringValue; }

+        get { return result.hasStringValue; }

       }

       public pb::ByteString StringValue {

         get { return result.StringValue; }

diff --git a/src/ProtocolBuffers/ICodedOutputStream.cs b/src/ProtocolBuffers/ICodedOutputStream.cs
index f008e798..db7ea6e1 100644
--- a/src/ProtocolBuffers/ICodedOutputStream.cs
+++ b/src/ProtocolBuffers/ICodedOutputStream.cs
@@ -79,7 +79,8 @@ namespace Google.ProtocolBuffers
         void WriteMessageSetExtension(int fieldNumber, string fieldName, ByteString value);

         void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list);

         void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list);

-        void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, int calculatedSize, System.Collections.IEnumerable list);

+        void WriteArray<T>(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable<T> list);

+        void WritePackedArray<T>(FieldType fieldType, int fieldNumber, string fieldName, int calculatedSize, System.Collections.Generic.IEnumerable<T> list);

         void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value);

         void Flush();

     }