Coded*Stream streamlining.

Remove ICodedInputStream and ICodedOutputStream, and rewrite CodedInputStream and CodedOutputStream to be specific to the binary format. If we want to support text-based formats, that can be a whole different serialization mechanism.

6 files changed, 432 insertions, 800 deletions

diff --git a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
index aa2da330..450662a6 100644
--- a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
@@ -336,13 +336,11 @@ namespace Google.Protobuf
 

             CodedInputStream input = CodedInputStream.CreateInstance(ms);

             uint testtag;

-            string ignore;

-            Assert.IsTrue(input.ReadTag(out testtag, out ignore));

+            Assert.IsTrue(input.ReadTag(out testtag));

             Assert.AreEqual(tag, testtag);

 

-            ByteString bytes = null;

             // TODO(jonskeet): Should this be ArgumentNullException instead?

-            Assert.Throws<InvalidProtocolBufferException>(() => input.ReadBytes(ref bytes));

+            Assert.Throws<InvalidProtocolBufferException>(() => input.ReadBytes());

         }

 

         private static TestRecursiveMessage MakeRecursiveMessage(int depth)

@@ -435,13 +433,10 @@ namespace Google.Protobuf
 

             CodedInputStream input = CodedInputStream.CreateInstance(ms);

 

-            uint testtag;

-            string ignored;

-

-            Assert.IsTrue(input.ReadTag(out testtag, out ignored));

-            Assert.AreEqual(tag, testtag);

-            string text = null;

-            input.ReadString(ref text);

+            uint actualTag;

+            Assert.IsTrue(input.ReadTag(out actualTag));

+            Assert.AreEqual(tag, actualTag);

+            string text = input.ReadString();

             Assert.AreEqual('\ufffd', text[0]);

         }

 

@@ -473,11 +468,8 @@ namespace Google.Protobuf
         {

             byte[] bytes = new byte[10] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

-            int val = 0;

-

-            Assert.IsTrue(input.ReadEnum(ref val));

+            Assert.AreEqual((int)TestNegEnum.Value, input.ReadEnum());

             Assert.IsTrue(input.IsAtEnd);

-            Assert.AreEqual((int) TestNegEnum.Value, val);

         }

 

         [Test]

@@ -487,17 +479,16 @@ namespace Google.Protobuf
             int msgSize = 1 + 1 + arraySize;

             byte[] bytes = new byte[msgSize];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WritePackedInt32Array(8, "", new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });

+            output.WritePackedInt32Array(8, new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });

 

             Assert.AreEqual(0, output.SpaceLeft);

 

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

             uint tag;

-            string name;

-            Assert.IsTrue(input.ReadTag(out tag, out name));

+            Assert.IsTrue(input.ReadTag(out tag));

 

             List<TestNegEnum> values = new List<TestNegEnum>();

-            input.ReadEnumArray(tag, name, values);

+            input.ReadEnumArray(tag, values);

 

             Assert.AreEqual(6, values.Count);

             Assert.AreEqual(TestNegEnum.None, values[0]);

@@ -512,17 +503,16 @@ namespace Google.Protobuf
             int msgSize = arraySize;

             byte[] bytes = new byte[msgSize];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteInt32Array(8, "", new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });

+            output.WriteInt32Array(8, new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });

 

             Assert.AreEqual(0, output.SpaceLeft);

 

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

             uint tag;

-            string name;

-            Assert.IsTrue(input.ReadTag(out tag, out name));

+            Assert.IsTrue(input.ReadTag(out tag));

 

             List<TestNegEnum> values = new List<TestNegEnum>();

-            input.ReadEnumArray(tag, name, values);

+            input.ReadEnumArray(tag, values);

 

             Assert.AreEqual(6, values.Count);

             Assert.AreEqual(TestNegEnum.None, values[0]);

@@ -537,26 +527,21 @@ namespace Google.Protobuf
             using (var ms = new MemoryStream())

             {

                 CodedOutputStream output = CodedOutputStream.CreateInstance(ms);

-                output.WriteField(FieldType.Bytes, 1, "bytes", ByteString.CopyFrom(new byte[100]));

-                output.WriteField(FieldType.Bytes, 2, "bytes", ByteString.CopyFrom(new byte[100]));

+                output.WriteBytes(1, ByteString.CopyFrom(new byte[100]));

+                output.WriteBytes(2, ByteString.CopyFrom(new byte[100]));

                 output.Flush();

 

                 ms.Position = 0;

                 CodedInputStream input = CodedInputStream.CreateInstance(ms, new byte[ms.Length / 2]);

 

                 uint tag;

-                string ignore;

-                ByteString value;

-

-                Assert.IsTrue(input.ReadTag(out tag, out ignore));

+                Assert.IsTrue(input.ReadTag(out tag));

                 Assert.AreEqual(1, WireFormat.GetTagFieldNumber(tag));

-                value = ByteString.Empty;

-                Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100);

+                Assert.AreEqual(100, input.ReadBytes().Length);

 

-                Assert.IsTrue(input.ReadTag(out tag, out ignore));

+                Assert.IsTrue(input.ReadTag(out tag));

                 Assert.AreEqual(2, WireFormat.GetTagFieldNumber(tag));

-                value = ByteString.Empty;

-                Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100);

+                Assert.AreEqual(100, input.ReadBytes().Length);

             }

         }

     }

diff --git a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
index fcbb7f8d..682c005a 100644
--- a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
@@ -316,7 +316,7 @@ namespace Google.Protobuf
 

             byte[] bytes = new byte[11];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteEnum(8, "", (int) TestNegEnum.Value);

+            output.WriteEnum(8, (int) TestNegEnum.Value);

 

             Assert.AreEqual(0, output.SpaceLeft);

             //fyi, 0x40 == 0x08 << 3 + 0, field num + wire format shift

@@ -330,18 +330,17 @@ namespace Google.Protobuf
             int msgSize = 1 + 1 + arraySize;

             byte[] bytes = new byte[msgSize];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WritePackedEnumArray(8, "", new RepeatedField<TestNegEnum> {

+            output.WritePackedEnumArray(8, new RepeatedField<TestNegEnum> {

                 0, (TestNegEnum) (-1), TestNegEnum.Value, (TestNegEnum) (-3), (TestNegEnum) (-4), (TestNegEnum) (-5) });

 

             Assert.AreEqual(0, output.SpaceLeft);

 

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

             uint tag;

-            string name;

-            Assert.IsTrue(input.ReadTag(out tag, out name));

+            Assert.IsTrue(input.ReadTag(out tag));

 

             List<int> values = new List<int>();

-            input.ReadInt32Array(tag, name, values);

+            input.ReadInt32Array(tag, values);

 

             Assert.AreEqual(6, values.Count);

             for (int i = 0; i > -6; i--)

@@ -355,17 +354,16 @@ namespace Google.Protobuf
             int msgSize = arraySize;

             byte[] bytes = new byte[msgSize];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

-            output.WriteEnumArray(8, "", new RepeatedField<TestNegEnum> {

+            output.WriteEnumArray(8, new RepeatedField<TestNegEnum> {

                 0, (TestNegEnum) (-1), TestNegEnum.Value, (TestNegEnum) (-3), (TestNegEnum) (-4), (TestNegEnum) (-5) });

             Assert.AreEqual(0, output.SpaceLeft);

 

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

             uint tag;

-            string name;

-            Assert.IsTrue(input.ReadTag(out tag, out name));

+            Assert.IsTrue(input.ReadTag(out tag));

 

             List<int> values = new List<int>();

-            input.ReadInt32Array(tag, name, values);

+            input.ReadInt32Array(tag, values);

 

             Assert.AreEqual(6, values.Count);

             for (int i = 0; i > -6; i--)

@@ -425,16 +423,14 @@ namespace Google.Protobuf
             {

                 CodedInputStream cin = CodedInputStream.CreateInstance(new MemoryStream(bytes), new byte[50]);

                 uint tag;

-                int intValue = 0;

-                string ignore;

                 Assert.AreEqual(0, cin.Position);

                 // Field 1:

-                Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 1);

+                Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 1);

                 Assert.AreEqual(1, cin.Position);

-                Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500);

+                Assert.AreEqual(500, cin.ReadInt32());

                 Assert.AreEqual(3, cin.Position);

                 //Field 2:

-                Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 2);

+                Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 2);

                 Assert.AreEqual(4, cin.Position);

                 uint childlen = cin.ReadRawVarint32();

                 Assert.AreEqual(120u, childlen);

@@ -444,30 +440,31 @@ namespace Google.Protobuf
                 // Now we are reading child message

                 {

                     // Field 11: numeric value: 500

-                    Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 11);

+                    Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 11);

                     Assert.AreEqual(6, cin.Position);

-                    Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500);

+                    Assert.AreEqual(500, cin.ReadInt32());

                     Assert.AreEqual(8, cin.Position);

                     //Field 12: length delimited 120 bytes

-                    Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 12);

+                    Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 12);

                     Assert.AreEqual(9, cin.Position);

-                    ByteString bstr = null;

-                    Assert.IsTrue(cin.ReadBytes(ref bstr) && bstr.Length == 110 && bstr.ToByteArray()[109] == 109);

+                    ByteString bstr = cin.ReadBytes();

+                    Assert.AreEqual(110, bstr.Length);

+                    Assert.AreEqual((byte) 109, bstr[109]);

                     Assert.AreEqual(120, cin.Position);

                     // Field 13: fixed numeric value: 501

-                    Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 13);

+                    Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 13);

                     // ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit

                     Assert.AreEqual(121, cin.Position);

-                    Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501);

+                    Assert.AreEqual(501, cin.ReadSFixed32());

                     Assert.AreEqual(125, cin.Position);

                     Assert.IsTrue(cin.IsAtEnd);

                 }

                 cin.PopLimit(oldlimit);

                 Assert.AreEqual(125, cin.Position);

                 // Field 3: fixed numeric value: 501

-                Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 3);

+                Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 3);

                 Assert.AreEqual(126, cin.Position);

-                Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501);

+                Assert.AreEqual(501, cin.ReadSFixed32());

                 Assert.AreEqual(130, cin.Position);

                 Assert.IsTrue(cin.IsAtEnd);

             }

diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs
index 4b62794a..1bd4e22b 100644
--- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs
+++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs
@@ -107,10 +107,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (D != 0) {
-        output.WriteInt32(1, fieldNames[0], D);
+        output.WriteInt32(1, D);
       }
     }
 
@@ -130,16 +129,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -149,7 +141,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref d_);
+            d_ = input.ReadInt32();
             break;
           }
         }
diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs
index 2f7f8699..32123d53 100644
--- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs
+++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs
@@ -92,10 +92,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (E != 0) {
-        output.WriteInt32(1, fieldNames[0], E);
+        output.WriteInt32(1, E);
       }
     }
 
@@ -115,16 +114,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -134,7 +126,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref e_);
+            e_ = input.ReadInt32();
             break;
           }
         }
diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
index 14ca78a4..d8c8995b 100644
--- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
+++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
@@ -153,13 +153,12 @@ namespace UnitTest.Issues.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) {
-        output.WriteEnum(1, fieldNames[1], (int) Value);
+        output.WriteEnum(1, (int) Value);
       }
-      output.WriteEnumArray(2, fieldNames[2], values_);
-      output.WritePackedEnumArray(3, fieldNames[0], packedValues_);
+      output.WriteEnumArray(2, values_);
+      output.WritePackedEnumArray(3, packedValues_);
     }
 
     public int CalculateSize() {
@@ -201,16 +200,9 @@ namespace UnitTest.Issues.TestProtos {
       packedValues_.Add(other.packedValues_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -220,18 +212,17 @@ namespace UnitTest.Issues.TestProtos {
             }
             break;
           case 8: {
-            int tmp = 0;
-            input.ReadEnum(ref tmp);
-            value_ = (global::UnitTest.Issues.TestProtos.NegativeEnum) tmp;break;
+            value_ = (global::UnitTest.Issues.TestProtos.NegativeEnum) input.ReadEnum();
+            break;
           }
           case 18:
           case 16: {
-            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(tag, fieldName, values_);
+            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(tag, values_);
             break;
           }
           case 26:
           case 24: {
-            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(tag, fieldName, packedValues_);
+            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(tag, packedValues_);
             break;
           }
         }
@@ -278,8 +269,7 @@ namespace UnitTest.Issues.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -292,16 +282,9 @@ namespace UnitTest.Issues.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -412,20 +395,19 @@ namespace UnitTest.Issues.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (PrimitiveValue != 0) {
-        output.WriteInt32(1, fieldNames[5], PrimitiveValue);
+        output.WriteInt32(1, PrimitiveValue);
       }
-      output.WritePackedInt32Array(2, fieldNames[4], primitiveArray_);
+      output.WritePackedInt32Array(2, primitiveArray_);
       if (messageValue_ != null) {
-        output.WriteMessage(3, fieldNames[3], MessageValue);
+        output.WriteMessage(3, MessageValue);
       }
-      output.WriteMessageArray(4, fieldNames[2], messageArray_);
+      output.WriteMessageArray(4, messageArray_);
       if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) {
-        output.WriteEnum(5, fieldNames[1], (int) EnumValue);
+        output.WriteEnum(5, (int) EnumValue);
       }
-      output.WritePackedEnumArray(6, fieldNames[0], enumArray_);
+      output.WritePackedEnumArray(6, enumArray_);
     }
 
     public int CalculateSize() {
@@ -486,16 +468,9 @@ namespace UnitTest.Issues.TestProtos {
       enumArray_.Add(other.enumArray_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -505,12 +480,12 @@ namespace UnitTest.Issues.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref primitiveValue_);
+            primitiveValue_ = input.ReadInt32();
             break;
           }
           case 18:
           case 16: {
-            input.ReadInt32Array(tag, fieldName, primitiveArray_);
+            input.ReadInt32Array(tag, primitiveArray_);
             break;
           }
           case 26: {
@@ -521,17 +496,16 @@ namespace UnitTest.Issues.TestProtos {
             break;
           }
           case 34: {
-            input.ReadMessageArray(tag, fieldName, messageArray_, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser);
+            input.ReadMessageArray(tag, messageArray_, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser);
             break;
           }
           case 40: {
-            int tmp = 0;
-            input.ReadEnum(ref tmp);
-            enumValue_ = (global::UnitTest.Issues.TestProtos.DeprecatedEnum) tmp;break;
+            enumValue_ = (global::UnitTest.Issues.TestProtos.DeprecatedEnum) input.ReadEnum();
+            break;
           }
           case 50:
           case 48: {
-            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(tag, fieldName, enumArray_);
+            input.ReadEnumArray<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(tag, enumArray_);
             break;
           }
         }
@@ -588,10 +562,9 @@ namespace UnitTest.Issues.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Item != 0) {
-        output.WriteInt32(1, fieldNames[0], Item);
+        output.WriteInt32(1, Item);
       }
     }
 
@@ -611,16 +584,9 @@ namespace UnitTest.Issues.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -630,7 +596,7 @@ namespace UnitTest.Issues.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref item_);
+            item_ = input.ReadInt32();
             break;
           }
         }
diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
index 3e5bb8b6..4c4dabab 100644
--- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
+++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
@@ -888,107 +888,106 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (SingleInt32 != 0) {
-        output.WriteInt32(1, fieldNames[36], SingleInt32);
+        output.WriteInt32(1, SingleInt32);
       }
       if (SingleInt64 != 0L) {
-        output.WriteInt64(2, fieldNames[37], SingleInt64);
+        output.WriteInt64(2, SingleInt64);
       }
       if (SingleUint32 != 0) {
-        output.WriteUInt32(3, fieldNames[46], SingleUint32);
+        output.WriteUInt32(3, SingleUint32);
       }
       if (SingleUint64 != 0UL) {
-        output.WriteUInt64(4, fieldNames[47], SingleUint64);
+        output.WriteUInt64(4, SingleUint64);
       }
       if (SingleSint32 != 0) {
-        output.WriteSInt32(5, fieldNames[43], SingleSint32);
+        output.WriteSInt32(5, SingleSint32);
       }
       if (SingleSint64 != 0L) {
-        output.WriteSInt64(6, fieldNames[44], SingleSint64);
+        output.WriteSInt64(6, SingleSint64);
       }
       if (SingleFixed32 != 0) {
-        output.WriteFixed32(7, fieldNames[29], SingleFixed32);
+        output.WriteFixed32(7, SingleFixed32);
       }
       if (SingleFixed64 != 0UL) {
-        output.WriteFixed64(8, fieldNames[30], SingleFixed64);
+        output.WriteFixed64(8, SingleFixed64);
       }
       if (SingleSfixed32 != 0) {
-        output.WriteSFixed32(9, fieldNames[41], SingleSfixed32);
+        output.WriteSFixed32(9, SingleSfixed32);
       }
       if (SingleSfixed64 != 0L) {
-        output.WriteSFixed64(10, fieldNames[42], SingleSfixed64);
+        output.WriteSFixed64(10, SingleSfixed64);
       }
       if (SingleFloat != 0F) {
-        output.WriteFloat(11, fieldNames[31], SingleFloat);
+        output.WriteFloat(11, SingleFloat);
       }
       if (SingleDouble != 0D) {
-        output.WriteDouble(12, fieldNames[28], SingleDouble);
+        output.WriteDouble(12, SingleDouble);
       }
       if (SingleBool != false) {
-        output.WriteBool(13, fieldNames[26], SingleBool);
+        output.WriteBool(13, SingleBool);
       }
       if (SingleString != "") {
-        output.WriteString(14, fieldNames[45], SingleString);
+        output.WriteString(14, SingleString);
       }
       if (SingleBytes != pb::ByteString.Empty) {
-        output.WriteBytes(15, fieldNames[27], SingleBytes);
+        output.WriteBytes(15, SingleBytes);
       }
       if (singleNestedMessage_ != null) {
-        output.WriteMessage(18, fieldNames[39], SingleNestedMessage);
+        output.WriteMessage(18, SingleNestedMessage);
       }
       if (singleForeignMessage_ != null) {
-        output.WriteMessage(19, fieldNames[33], SingleForeignMessage);
+        output.WriteMessage(19, SingleForeignMessage);
       }
       if (singleImportMessage_ != null) {
-        output.WriteMessage(20, fieldNames[35], SingleImportMessage);
+        output.WriteMessage(20, SingleImportMessage);
       }
       if (SingleNestedEnum != global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum.NESTED_ENUM_UNSPECIFIED) {
-        output.WriteEnum(21, fieldNames[38], (int) SingleNestedEnum);
+        output.WriteEnum(21, (int) SingleNestedEnum);
       }
       if (SingleForeignEnum != global::Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UNSPECIFIED) {
-        output.WriteEnum(22, fieldNames[32], (int) SingleForeignEnum);
+        output.WriteEnum(22, (int) SingleForeignEnum);
       }
       if (SingleImportEnum != global::Google.Protobuf.TestProtos.ImportEnum.IMPORT_ENUM_UNSPECIFIED) {
-        output.WriteEnum(23, fieldNames[34], (int) SingleImportEnum);
+        output.WriteEnum(23, (int) SingleImportEnum);
       }
       if (singlePublicImportMessage_ != null) {
-        output.WriteMessage(26, fieldNames[40], SinglePublicImportMessage);
-      }
-      output.WritePackedInt32Array(31, fieldNames[14], repeatedInt32_);
-      output.WritePackedInt64Array(32, fieldNames[15], repeatedInt64_);
-      output.WritePackedUInt32Array(33, fieldNames[24], repeatedUint32_);
-      output.WritePackedUInt64Array(34, fieldNames[25], repeatedUint64_);
-      output.WritePackedSInt32Array(35, fieldNames[21], repeatedSint32_);
-      output.WritePackedSInt64Array(36, fieldNames[22], repeatedSint64_);
-      output.WritePackedFixed32Array(37, fieldNames[7], repeatedFixed32_);
-      output.WritePackedFixed64Array(38, fieldNames[8], repeatedFixed64_);
-      output.WritePackedSFixed32Array(39, fieldNames[19], repeatedSfixed32_);
-      output.WritePackedSFixed64Array(40, fieldNames[20], repeatedSfixed64_);
-      output.WritePackedFloatArray(41, fieldNames[9], repeatedFloat_);
-      output.WritePackedDoubleArray(42, fieldNames[6], repeatedDouble_);
-      output.WritePackedBoolArray(43, fieldNames[4], repeatedBool_);
-      output.WriteStringArray(44, fieldNames[23], repeatedString_);
-      output.WriteBytesArray(45, fieldNames[5], repeatedBytes_);
-      output.WriteMessageArray(48, fieldNames[17], repeatedNestedMessage_);
-      output.WriteMessageArray(49, fieldNames[11], repeatedForeignMessage_);
-      output.WriteMessageArray(50, fieldNames[13], repeatedImportMessage_);
-      output.WritePackedEnumArray(51, fieldNames[16], repeatedNestedEnum_);
-      output.WritePackedEnumArray(52, fieldNames[10], repeatedForeignEnum_);
-      output.WritePackedEnumArray(53, fieldNames[12], repeatedImportEnum_);
-      output.WriteMessageArray(54, fieldNames[18], repeatedPublicImportMessage_);
+        output.WriteMessage(26, SinglePublicImportMessage);
+      }
+      output.WritePackedInt32Array(31, repeatedInt32_);
+      output.WritePackedInt64Array(32, repeatedInt64_);
+      output.WritePackedUInt32Array(33, repeatedUint32_);
+      output.WritePackedUInt64Array(34, repeatedUint64_);
+      output.WritePackedSInt32Array(35, repeatedSint32_);
+      output.WritePackedSInt64Array(36, repeatedSint64_);
+      output.WritePackedFixed32Array(37, repeatedFixed32_);
+      output.WritePackedFixed64Array(38, repeatedFixed64_);
+      output.WritePackedSFixed32Array(39, repeatedSfixed32_);
+      output.WritePackedSFixed64Array(40, repeatedSfixed64_);
+      output.WritePackedFloatArray(41, repeatedFloat_);
+      output.WritePackedDoubleArray(42, repeatedDouble_);
+      output.WritePackedBoolArray(43, repeatedBool_);
+      output.WriteStringArray(44, repeatedString_);
+      output.WriteBytesArray(45, repeatedBytes_);
+      output.WriteMessageArray(48, repeatedNestedMessage_);
+      output.WriteMessageArray(49, repeatedForeignMessage_);
+      output.WriteMessageArray(50, repeatedImportMessage_);
+      output.WritePackedEnumArray(51, repeatedNestedEnum_);
+      output.WritePackedEnumArray(52, repeatedForeignEnum_);
+      output.WritePackedEnumArray(53, repeatedImportEnum_);
+      output.WriteMessageArray(54, repeatedPublicImportMessage_);
       if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) {
-        output.WriteUInt32(111, fieldNames[3], OneofUint32);
+        output.WriteUInt32(111, OneofUint32);
       }
       if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {
-        output.WriteMessage(112, fieldNames[1], OneofNestedMessage);
+        output.WriteMessage(112, OneofNestedMessage);
       }
       if (oneofFieldCase_ == OneofFieldOneofCase.OneofString) {
-        output.WriteString(113, fieldNames[2], OneofString);
+        output.WriteString(113, OneofString);
       }
       if (oneofFieldCase_ == OneofFieldOneofCase.OneofBytes) {
-        output.WriteBytes(114, fieldNames[0], OneofBytes);
+        output.WriteBytes(114, OneofBytes);
       }
     }
 
@@ -1372,16 +1371,9 @@ namespace Google.Protobuf.TestProtos {
 
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -1391,63 +1383,63 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref singleInt32_);
+            singleInt32_ = input.ReadInt32();
             break;
           }
           case 16: {
-            input.ReadInt64(ref singleInt64_);
+            singleInt64_ = input.ReadInt64();
             break;
           }
           case 24: {
-            input.ReadUInt32(ref singleUint32_);
+            singleUint32_ = input.ReadUInt32();
             break;
           }
           case 32: {
-            input.ReadUInt64(ref singleUint64_);
+            singleUint64_ = input.ReadUInt64();
             break;
           }
           case 40: {
-            input.ReadSInt32(ref singleSint32_);
+            singleSint32_ = input.ReadSInt32();
             break;
           }
           case 48: {
-            input.ReadSInt64(ref singleSint64_);
+            singleSint64_ = input.ReadSInt64();
             break;
           }
           case 61: {
-            input.ReadFixed32(ref singleFixed32_);
+            singleFixed32_ = input.ReadFixed32();
             break;
           }
           case 65: {
-            input.ReadFixed64(ref singleFixed64_);
+            singleFixed64_ = input.ReadFixed64();
             break;
           }
           case 77: {
-            input.ReadSFixed32(ref singleSfixed32_);
+            singleSfixed32_ = input.ReadSFixed32();
             break;
           }
           case 81: {
-            input.ReadSFixed64(ref singleSfixed64_);
+            singleSfixed64_ = input.ReadSFixed64();
             break;
           }
           case 93: {
-            input.ReadFloat(ref singleFloat_);
+            singleFloat_ = input.ReadFloat();
             break;
           }
           case 97: {
-            input.ReadDouble(ref singleDouble_);
+            singleDouble_ = input.ReadDouble();
             break;
           }
           case 104: {
-            input.ReadBool(ref singleBool_);
+            singleBool_ = input.ReadBool();
             break;
           }
           case 114: {
-            input.ReadString(ref singleString_);
+            singleString_ = input.ReadString();
             break;
           }
           case 122: {
-            input.ReadBytes(ref singleBytes_);
+            singleBytes_ = input.ReadBytes();
             break;
           }
           case 146: {
@@ -1472,19 +1464,16 @@ namespace Google.Protobuf.TestProtos {
             break;
           }
           case 168: {
-            int tmp = 0;
-            input.ReadEnum(ref tmp);
-            singleNestedEnum_ = (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum) tmp;break;
+            singleNestedEnum_ = (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum) input.ReadEnum();
+            break;
           }
           case 176: {
-            int tmp = 0;
-            input.ReadEnum(ref tmp);
-            singleForeignEnum_ = (global::Google.Protobuf.TestProtos.ForeignEnum) tmp;break;
+            singleForeignEnum_ = (global::Google.Protobuf.TestProtos.ForeignEnum) input.ReadEnum();
+            break;
           }
           case 184: {
-            int tmp = 0;
-            input.ReadEnum(ref tmp);
-            singleImportEnum_ = (global::Google.Protobuf.TestProtos.ImportEnum) tmp;break;
+            singleImportEnum_ = (global::Google.Protobuf.TestProtos.ImportEnum) input.ReadEnum();
+            break;
           }
           case 210: {
             if (singlePublicImportMessage_ == null) {
@@ -1495,114 +1484,111 @@ namespace Google.Protobuf.TestProtos {
           }
           case 250:
           case 248: {
-            input.ReadInt32Array(tag, fieldName, repeatedInt32_);
+            input.ReadInt32Array(tag, repeatedInt32_);
             break;
           }
           case 258:
           case 256: {
-            input.ReadInt64Array(tag, fieldName, repeatedInt64_);
+            input.ReadInt64Array(tag, repeatedInt64_);
             break;
           }
           case 266:
           case 264: {
-            input.ReadUInt32Array(tag, fieldName, repeatedUint32_);
+            input.ReadUInt32Array(tag, repeatedUint32_);
             break;
           }
           case 274:
           case 272: {
-            input.ReadUInt64Array(tag, fieldName, repeatedUint64_);
+            input.ReadUInt64Array(tag, repeatedUint64_);
             break;
           }
           case 282:
           case 280: {
-            input.ReadSInt32Array(tag, fieldName, repeatedSint32_);
+            input.ReadSInt32Array(tag, repeatedSint32_);
             break;
           }
           case 290:
           case 288: {
-            input.ReadSInt64Array(tag, fieldName, repeatedSint64_);
+            input.ReadSInt64Array(tag, repeatedSint64_);
             break;
           }
           case 298:
           case 301: {
-            input.ReadFixed32Array(tag, fieldName, repeatedFixed32_);
+            input.ReadFixed32Array(tag, repeatedFixed32_);
             break;
           }
           case 306:
           case 305: {
-            input.ReadFixed64Array(tag, fieldName, repeatedFixed64_);
+            input.ReadFixed64Array(tag, repeatedFixed64_);
             break;
           }
           case 314:
           case 317: {
-            input.ReadSFixed32Array(tag, fieldName, repeatedSfixed32_);
+            input.ReadSFixed32Array(tag, repeatedSfixed32_);
             break;
           }
           case 322:
           case 321: {
-            input.ReadSFixed64Array(tag, fieldName, repeatedSfixed64_);
+            input.ReadSFixed64Array(tag, repeatedSfixed64_);
             break;
           }
           case 330:
           case 333: {
-            input.ReadFloatArray(tag, fieldName, repeatedFloat_);
+            input.ReadFloatArray(tag, repeatedFloat_);
             break;
           }
           case 338:
           case 337: {
-            input.ReadDoubleArray(tag, fieldName, repeatedDouble_);
+            input.ReadDoubleArray(tag, repeatedDouble_);
             break;
           }
           case 346:
           case 344: {
-            input.ReadBoolArray(tag, fieldName, repeatedBool_);
+            input.ReadBoolArray(tag, repeatedBool_);
             break;
           }
           case 354: {
-            input.ReadStringArray(tag, fieldName, repeatedString_);
+            input.ReadStringArray(tag, repeatedString_);
             break;
           }
           case 362: {
-            input.ReadBytesArray(tag, fieldName, repeatedBytes_);
+            input.ReadBytesArray(tag, repeatedBytes_);
             break;
           }
           case 386: {
-            input.ReadMessageArray(tag, fieldName, repeatedNestedMessage_, global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage.Parser);
+            input.ReadMessageArray(tag, repeatedNestedMessage_, global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage.Parser);
             break;
           }
           case 394: {
-            input.ReadMessageArray(tag, fieldName, repeatedForeignMessage_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
+            input.ReadMessageArray(tag, repeatedForeignMessage_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
             break;
           }
           case 402: {
-            input.ReadMessageArray(tag, fieldName, repeatedImportMessage_, global::Google.Protobuf.TestProtos.ImportMessage.Parser);
+            input.ReadMessageArray(tag, repeatedImportMessage_, global::Google.Protobuf.TestProtos.ImportMessage.Parser);
             break;
           }
           case 410:
           case 408: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>(tag, fieldName, repeatedNestedEnum_);
+            input.ReadEnumArray<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>(tag, repeatedNestedEnum_);
             break;
           }
           case 418:
           case 416: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, fieldName, repeatedForeignEnum_);
+            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, repeatedForeignEnum_);
             break;
           }
           case 426:
           case 424: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ImportEnum>(tag, fieldName, repeatedImportEnum_);
+            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ImportEnum>(tag, repeatedImportEnum_);
             break;
           }
           case 434: {
-            input.ReadMessageArray(tag, fieldName, repeatedPublicImportMessage_, global::Google.Protobuf.TestProtos.PublicImportMessage.Parser);
+            input.ReadMessageArray(tag, repeatedPublicImportMessage_, global::Google.Protobuf.TestProtos.PublicImportMessage.Parser);
             break;
           }
           case 888: {
-            uint value = 0;
-            if (input.ReadUInt32(ref value)) {
-              oneofField_ = value;
-              oneofFieldCase_ = OneofFieldOneofCase.OneofUint32;
-            }
+            oneofField_ = input.ReadUInt32()
+            ;oneofFieldCase_ = OneofFieldOneofCase.OneofUint32;
             break;
           }
           case 898: {
@@ -1615,19 +1601,13 @@ namespace Google.Protobuf.TestProtos {
             break;
           }
           case 906: {
-            string value = "";
-            if (input.ReadString(ref value)) {
-              oneofField_ = value;
-              oneofFieldCase_ = OneofFieldOneofCase.OneofString;
-            }
+            oneofField_ = input.ReadString()
+            ;oneofFieldCase_ = OneofFieldOneofCase.OneofString;
             break;
           }
           case 914: {
-            pb::ByteString value = pb::ByteString.Empty;
-            if (input.ReadBytes(ref value)) {
-              oneofField_ = value;
-              oneofFieldCase_ = OneofFieldOneofCase.OneofBytes;
-            }
+            oneofField_ = input.ReadBytes()
+            ;oneofFieldCase_ = OneofFieldOneofCase.OneofBytes;
             break;
           }
         }
@@ -1693,10 +1673,9 @@ namespace Google.Protobuf.TestProtos {
           return hash;
         }
 
-        public void WriteTo(pb::ICodedOutputStream output) {
-          string[] fieldNames = _fieldNames;
+        public void WriteTo(pb::CodedOutputStream output) {
           if (Bb != 0) {
-            output.WriteInt32(1, fieldNames[0], Bb);
+            output.WriteInt32(1, Bb);
           }
         }
 
@@ -1716,16 +1695,9 @@ namespace Google.Protobuf.TestProtos {
           }
         }
 
-        public void MergeFrom(pb::ICodedInputStream input) {
+        public void MergeFrom(pb::CodedInputStream input) {
           uint tag;
-          string fieldName;
-          while (input.ReadTag(out tag, out fieldName)) {
-            if (tag == 0 && fieldName != null) {
-              int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-              if (fieldOrdinal >= 0) {
-                tag = _fieldTags[fieldOrdinal];
-              }
-            }
+          while (input.ReadTag(out tag)) {
             switch(tag) {
               case 0:
                 throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -1735,7 +1707,7 @@ namespace Google.Protobuf.TestProtos {
                 }
                 break;
               case 8: {
-                input.ReadInt32(ref bb_);
+                bb_ = input.ReadInt32();
                 break;
               }
             }
@@ -1811,15 +1783,14 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (child_ != null) {
-        output.WriteMessage(1, fieldNames[0], Child);
+        output.WriteMessage(1, Child);
       }
       if (payload_ != null) {
-        output.WriteMessage(2, fieldNames[1], Payload);
+        output.WriteMessage(2, Payload);
       }
-      output.WriteMessageArray(3, fieldNames[2], repeatedChild_);
+      output.WriteMessageArray(3, repeatedChild_);
     }
 
     public int CalculateSize() {
@@ -1854,16 +1825,9 @@ namespace Google.Protobuf.TestProtos {
       repeatedChild_.Add(other.repeatedChild_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -1887,7 +1851,7 @@ namespace Google.Protobuf.TestProtos {
             break;
           }
           case 26: {
-            input.ReadMessageArray(tag, fieldName, repeatedChild_, global::Google.Protobuf.TestProtos.NestedTestAllTypes.Parser);
+            input.ReadMessageArray(tag, repeatedChild_, global::Google.Protobuf.TestProtos.NestedTestAllTypes.Parser);
             break;
           }
         }
@@ -1945,10 +1909,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (DeprecatedInt32 != 0) {
-        output.WriteInt32(1, fieldNames[0], DeprecatedInt32);
+        output.WriteInt32(1, DeprecatedInt32);
       }
     }
 
@@ -1968,16 +1931,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -1987,7 +1943,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref deprecatedInt32_);
+            deprecatedInt32_ = input.ReadInt32();
             break;
           }
         }
@@ -2044,10 +2000,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (C != 0) {
-        output.WriteInt32(1, fieldNames[0], C);
+        output.WriteInt32(1, C);
       }
     }
 
@@ -2067,16 +2022,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2086,7 +2034,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref c_);
+            c_ = input.ReadInt32();
             break;
           }
         }
@@ -2133,8 +2081,7 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -2147,16 +2094,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2217,10 +2157,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (foreignNested_ != null) {
-        output.WriteMessage(1, fieldNames[0], ForeignNested);
+        output.WriteMessage(1, ForeignNested);
       }
     }
 
@@ -2243,16 +2182,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2332,13 +2264,12 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (A != 0) {
-        output.WriteInt32(1, fieldNames[0], A);
+        output.WriteInt32(1, A);
       }
       if (Bb != 0) {
-        output.WriteInt32(268435455, fieldNames[1], Bb);
+        output.WriteInt32(268435455, Bb);
       }
     }
 
@@ -2364,16 +2295,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2383,11 +2307,11 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref a_);
+            a_ = input.ReadInt32();
             break;
           }
           case 2147483640: {
-            input.ReadInt32(ref bb_);
+            bb_ = input.ReadInt32();
             break;
           }
         }
@@ -2452,13 +2376,12 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (a_ != null) {
-        output.WriteMessage(1, fieldNames[0], A);
+        output.WriteMessage(1, A);
       }
       if (I != 0) {
-        output.WriteInt32(2, fieldNames[1], I);
+        output.WriteInt32(2, I);
       }
     }
 
@@ -2487,16 +2410,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2513,7 +2429,7 @@ namespace Google.Protobuf.TestProtos {
             break;
           }
           case 16: {
-            input.ReadInt32(ref i_);
+            i_ = input.ReadInt32();
             break;
           }
         }
@@ -2568,10 +2484,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (bb_ != null) {
-        output.WriteMessage(1, fieldNames[0], Bb);
+        output.WriteMessage(1, Bb);
       }
     }
 
@@ -2594,16 +2509,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2681,13 +2589,12 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (a_ != null) {
-        output.WriteMessage(1, fieldNames[0], A);
+        output.WriteMessage(1, A);
       }
       if (OptionalInt32 != 0) {
-        output.WriteInt32(2, fieldNames[1], OptionalInt32);
+        output.WriteInt32(2, OptionalInt32);
       }
     }
 
@@ -2716,16 +2623,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2742,7 +2642,7 @@ namespace Google.Protobuf.TestProtos {
             break;
           }
           case 16: {
-            input.ReadInt32(ref optionalInt32_);
+            optionalInt32_ = input.ReadInt32();
             break;
           }
         }
@@ -2859,24 +2759,23 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (PrimitiveField != 0) {
-        output.WriteInt32(1, fieldNames[2], PrimitiveField);
+        output.WriteInt32(1, PrimitiveField);
       }
       if (StringField != "") {
-        output.WriteString(2, fieldNames[7], StringField);
+        output.WriteString(2, StringField);
       }
       if (EnumField != global::Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UNSPECIFIED) {
-        output.WriteEnum(3, fieldNames[0], (int) EnumField);
+        output.WriteEnum(3, (int) EnumField);
       }
       if (messageField_ != null) {
-        output.WriteMessage(4, fieldNames[1], MessageField);
+        output.WriteMessage(4, MessageField);
       }
-      output.WritePackedInt32Array(7, fieldNames[5], repeatedPrimitiveField_);
-      output.WriteStringArray(8, fieldNames[6], repeatedStringField_);
-      output.WritePackedEnumArray(9, fieldNames[3], repeatedEnumField_);
-      output.WriteMessageArray(10, fieldNames[4], repeatedMessageField_);
+      output.WritePackedInt32Array(7, repeatedPrimitiveField_);
+      output.WriteStringArray(8, repeatedStringField_);
+      output.WritePackedEnumArray(9, repeatedEnumField_);
+      output.WriteMessageArray(10, repeatedMessageField_);
     }
 
     public int CalculateSize() {
@@ -2952,16 +2851,9 @@ namespace Google.Protobuf.TestProtos {
       repeatedMessageField_.Add(other.repeatedMessageField_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -2971,17 +2863,16 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref primitiveField_);
+            primitiveField_ = input.ReadInt32();
             break;
           }
           case 18: {
-            input.ReadString(ref stringField_);
+            stringField_ = input.ReadString();
             break;
           }
           case 24: {
-            int tmp = 0;
-            input.ReadEnum(ref tmp);
-            enumField_ = (global::Google.Protobuf.TestProtos.ForeignEnum) tmp;break;
+            enumField_ = (global::Google.Protobuf.TestProtos.ForeignEnum) input.ReadEnum();
+            break;
           }
           case 34: {
             if (messageField_ == null) {
@@ -2992,20 +2883,20 @@ namespace Google.Protobuf.TestProtos {
           }
           case 58:
           case 56: {
-            input.ReadInt32Array(tag, fieldName, repeatedPrimitiveField_);
+            input.ReadInt32Array(tag, repeatedPrimitiveField_);
             break;
           }
           case 66: {
-            input.ReadStringArray(tag, fieldName, repeatedStringField_);
+            input.ReadStringArray(tag, repeatedStringField_);
             break;
           }
           case 74:
           case 72: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, fieldName, repeatedEnumField_);
+            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, repeatedEnumField_);
             break;
           }
           case 82: {
-            input.ReadMessageArray(tag, fieldName, repeatedMessageField_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
+            input.ReadMessageArray(tag, repeatedMessageField_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser);
             break;
           }
         }
@@ -3090,19 +2981,18 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (MyInt != 0L) {
-        output.WriteInt64(1, fieldNames[1], MyInt);
+        output.WriteInt64(1, MyInt);
       }
       if (MyString != "") {
-        output.WriteString(11, fieldNames[2], MyString);
+        output.WriteString(11, MyString);
       }
       if (MyFloat != 0F) {
-        output.WriteFloat(101, fieldNames[0], MyFloat);
+        output.WriteFloat(101, MyFloat);
       }
       if (singleNestedMessage_ != null) {
-        output.WriteMessage(200, fieldNames[3], SingleNestedMessage);
+        output.WriteMessage(200, SingleNestedMessage);
       }
     }
 
@@ -3143,16 +3033,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3162,15 +3045,15 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt64(ref myInt_);
+            myInt_ = input.ReadInt64();
             break;
           }
           case 90: {
-            input.ReadString(ref myString_);
+            myString_ = input.ReadString();
             break;
           }
           case 813: {
-            input.ReadFloat(ref myFloat_);
+            myFloat_ = input.ReadFloat();
             break;
           }
           case 1602: {
@@ -3245,13 +3128,12 @@ namespace Google.Protobuf.TestProtos {
           return hash;
         }
 
-        public void WriteTo(pb::ICodedOutputStream output) {
-          string[] fieldNames = _fieldNames;
+        public void WriteTo(pb::CodedOutputStream output) {
           if (Bb != 0) {
-            output.WriteInt32(1, fieldNames[0], Bb);
+            output.WriteInt32(1, Bb);
           }
           if (Oo != 0L) {
-            output.WriteInt64(2, fieldNames[1], Oo);
+            output.WriteInt64(2, Oo);
           }
         }
 
@@ -3277,16 +3159,9 @@ namespace Google.Protobuf.TestProtos {
           }
         }
 
-        public void MergeFrom(pb::ICodedInputStream input) {
+        public void MergeFrom(pb::CodedInputStream input) {
           uint tag;
-          string fieldName;
-          while (input.ReadTag(out tag, out fieldName)) {
-            if (tag == 0 && fieldName != null) {
-              int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-              if (fieldOrdinal >= 0) {
-                tag = _fieldTags[fieldOrdinal];
-              }
-            }
+          while (input.ReadTag(out tag)) {
             switch(tag) {
               case 0:
                 throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3296,11 +3171,11 @@ namespace Google.Protobuf.TestProtos {
                 }
                 break;
               case 8: {
-                input.ReadInt32(ref bb_);
+                bb_ = input.ReadInt32();
                 break;
               }
               case 16: {
-                input.ReadInt64(ref oo_);
+                oo_ = input.ReadInt64();
                 break;
               }
             }
@@ -3362,10 +3237,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum.TEST_SPARSE_ENUM_UNSPECIFIED) {
-        output.WriteEnum(1, fieldNames[0], (int) SparseEnum);
+        output.WriteEnum(1, (int) SparseEnum);
       }
     }
 
@@ -3385,16 +3259,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3404,9 +3271,8 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            int tmp = 0;
-            input.ReadEnum(ref tmp);
-            sparseEnum_ = (global::Google.Protobuf.TestProtos.TestSparseEnum) tmp;break;
+            sparseEnum_ = (global::Google.Protobuf.TestProtos.TestSparseEnum) input.ReadEnum();
+            break;
           }
         }
       }
@@ -3462,10 +3328,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != "") {
-        output.WriteString(1, fieldNames[0], Data);
+        output.WriteString(1, Data);
       }
     }
 
@@ -3485,16 +3350,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3504,7 +3362,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 10: {
-            input.ReadString(ref data_);
+            data_ = input.ReadString();
             break;
           }
         }
@@ -3559,9 +3417,8 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
-      output.WriteStringArray(1, fieldNames[0], data_);
+    public void WriteTo(pb::CodedOutputStream output) {
+      output.WriteStringArray(1, data_);
     }
 
     public int CalculateSize() {
@@ -3583,16 +3440,9 @@ namespace Google.Protobuf.TestProtos {
       data_.Add(other.data_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3602,7 +3452,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 10: {
-            input.ReadStringArray(tag, fieldName, data_);
+            input.ReadStringArray(tag, data_);
             break;
           }
         }
@@ -3659,10 +3509,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != pb::ByteString.Empty) {
-        output.WriteBytes(1, fieldNames[0], Data);
+        output.WriteBytes(1, Data);
       }
     }
 
@@ -3682,16 +3531,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3701,7 +3543,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 10: {
-            input.ReadBytes(ref data_);
+            data_ = input.ReadBytes();
             break;
           }
         }
@@ -3758,10 +3600,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != pb::ByteString.Empty) {
-        output.WriteBytes(1, fieldNames[0], Data);
+        output.WriteBytes(1, Data);
       }
     }
 
@@ -3781,16 +3622,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3800,7 +3634,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 10: {
-            input.ReadBytes(ref data_);
+            data_ = input.ReadBytes();
             break;
           }
         }
@@ -3857,10 +3691,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != 0) {
-        output.WriteInt32(1, fieldNames[0], Data);
+        output.WriteInt32(1, Data);
       }
     }
 
@@ -3880,16 +3713,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3899,7 +3725,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt32(ref data_);
+            data_ = input.ReadInt32();
             break;
           }
         }
@@ -3956,10 +3782,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != 0) {
-        output.WriteUInt32(1, fieldNames[0], Data);
+        output.WriteUInt32(1, Data);
       }
     }
 
@@ -3979,16 +3804,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -3998,7 +3816,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadUInt32(ref data_);
+            data_ = input.ReadUInt32();
             break;
           }
         }
@@ -4055,10 +3873,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != 0L) {
-        output.WriteInt64(1, fieldNames[0], Data);
+        output.WriteInt64(1, Data);
       }
     }
 
@@ -4078,16 +3895,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -4097,7 +3907,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadInt64(ref data_);
+            data_ = input.ReadInt64();
             break;
           }
         }
@@ -4154,10 +3964,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != 0UL) {
-        output.WriteUInt64(1, fieldNames[0], Data);
+        output.WriteUInt64(1, Data);
       }
     }
 
@@ -4177,16 +3986,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -4196,7 +3998,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadUInt64(ref data_);
+            data_ = input.ReadUInt64();
             break;
           }
         }
@@ -4253,10 +4055,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (Data != false) {
-        output.WriteBool(1, fieldNames[0], Data);
+        output.WriteBool(1, Data);
       }
     }
 
@@ -4276,16 +4077,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -4295,7 +4089,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            input.ReadBool(ref data_);
+            data_ = input.ReadBool();
             break;
           }
         }
@@ -4391,16 +4185,15 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (fooCase_ == FooOneofCase.FooInt) {
-        output.WriteInt32(1, fieldNames[0], FooInt);
+        output.WriteInt32(1, FooInt);
       }
       if (fooCase_ == FooOneofCase.FooString) {
-        output.WriteString(2, fieldNames[2], FooString);
+        output.WriteString(2, FooString);
       }
       if (fooCase_ == FooOneofCase.FooMessage) {
-        output.WriteMessage(3, fieldNames[1], FooMessage);
+        output.WriteMessage(3, FooMessage);
       }
     }
 
@@ -4435,16 +4228,9 @@ namespace Google.Protobuf.TestProtos {
 
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -4454,19 +4240,13 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 8: {
-            int value = 0;
-            if (input.ReadInt32(ref value)) {
-              foo_ = value;
-              fooCase_ = FooOneofCase.FooInt;
-            }
+            foo_ = input.ReadInt32()
+            ;fooCase_ = FooOneofCase.FooInt;
             break;
           }
           case 18: {
-            string value = "";
-            if (input.ReadString(ref value)) {
-              foo_ = value;
-              fooCase_ = FooOneofCase.FooString;
-            }
+            foo_ = input.ReadString()
+            ;fooCase_ = FooOneofCase.FooString;
             break;
           }
           case 26: {
@@ -4634,22 +4414,21 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
-      output.WritePackedInt32Array(90, fieldNames[6], packedInt32_);
-      output.WritePackedInt64Array(91, fieldNames[7], packedInt64_);
-      output.WritePackedUInt32Array(92, fieldNames[12], packedUint32_);
-      output.WritePackedUInt64Array(93, fieldNames[13], packedUint64_);
-      output.WritePackedSInt32Array(94, fieldNames[10], packedSint32_);
-      output.WritePackedSInt64Array(95, fieldNames[11], packedSint64_);
-      output.WritePackedFixed32Array(96, fieldNames[3], packedFixed32_);
-      output.WritePackedFixed64Array(97, fieldNames[4], packedFixed64_);
-      output.WritePackedSFixed32Array(98, fieldNames[8], packedSfixed32_);
-      output.WritePackedSFixed64Array(99, fieldNames[9], packedSfixed64_);
-      output.WritePackedFloatArray(100, fieldNames[5], packedFloat_);
-      output.WritePackedDoubleArray(101, fieldNames[1], packedDouble_);
-      output.WritePackedBoolArray(102, fieldNames[0], packedBool_);
-      output.WritePackedEnumArray(103, fieldNames[2], packedEnum_);
+    public void WriteTo(pb::CodedOutputStream output) {
+      output.WritePackedInt32Array(90, packedInt32_);
+      output.WritePackedInt64Array(91, packedInt64_);
+      output.WritePackedUInt32Array(92, packedUint32_);
+      output.WritePackedUInt64Array(93, packedUint64_);
+      output.WritePackedSInt32Array(94, packedSint32_);
+      output.WritePackedSInt64Array(95, packedSint64_);
+      output.WritePackedFixed32Array(96, packedFixed32_);
+      output.WritePackedFixed64Array(97, packedFixed64_);
+      output.WritePackedSFixed32Array(98, packedSfixed32_);
+      output.WritePackedSFixed64Array(99, packedSfixed64_);
+      output.WritePackedFloatArray(100, packedFloat_);
+      output.WritePackedDoubleArray(101, packedDouble_);
+      output.WritePackedBoolArray(102, packedBool_);
+      output.WritePackedEnumArray(103, packedEnum_);
     }
 
     public int CalculateSize() {
@@ -4803,16 +4582,9 @@ namespace Google.Protobuf.TestProtos {
       packedEnum_.Add(other.packedEnum_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -4823,72 +4595,72 @@ namespace Google.Protobuf.TestProtos {
             break;
           case 722:
           case 720: {
-            input.ReadInt32Array(tag, fieldName, packedInt32_);
+            input.ReadInt32Array(tag, packedInt32_);
             break;
           }
           case 730:
           case 728: {
-            input.ReadInt64Array(tag, fieldName, packedInt64_);
+            input.ReadInt64Array(tag, packedInt64_);
             break;
           }
           case 738:
           case 736: {
-            input.ReadUInt32Array(tag, fieldName, packedUint32_);
+            input.ReadUInt32Array(tag, packedUint32_);
             break;
           }
           case 746:
           case 744: {
-            input.ReadUInt64Array(tag, fieldName, packedUint64_);
+            input.ReadUInt64Array(tag, packedUint64_);
             break;
           }
           case 754:
           case 752: {
-            input.ReadSInt32Array(tag, fieldName, packedSint32_);
+            input.ReadSInt32Array(tag, packedSint32_);
             break;
           }
           case 762:
           case 760: {
-            input.ReadSInt64Array(tag, fieldName, packedSint64_);
+            input.ReadSInt64Array(tag, packedSint64_);
             break;
           }
           case 770:
           case 773: {
-            input.ReadFixed32Array(tag, fieldName, packedFixed32_);
+            input.ReadFixed32Array(tag, packedFixed32_);
             break;
           }
           case 778:
           case 777: {
-            input.ReadFixed64Array(tag, fieldName, packedFixed64_);
+            input.ReadFixed64Array(tag, packedFixed64_);
             break;
           }
           case 786:
           case 789: {
-            input.ReadSFixed32Array(tag, fieldName, packedSfixed32_);
+            input.ReadSFixed32Array(tag, packedSfixed32_);
             break;
           }
           case 794:
           case 793: {
-            input.ReadSFixed64Array(tag, fieldName, packedSfixed64_);
+            input.ReadSFixed64Array(tag, packedSfixed64_);
             break;
           }
           case 802:
           case 805: {
-            input.ReadFloatArray(tag, fieldName, packedFloat_);
+            input.ReadFloatArray(tag, packedFloat_);
             break;
           }
           case 810:
           case 809: {
-            input.ReadDoubleArray(tag, fieldName, packedDouble_);
+            input.ReadDoubleArray(tag, packedDouble_);
             break;
           }
           case 818:
           case 816: {
-            input.ReadBoolArray(tag, fieldName, packedBool_);
+            input.ReadBoolArray(tag, packedBool_);
             break;
           }
           case 826:
           case 824: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, fieldName, packedEnum_);
+            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, packedEnum_);
             break;
           }
         }
@@ -5047,22 +4819,21 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
-      output.WriteInt32Array(90, fieldNames[6], unpackedInt32_);
-      output.WriteInt64Array(91, fieldNames[7], unpackedInt64_);
-      output.WriteUInt32Array(92, fieldNames[12], unpackedUint32_);
-      output.WriteUInt64Array(93, fieldNames[13], unpackedUint64_);
-      output.WriteSInt32Array(94, fieldNames[10], unpackedSint32_);
-      output.WriteSInt64Array(95, fieldNames[11], unpackedSint64_);
-      output.WriteFixed32Array(96, fieldNames[3], unpackedFixed32_);
-      output.WriteFixed64Array(97, fieldNames[4], unpackedFixed64_);
-      output.WriteSFixed32Array(98, fieldNames[8], unpackedSfixed32_);
-      output.WriteSFixed64Array(99, fieldNames[9], unpackedSfixed64_);
-      output.WriteFloatArray(100, fieldNames[5], unpackedFloat_);
-      output.WriteDoubleArray(101, fieldNames[1], unpackedDouble_);
-      output.WriteBoolArray(102, fieldNames[0], unpackedBool_);
-      output.WriteEnumArray(103, fieldNames[2], unpackedEnum_);
+    public void WriteTo(pb::CodedOutputStream output) {
+      output.WriteInt32Array(90, unpackedInt32_);
+      output.WriteInt64Array(91, unpackedInt64_);
+      output.WriteUInt32Array(92, unpackedUint32_);
+      output.WriteUInt64Array(93, unpackedUint64_);
+      output.WriteSInt32Array(94, unpackedSint32_);
+      output.WriteSInt64Array(95, unpackedSint64_);
+      output.WriteFixed32Array(96, unpackedFixed32_);
+      output.WriteFixed64Array(97, unpackedFixed64_);
+      output.WriteSFixed32Array(98, unpackedSfixed32_);
+      output.WriteSFixed64Array(99, unpackedSfixed64_);
+      output.WriteFloatArray(100, unpackedFloat_);
+      output.WriteDoubleArray(101, unpackedDouble_);
+      output.WriteBoolArray(102, unpackedBool_);
+      output.WriteEnumArray(103, unpackedEnum_);
     }
 
     public int CalculateSize() {
@@ -5189,16 +4960,9 @@ namespace Google.Protobuf.TestProtos {
       unpackedEnum_.Add(other.unpackedEnum_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -5209,72 +4973,72 @@ namespace Google.Protobuf.TestProtos {
             break;
           case 722:
           case 720: {
-            input.ReadInt32Array(tag, fieldName, unpackedInt32_);
+            input.ReadInt32Array(tag, unpackedInt32_);
             break;
           }
           case 730:
           case 728: {
-            input.ReadInt64Array(tag, fieldName, unpackedInt64_);
+            input.ReadInt64Array(tag, unpackedInt64_);
             break;
           }
           case 738:
           case 736: {
-            input.ReadUInt32Array(tag, fieldName, unpackedUint32_);
+            input.ReadUInt32Array(tag, unpackedUint32_);
             break;
           }
           case 746:
           case 744: {
-            input.ReadUInt64Array(tag, fieldName, unpackedUint64_);
+            input.ReadUInt64Array(tag, unpackedUint64_);
             break;
           }
           case 754:
           case 752: {
-            input.ReadSInt32Array(tag, fieldName, unpackedSint32_);
+            input.ReadSInt32Array(tag, unpackedSint32_);
             break;
           }
           case 762:
           case 760: {
-            input.ReadSInt64Array(tag, fieldName, unpackedSint64_);
+            input.ReadSInt64Array(tag, unpackedSint64_);
             break;
           }
           case 770:
           case 773: {
-            input.ReadFixed32Array(tag, fieldName, unpackedFixed32_);
+            input.ReadFixed32Array(tag, unpackedFixed32_);
             break;
           }
           case 778:
           case 777: {
-            input.ReadFixed64Array(tag, fieldName, unpackedFixed64_);
+            input.ReadFixed64Array(tag, unpackedFixed64_);
             break;
           }
           case 786:
           case 789: {
-            input.ReadSFixed32Array(tag, fieldName, unpackedSfixed32_);
+            input.ReadSFixed32Array(tag, unpackedSfixed32_);
             break;
           }
           case 794:
           case 793: {
-            input.ReadSFixed64Array(tag, fieldName, unpackedSfixed64_);
+            input.ReadSFixed64Array(tag, unpackedSfixed64_);
             break;
           }
           case 802:
           case 805: {
-            input.ReadFloatArray(tag, fieldName, unpackedFloat_);
+            input.ReadFloatArray(tag, unpackedFloat_);
             break;
           }
           case 810:
           case 809: {
-            input.ReadDoubleArray(tag, fieldName, unpackedDouble_);
+            input.ReadDoubleArray(tag, unpackedDouble_);
             break;
           }
           case 818:
           case 816: {
-            input.ReadBoolArray(tag, fieldName, unpackedBool_);
+            input.ReadBoolArray(tag, unpackedBool_);
             break;
           }
           case 826:
           case 824: {
-            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, fieldName, unpackedEnum_);
+            input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(tag, unpackedEnum_);
             break;
           }
         }
@@ -5369,14 +5133,13 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
-      output.WritePackedFixed32Array(12, fieldNames[0], repeatedFixed32_);
-      output.WritePackedInt32Array(13, fieldNames[3], repeatedInt32_);
-      output.WritePackedFixed64Array(2046, fieldNames[1], repeatedFixed64_);
-      output.WritePackedInt64Array(2047, fieldNames[4], repeatedInt64_);
-      output.WritePackedFloatArray(262142, fieldNames[2], repeatedFloat_);
-      output.WritePackedUInt64Array(262143, fieldNames[5], repeatedUint64_);
+    public void WriteTo(pb::CodedOutputStream output) {
+      output.WritePackedFixed32Array(12, repeatedFixed32_);
+      output.WritePackedInt32Array(13, repeatedInt32_);
+      output.WritePackedFixed64Array(2046, repeatedFixed64_);
+      output.WritePackedInt64Array(2047, repeatedInt64_);
+      output.WritePackedFloatArray(262142, repeatedFloat_);
+      output.WritePackedUInt64Array(262143, repeatedUint64_);
     }
 
     public int CalculateSize() {
@@ -5449,16 +5212,9 @@ namespace Google.Protobuf.TestProtos {
       repeatedUint64_.Add(other.repeatedUint64_);
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -5469,32 +5225,32 @@ namespace Google.Protobuf.TestProtos {
             break;
           case 98:
           case 101: {
-            input.ReadFixed32Array(tag, fieldName, repeatedFixed32_);
+            input.ReadFixed32Array(tag, repeatedFixed32_);
             break;
           }
           case 106:
           case 104: {
-            input.ReadInt32Array(tag, fieldName, repeatedInt32_);
+            input.ReadInt32Array(tag, repeatedInt32_);
             break;
           }
           case 16370:
           case 16369: {
-            input.ReadFixed64Array(tag, fieldName, repeatedFixed64_);
+            input.ReadFixed64Array(tag, repeatedFixed64_);
             break;
           }
           case 16378:
           case 16376: {
-            input.ReadInt64Array(tag, fieldName, repeatedInt64_);
+            input.ReadInt64Array(tag, repeatedInt64_);
             break;
           }
           case 2097138:
           case 2097141: {
-            input.ReadFloatArray(tag, fieldName, repeatedFloat_);
+            input.ReadFloatArray(tag, repeatedFloat_);
             break;
           }
           case 2097146:
           case 2097144: {
-            input.ReadUInt64Array(tag, fieldName, repeatedUint64_);
+            input.ReadUInt64Array(tag, repeatedUint64_);
             break;
           }
         }
@@ -5551,10 +5307,9 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
       if (A != "") {
-        output.WriteString(1, fieldNames[0], A);
+        output.WriteString(1, A);
       }
     }
 
@@ -5574,16 +5329,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -5593,7 +5341,7 @@ namespace Google.Protobuf.TestProtos {
             }
             break;
           case 10: {
-            input.ReadString(ref a_);
+            a_ = input.ReadString();
             break;
           }
         }
@@ -5640,8 +5388,7 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -5654,16 +5401,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -5716,8 +5456,7 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -5730,16 +5469,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -5792,8 +5524,7 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -5806,16 +5537,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -5868,8 +5592,7 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -5882,16 +5605,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -5944,8 +5660,7 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -5958,16 +5673,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();
@@ -6020,8 +5728,7 @@ namespace Google.Protobuf.TestProtos {
       return hash;
     }
 
-    public void WriteTo(pb::ICodedOutputStream output) {
-      string[] fieldNames = _fieldNames;
+    public void WriteTo(pb::CodedOutputStream output) {
     }
 
     public int CalculateSize() {
@@ -6034,16 +5741,9 @@ namespace Google.Protobuf.TestProtos {
       }
     }
 
-    public void MergeFrom(pb::ICodedInputStream input) {
+    public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
-      string fieldName;
-      while (input.ReadTag(out tag, out fieldName)) {
-        if (tag == 0 && fieldName != null) {
-          int fieldOrdinal = global::System.Array.BinarySearch(_fieldNames, fieldName, global::System.StringComparer.Ordinal);
-          if (fieldOrdinal >= 0) {
-            tag = _fieldTags[fieldOrdinal];
-          }
-        }
+      while (input.ReadTag(out tag)) {
         switch(tag) {
           case 0:
             throw pb::InvalidProtocolBufferException.InvalidTag();