Migrate writer to io::Printer for C#

1 files changed, 574 insertions, 545 deletions

diff --git a/src/google/protobuf/compiler/csharp/csharp_message.cc b/src/google/protobuf/compiler/csharp/csharp_message.cc
index 22681235..66b87110 100644
--- a/src/google/protobuf/compiler/csharp/csharp_message.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_message.cc
@@ -30,6 +30,7 @@
 
 #include <sstream>
 #include <algorithm>
+#include <map>
 
 #include <google/protobuf/compiler/code_generator.h>
 #include <google/protobuf/compiler/plugin.h>
@@ -46,7 +47,6 @@
 #include <google/protobuf/compiler/csharp/csharp_message.h>
 #include <google/protobuf/compiler/csharp/csharp_helpers.h>
 #include <google/protobuf/compiler/csharp/csharp_field_base.h>
-#include <google/protobuf/compiler/csharp/csharp_writer.h>
 
 using google::protobuf::internal::scoped_ptr;
 
@@ -105,7 +105,7 @@ std::string GetUniqueFileScopeIdentifier(const Descriptor* descriptor) {
   return "static_" + result;
 }
 
-void MessageGenerator::GenerateStaticVariables(Writer* writer) {
+void MessageGenerator::GenerateStaticVariables(io::Printer* printer) {
   // Because descriptor.proto (Google.ProtocolBuffers.DescriptorProtos) is
   // used in the construction of descriptors, we have a tricky bootstrapping
   // problem.  To help control static initialization order, we make sure all
@@ -117,175 +117,184 @@ void MessageGenerator::GenerateStaticVariables(Writer* writer) {
 
   if (!use_lite_runtime()) {
     // The descriptor for this type.
-    std::string access = "internal";
-    writer->WriteLine(
-        "$0$ static pbd::MessageDescriptor internal__$1$__Descriptor;", access,
-        identifier);
-    writer->WriteLine(
-        "$0$ static pb::FieldAccess.FieldAccessorTable<$1$, $1$.Builder> internal__$2$__FieldAccessorTable;",
-        access, full_class_name(), identifier);
+    printer->Print(
+        "internal static pbd::MessageDescriptor internal__$identifier$__Descriptor;\n"
+        "internal static pb::FieldAccess.FieldAccessorTable<$full_class_name$, $full_class_name$.Builder> internal__$identifier$__FieldAccessorTable;\n",
+	"identifier", GetUniqueFileScopeIdentifier(descriptor_),
+	"full_class_name", full_class_name());
   }
 
   for (int i = 0; i < descriptor_->nested_type_count(); i++) {
     MessageGenerator messageGenerator(descriptor_->nested_type(i));
-    messageGenerator.GenerateStaticVariables(writer);
+    messageGenerator.GenerateStaticVariables(printer);
   }
 }
 
-void MessageGenerator::GenerateStaticVariableInitializers(Writer* writer) {
-  std::string identifier = GetUniqueFileScopeIdentifier(descriptor_);
-
+void MessageGenerator::GenerateStaticVariableInitializers(io::Printer* printer) {
+  map<string, string> vars;
+  vars["identifier"] = GetUniqueFileScopeIdentifier(descriptor_);
+  vars["index"] = SimpleItoa(descriptor_->index());
+  vars["full_class_name"] = full_class_name();
+  if (descriptor_->containing_type() != NULL) {
+    vars["parent"] = GetUniqueFileScopeIdentifier(
+	descriptor_->containing_type());
+  }
   if (!use_lite_runtime()) {
-    writer->Write("internal__$0$__Descriptor = ", identifier);
+    printer->Print(vars, "internal__$identifier$__Descriptor = ");
 
     if (!descriptor_->containing_type()) {
-      writer->WriteLine("Descriptor.MessageTypes[$0$];",
-                        SimpleItoa(descriptor_->index()));
+      printer->Print(vars, "Descriptor.MessageTypes[$index$];\n");
     } else {
-      writer->WriteLine(
-          "internal__$0$__Descriptor.NestedTypes[$1$];",
-          GetUniqueFileScopeIdentifier(descriptor_->containing_type()),
-          SimpleItoa(descriptor_->index()));
+      printer->Print(vars, "internal__$parent$__Descriptor.NestedTypes[$index$];\n");
     }
 
-    writer->WriteLine("internal__$0$__FieldAccessorTable = ", identifier);
-    writer->WriteLine(
-        "    new pb::FieldAccess.FieldAccessorTable<$1$, $1$.Builder>(internal__$0$__Descriptor,",
-        identifier, full_class_name());
-    writer->Write("        new string[] { ");
+    printer->Print(
+      vars,
+      "internal__$identifier$__FieldAccessorTable = \n"
+      "    new pb::FieldAccess.FieldAccessorTable<$full_class_name$, $full_class_name$.Builder>(internal__$identifier$__Descriptor,\n");
+    printer->Print("        new string[] { ");
     for (int i = 0; i < descriptor_->field_count(); i++) {
-      writer->Write("\"$0$\", ", GetPropertyName(descriptor_->field(i)));
+      printer->Print("\"$property_name$\", ",
+                     "property_name", GetPropertyName(descriptor_->field(i)));
     }
     for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
-      writer->Write("\"$0$\", ",
-		    UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
+      printer->Print("\"$oneof_name$\", ",
+                     "oneof_name",
+                     UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
     }
-    writer->WriteLine("});");
+    printer->Print("});\n");
   }
 
   // Generate static member initializers for all nested types.
   for (int i = 0; i < descriptor_->nested_type_count(); i++) {
     MessageGenerator messageGenerator(descriptor_->nested_type(i));
-    messageGenerator.GenerateStaticVariableInitializers(writer);
+    messageGenerator.GenerateStaticVariableInitializers(printer);
   }
 
   for (int i = 0; i < descriptor_->extension_count(); i++) {
     ExtensionGenerator extensionGenerator(descriptor_->extension(i));
-    extensionGenerator.GenerateStaticVariableInitializers(writer);
+    extensionGenerator.GenerateStaticVariableInitializers(printer);
   }
 }
 
-void MessageGenerator::Generate(Writer* writer) {
-  writer->WriteLine(
-      "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
-  WriteGeneratedCodeAttributes(writer);
-  writer->WriteLine(
-      "$0$ sealed partial class $1$ : pb::$2$Message$3$<$1$, $1$.Builder> {",
-      class_access_level(), class_name(),
-      descriptor_->extension_range_count() > 0 ? "Extendable" : "Generated",
-      runtime_suffix());
-  writer->Indent();
-  writer->WriteLine("private $0$() { }", class_name());  // Private ctor.
-  // Must call MakeReadOnly() to make sure all lists are made read-only
-  writer->WriteLine(
-      "private static readonly $0$ defaultInstance = new $0$().MakeReadOnly();",
-      class_name());
+void MessageGenerator::Generate(io::Printer* printer) {
+  map<string, string> vars;
+  vars["class_name"] = class_name();
+  vars["access_level"] = class_access_level();
+  vars["extendable_or_generated"] = descriptor_->extension_range_count() > 0 ?
+    "Extendable" : "Generated";
+  vars["suffix"] = runtime_suffix();
+  vars["umbrella_class_name"] = GetFullUmbrellaClassName(descriptor_->file());
+  vars["identifier"] = GetUniqueFileScopeIdentifier(descriptor_);
+
+  printer->Print(
+      "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]\n");
+  WriteGeneratedCodeAttributes(printer);
+  printer->Print(
+    vars,
+    "$access_level$ sealed partial class $class_name$ : pb::$extendable_or_generated$Message$suffix$<$class_name$, $class_name$.Builder> {\n");
+  printer->Indent();
+  printer->Print(
+    vars,
+    "private $class_name$() { }\n"  // Private ctor.
+    // Must call MakeReadOnly() to make sure all lists are made read-only
+    "private static readonly $class_name$ defaultInstance = new $class_name$().MakeReadOnly();\n");
 
   if (optimize_speed()) {
-    writer->WriteLine(
-        "private static readonly string[] _$0$FieldNames = new string[] { $2$$1$$2$ };",
-        UnderscoresToCamelCase(class_name(), false),
-        JoinStrings(field_names(), "\", \""),
-        field_names().size() > 0 ? "\"" : "");
+    printer->Print(
+      "private static readonly string[] _$name$FieldNames = "
+      "new string[] { $slash$$field_names$$slash$ };\n",
+      "name", UnderscoresToCamelCase(class_name(), false),
+      "field_names", JoinStrings(field_names(), "\", \""),
+      "slash", field_names().size() > 0 ? "\"" : "");
     std::vector<std::string> tags;
     for (int i = 0; i < field_names().size(); i++) {
       uint32 tag = internal::WireFormat::MakeTag(
           descriptor_->FindFieldByName(field_names()[i]));
       tags.push_back(SimpleItoa(tag));
     }
-    writer->WriteLine(
-        "private static readonly uint[] _$0$FieldTags = new uint[] { $1$ };",
-        UnderscoresToCamelCase(class_name(), false), JoinStrings(tags, ", "));
-  }
-  writer->WriteLine("public static $0$ DefaultInstance {", class_name());
-  writer->WriteLine("  get { return defaultInstance; }");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine("public override $0$ DefaultInstanceForType {",
-                    class_name());
-  writer->WriteLine("  get { return DefaultInstance; }");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine("protected override $0$ ThisMessage {", class_name());
-  writer->WriteLine("  get { return this; }");
-  writer->WriteLine("}");
-  writer->WriteLine();
+    printer->Print(
+      "private static readonly uint[] _$name$FieldTags = new uint[] { $tags$ };\n",
+      "name", UnderscoresToCamelCase(class_name(), false),
+      "tags", JoinStrings(tags, ", "));
+  }
+  printer->Print(
+    vars,
+    "public static $class_name$ DefaultInstance {\n"
+    "  get { return defaultInstance; }\n"
+    "}\n"
+    "\n"
+    "public override $class_name$ DefaultInstanceForType {\n"
+    "  get { return DefaultInstance; }\n"
+    "}\n"
+    "\n"
+    "protected override $class_name$ ThisMessage {\n"
+    "  get { return this; }\n"
+    "}\n\n");
+
   if (!use_lite_runtime()) {
-    writer->WriteLine("public static pbd::MessageDescriptor Descriptor {");
-    writer->WriteLine("  get { return $0$.internal__$1$__Descriptor; }",
-                      GetFullUmbrellaClassName(descriptor_->file()),
-                      GetUniqueFileScopeIdentifier(descriptor_));
-    writer->WriteLine("}");
-    writer->WriteLine();
-    writer->WriteLine(
-        "protected override pb::FieldAccess.FieldAccessorTable<$0$, $0$.Builder> InternalFieldAccessors {",
-        class_name());
-    writer->WriteLine("  get { return $0$.internal__$1$__FieldAccessorTable; }",
-                      GetFullUmbrellaClassName(descriptor_->file()),
-                      GetUniqueFileScopeIdentifier(descriptor_));
-    writer->WriteLine("}");
-    writer->WriteLine();
+    printer->Print(
+      vars,
+      "public static pbd::MessageDescriptor Descriptor {\n"
+      "  get { return $umbrella_class_name$.internal__$identifier$__Descriptor; }\n"
+      "}\n"
+      "\n"
+      "protected override pb::FieldAccess.FieldAccessorTable<$class_name$, $class_name$.Builder> InternalFieldAccessors {\n"
+      "  get { return $umbrella_class_name$.internal__$identifier$__FieldAccessorTable; }\n"
+      "}\n"
+      "\n");
   }
 
   // Extensions don't need to go in an extra nested type
   for (int i = 0; i < descriptor_->extension_count(); i++) {
     ExtensionGenerator extensionGenerator(descriptor_->extension(i));
-    extensionGenerator.Generate(writer);
+    extensionGenerator.Generate(printer);
   }
 
   if (descriptor_->enum_type_count() + descriptor_->nested_type_count() > 0) {
-    writer->WriteLine("#region Nested types");
-    writer->WriteLine(
-        "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
-    WriteGeneratedCodeAttributes(writer);
-    writer->WriteLine("public static partial class Types {");
-    writer->Indent();
+    printer->Print("#region Nested types\n"
+		   "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]\n");
+    WriteGeneratedCodeAttributes(printer);
+    printer->Print("public static partial class Types {\n");
+    printer->Indent();
     for (int i = 0; i < descriptor_->enum_type_count(); i++) {
       EnumGenerator enumGenerator(descriptor_->enum_type(i));
-      enumGenerator.Generate(writer);
+      enumGenerator.Generate(printer);
     }
     for (int i = 0; i < descriptor_->nested_type_count(); i++) {
       MessageGenerator messageGenerator(descriptor_->nested_type(i));
-      messageGenerator.Generate(writer);
+      messageGenerator.Generate(printer);
     }
-    writer->Outdent();
-    writer->WriteLine("}");
-    writer->WriteLine("#endregion");
-    writer->WriteLine();
+    printer->Outdent();
+    printer->Print("}\n"
+                   "#endregion\n"
+                   "\n");
   }
 
   // oneof
   for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
-    string name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false);
-    string property_name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true);
-    writer->WriteLine("private object $0$_;", name);
-    writer->WriteLine("public enum $0$OneofCase {", property_name);
-    writer->Indent();
+    vars["name"] = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false);
+    vars["property_name"] = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true);
+    printer->Print(
+      vars,
+      "private object $name$_;\n"
+      "public enum $property_name$OneofCase {\n");
+    printer->Indent();
     for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
       const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
-      writer->WriteLine("$0$ = $1$,",
-			GetPropertyName(field),
-			SimpleItoa(field->number()));
+      printer->Print("$field_property_name$ = $index$,\n",
+                     "field_property_name", GetPropertyName(field),
+                     "index", SimpleItoa(field->number()));
     }
-    writer->WriteLine("None = 0,");
-    writer->Outdent();
-    writer->WriteLine("}");
-    writer->WriteLine("private $0$OneofCase $1$Case_ = $0$OneofCase.None;",
-		      property_name, name);
-    writer->WriteLine("public $0$OneofCase $0$Case {", property_name);
-    writer->WriteLine("  get { return $0$Case_; }", name);
-    writer->WriteLine("}");
-    writer->WriteLine();
+    printer->Print("None = 0,\n");
+    printer->Outdent();
+    printer->Print("}\n");
+    printer->Print(
+      vars,
+      "private $property_name$OneofCase $name$Case_ = $property_name$OneofCase.None;\n"
+      "public $property_name$OneofCase $property_name$Case {\n"
+      "  get { return $name$Case_; }\n"
+      "}\n\n");
   }
 
   // Fields
@@ -293,108 +302,119 @@ void MessageGenerator::Generate(Writer* writer) {
     const FieldDescriptor* fieldDescriptor = descriptor_->field(i);
 
     // Rats: we lose the debug comment here :(
-    writer->WriteLine("public const int $0$ = $1$;",
-                      GetFieldConstantName(fieldDescriptor),
-                      SimpleItoa(fieldDescriptor->number()));
+    printer->Print(
+      "public const int $field_constant_name$ = $index$;\n",
+      "field_constant_name", GetFieldConstantName(fieldDescriptor),
+      "index", SimpleItoa(fieldDescriptor->number()));
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(fieldDescriptor));
-    generator->GenerateMembers(writer);
-    writer->WriteLine();
+    generator->GenerateMembers(printer);
+    printer->Print("\n");
   }
 
   if (optimize_speed()) {
     if (SupportFieldPresence(descriptor_->file())) {
-      GenerateIsInitialized(writer);
+      GenerateIsInitialized(printer);
     }
-    GenerateMessageSerializationMethods(writer);
+    GenerateMessageSerializationMethods(printer);
   }
   if (use_lite_runtime()) {
-    GenerateLiteRuntimeMethods(writer);
+    GenerateLiteRuntimeMethods(printer);
   }
 
-  GenerateParseFromMethods(writer);
-  GenerateBuilder(writer);
+  GenerateParseFromMethods(printer);
+  GenerateBuilder(printer);
 
   // Force the static initialization code for the file to run, since it may
   // initialize static variables declared in this class.
-  writer->WriteLine("static $0$() {", class_name());
+  printer->Print(vars, "static $class_name$() {\n");
   // We call object.ReferenceEquals() just to make it a valid statement on its own.
   // Another option would be GetType(), but that causes problems in DescriptorProtoFile,
   // where the bootstrapping is somewhat recursive - type initializers call
   // each other, effectively. We temporarily see Descriptor as null.
-  writer->WriteLine("  object.ReferenceEquals($0$.Descriptor, null);",
-                    GetFullUmbrellaClassName(descriptor_->file()));
-  writer->WriteLine("}");
+  printer->Print(
+    vars,
+    "  object.ReferenceEquals($umbrella_class_name$.Descriptor, null);\n"
+    "}\n");
 
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print("\n");
 
 }
 
-void MessageGenerator::GenerateLiteRuntimeMethods(Writer* writer) {
+void MessageGenerator::GenerateLiteRuntimeMethods(io::Printer* printer) {
+  map<string, string> vars;
+  vars["class_name"] = class_name();
+
   bool callbase = descriptor_->extension_range_count() > 0;
-  writer->WriteLine("#region Lite runtime methods");
-  writer->WriteLine("public override int GetHashCode() {");
-  writer->Indent();
-  writer->WriteLine("int hash = GetType().GetHashCode();");
+  printer->Print("#region Lite runtime methods\n"
+                 "public override int GetHashCode() {\n");
+  printer->Indent();
+  printer->Print("int hash = GetType().GetHashCode();\n");
   for (int i = 0; i < descriptor_->field_count(); i++) {
     const FieldDescriptor* field = descriptor_->field(i);
     if (field->containing_oneof() == NULL) {
       scoped_ptr<FieldGeneratorBase> generator(
           CreateFieldGeneratorInternal(field));
-      generator->WriteHash(writer);
+      generator->WriteHash(printer);
     }
   }
   for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
     string name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false);
     string property_name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true);
-    writer->WriteLine("if ($0$Case_ != $1$OneofCase.None) {", name, property_name);
-    writer->WriteLine("  hash ^= $0$_.GetHashCode();", name);
-    writer->WriteLine("}");
+    printer->Print(
+      "if ($name$Case_ != $property_name$OneofCase.None) {\n"
+      "  hash ^= $name$_.GetHashCode();\n"
+      "}\n",
+      "name", UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false),
+      "property_name",
+      UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
   }
   if (callbase) {
-    writer->WriteLine("hash ^= base.GetHashCode();");
-  }
-  writer->WriteLine("return hash;");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
-
-  writer->WriteLine("public override bool Equals(object obj) {");
-  writer->Indent();
-  writer->WriteLine("$0$ other = obj as $0$;", class_name());
-  writer->WriteLine("if (other == null) return false;");
+    printer->Print("hash ^= base.GetHashCode();\n");
+  }
+  printer->Print("return hash;\n");
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print("\n");
+
+  printer->Print("public override bool Equals(object obj) {\n");
+  printer->Indent();
+  printer->Print(
+    vars,
+    "$class_name$ other = obj as $class_name$;\n"
+    "if (other == null) return false;\n");
   for (int i = 0; i < descriptor_->field_count(); i++) {
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
-    generator->WriteEquals(writer);
+    generator->WriteEquals(printer);
   }
   if (callbase) {
-    writer->WriteLine("if (!base.Equals(other)) return false;");
+    printer->Print("if (!base.Equals(other)) return false;\n");
   }
-  writer->WriteLine("return true;");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
+  printer->Print("return true;\n");
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print("\n");
 
-  writer->WriteLine(
-      "public override void PrintTo(global::System.IO.TextWriter writer) {");
-  writer->Indent();
+  printer->Print(
+    "public override void PrintTo(global::System.IO.TextWriter writer) {\n");
+  printer->Indent();
 
   for (int i = 0; i < fields_by_number().size(); i++) {
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(fields_by_number()[i]));
-    generator->WriteToString(writer);
+    generator->WriteToString(printer);
   }
 
   if (callbase) {
-    writer->WriteLine("base.PrintTo(writer);");
+    printer->Print("base.PrintTo(writer);\n");
   }
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine("#endregion");
-  writer->WriteLine();
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print("#endregion\n");
+  printer->Print("\n");
 }
 
 bool CompareExtensionRangesStart(const Descriptor::ExtensionRange* r1,
@@ -402,7 +422,7 @@ bool CompareExtensionRangesStart(const Descriptor::ExtensionRange* r1,
   return r1->start < r2->start;
 }
 
-void MessageGenerator::GenerateMessageSerializationMethods(Writer* writer) {
+void MessageGenerator::GenerateMessageSerializationMethods(io::Printer* printer) {
   std::vector<const Descriptor::ExtensionRange*> extension_ranges_sorted;
   for (int i = 0; i < descriptor_->extension_range_count(); i++) {
     extension_ranges_sorted.push_back(descriptor_->extension_range(i));
@@ -410,439 +430,442 @@ void MessageGenerator::GenerateMessageSerializationMethods(Writer* writer) {
   std::sort(extension_ranges_sorted.begin(), extension_ranges_sorted.end(),
             CompareExtensionRangesStart);
 
-  writer->WriteLine(
-      "public override void WriteTo(pb::ICodedOutputStream output) {");
-  writer->Indent();
+  printer->Print(
+      "public override void WriteTo(pb::ICodedOutputStream output) {\n");
+  printer->Indent();
   // Make sure we've computed the serialized length, so that packed fields are generated correctly.
-  writer->WriteLine("CalcSerializedSize();");
-  writer->WriteLine("string[] field_names = _$0$FieldNames;",
-                    UnderscoresToCamelCase(class_name(), false));
+  printer->Print("CalcSerializedSize();\n"
+		 "string[] field_names = _$class_name$FieldNames;\n",
+                 "class_name", UnderscoresToCamelCase(class_name(), false));
   if (descriptor_->extension_range_count()) {
-    writer->WriteLine(
-        "pb::ExtendableMessage$1$<$0$, $0$.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);",
-        class_name(), runtime_suffix());
+    printer->Print(
+      "pb::ExtendableMessage$runtime_suffix$<$class_name$, $class_name$.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);\n",
+      "class_name", class_name(),
+      "runtime_suffix", runtime_suffix());
   }
 
   // Merge the fields and the extension ranges, both sorted by field number.
   for (int i = 0, j = 0;
       i < fields_by_number().size() || j < extension_ranges_sorted.size();) {
     if (i == fields_by_number().size()) {
-      GenerateSerializeOneExtensionRange(writer, extension_ranges_sorted[j++]);
+      GenerateSerializeOneExtensionRange(printer, extension_ranges_sorted[j++]);
     } else if (j == extension_ranges_sorted.size()) {
-      GenerateSerializeOneField(writer, fields_by_number()[i++]);
+      GenerateSerializeOneField(printer, fields_by_number()[i++]);
     } else if (fields_by_number()[i]->number()
         < extension_ranges_sorted[j]->start) {
-      GenerateSerializeOneField(writer, fields_by_number()[i++]);
+      GenerateSerializeOneField(printer, fields_by_number()[i++]);
     } else {
-      GenerateSerializeOneExtensionRange(writer, extension_ranges_sorted[j++]);
+      GenerateSerializeOneExtensionRange(printer, extension_ranges_sorted[j++]);
     }
   }
 
   if (!use_lite_runtime()) {
     if (descriptor_->options().message_set_wire_format())
     {
-      writer->WriteLine("UnknownFields.WriteAsMessageSetTo(output);");
+      printer->Print("UnknownFields.WriteAsMessageSetTo(output);\n");
     } else {
-      writer->WriteLine("UnknownFields.WriteTo(output);");
+      printer->Print("UnknownFields.WriteTo(output);\n");
     }
   }
 
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine("private int memoizedSerializedSize = -1;");
-  writer->WriteLine("public override int SerializedSize {");
-  writer->Indent();
-  writer->WriteLine("get {");
-  writer->Indent();
-  writer->WriteLine("int size = memoizedSerializedSize;");
-  writer->WriteLine("if (size != -1) return size;");
-  writer->WriteLine("return CalcSerializedSize();");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
-
-  writer->WriteLine("private int CalcSerializedSize() {");
-  writer->Indent();
-  writer->WriteLine("int size = memoizedSerializedSize;");
-  writer->WriteLine("if (size != -1) return size;");
-  writer->WriteLine();
-  writer->WriteLine("size = 0;");
+  printer->Outdent();
+  printer->Print(
+    "}\n"
+    "\n"
+    "private int memoizedSerializedSize = -1;\n"
+    "public override int SerializedSize {\n");
+  printer->Indent();
+  printer->Print("get {\n");
+  printer->Indent();
+  printer->Print(
+    "int size = memoizedSerializedSize;\n"
+    "if (size != -1) return size;\n"
+    "return CalcSerializedSize();\n");
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print("\n");
+
+  printer->Print("private int CalcSerializedSize() {\n");
+  printer->Indent();
+  printer->Print(
+    "int size = memoizedSerializedSize;\n"
+    "if (size != -1) return size;\n"
+    "\n"
+    "size = 0;\n");
   for (int i = 0; i < descriptor_->field_count(); i++) {
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
-    generator->GenerateSerializedSizeCode(writer);
+    generator->GenerateSerializedSizeCode(printer);
   }
   if (descriptor_->extension_range_count() > 0) {
-    writer->WriteLine("size += ExtensionsSerializedSize;");
+    printer->Print("size += ExtensionsSerializedSize;\n");
   }
 
   if (!use_lite_runtime()) {
     if (descriptor_->options().message_set_wire_format()) {
-      writer->WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;");
+      printer->Print("size += UnknownFields.SerializedSizeAsMessageSet;\n");
     } else {
-      writer->WriteLine("size += UnknownFields.SerializedSize;");
+      printer->Print("size += UnknownFields.SerializedSize;\n");
     }
   }
-  writer->WriteLine("memoizedSerializedSize = size;");
-  writer->WriteLine("return size;");
-  writer->Outdent();
-  writer->WriteLine("}");
+  printer->Print(
+    "memoizedSerializedSize = size;\n"
+    "return size;\n");
+  printer->Outdent();
+  printer->Print("}\n");
 }
 
 void MessageGenerator::GenerateSerializeOneField(
-    Writer* writer, const FieldDescriptor* fieldDescriptor) {
+    io::Printer* printer, const FieldDescriptor* fieldDescriptor) {
   scoped_ptr<FieldGeneratorBase> generator(
       CreateFieldGeneratorInternal(fieldDescriptor));
-  generator->GenerateSerializationCode(writer);
+  generator->GenerateSerializationCode(printer);
 }
 
 void MessageGenerator::GenerateSerializeOneExtensionRange(
-    Writer* writer, const Descriptor::ExtensionRange* extensionRange) {
-  writer->WriteLine("extensionWriter.WriteUntil($0$, output);",
-                    SimpleItoa(extensionRange->end));
+    io::Printer* printer, const Descriptor::ExtensionRange* extensionRange) {
+  printer->Print("extensionWriter.WriteUntil($range_end$, output);\n",
+		 "range_end", SimpleItoa(extensionRange->end));
 }
 
-void MessageGenerator::GenerateParseFromMethods(Writer* writer) {
+void MessageGenerator::GenerateParseFromMethods(io::Printer* printer) {
   // Note:  These are separate from GenerateMessageSerializationMethods()
   //   because they need to be generated even for messages that are optimized
   //   for code size.
-
-  writer->WriteLine("public static $0$ ParseFrom(pb::ByteString data) {",
-                    class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {",
-      class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine("public static $0$ ParseFrom(byte[] data) {", class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {",
-      class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseFrom(global::System.IO.Stream input) {",
-      class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {",
-      class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseDelimitedFrom(global::System.IO.Stream input) {",
-      class_name());
-  writer->WriteLine(
-      "  return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {",
-      class_name());
-  writer->WriteLine(
-      "  return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseFrom(pb::ICodedInputStream input) {",
-      class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
-  writer->WriteLine("}");
-  writer->WriteLine(
-      "public static $0$ ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {",
-      class_name());
-  writer->WriteLine(
-      "  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
-  writer->WriteLine("}");
+  map<string, string> vars;
+  vars["class_name"] = class_name();
+
+  printer->Print(
+    vars,
+    "public static $class_name$ ParseFrom(pb::ByteString data) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseFrom(byte[] data) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseFrom(global::System.IO.Stream input) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseDelimitedFrom(global::System.IO.Stream input) {\n"
+    "  return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {\n"
+    "  return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseFrom(pb::ICodedInputStream input) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();\n"
+    "}\n"
+    "public static $class_name$ ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {\n"
+    "  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();\n"
+    "}\n");
 }
 
-void MessageGenerator::GenerateBuilder(Writer* writer) {
-  writer->WriteLine("private $0$ MakeReadOnly() {", class_name());
-  writer->Indent();
+void MessageGenerator::GenerateBuilder(io::Printer* printer) {
+  map<string, string> vars;
+  vars["class_name"] = class_name();
+  vars["access_level"] = class_access_level();
+  vars["extendable_or_generated"] = descriptor_->extension_range_count() > 0 ?
+    "Extendable" : "Generated";
+  vars["suffix"] = runtime_suffix();
+
+  printer->Print(vars, "private $class_name$ MakeReadOnly() {\n");
+  printer->Indent();
   for (int i = 0; i < descriptor_->field_count(); i++) {
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
-    generator->GenerateBuildingCode(writer);
-  }
-  writer->WriteLine("return this;");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
-
-  writer->WriteLine(
-      "public static Builder CreateBuilder() { return new Builder(); }");
-  writer->WriteLine(
-      "public override Builder ToBuilder() { return CreateBuilder(this); }");
-  writer->WriteLine(
-      "public override Builder CreateBuilderForType() { return new Builder(); }");
-  writer->WriteLine("public static Builder CreateBuilder($0$ prototype) {",
-                    class_name());
-  writer->WriteLine("  return new Builder(prototype);");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine(
-      "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
-  WriteGeneratedCodeAttributes(writer);
-  writer->WriteLine(
-      "$0$ sealed partial class Builder : pb::$2$Builder$3$<$1$, Builder> {",
-      class_access_level(), class_name(),
-      descriptor_->extension_range_count() > 0 ? "Extendable" : "Generated",
-      runtime_suffix());
-  writer->Indent();
-  writer->WriteLine("protected override Builder ThisBuilder {");
-  writer->WriteLine("  get { return this; }");
-  writer->WriteLine("}");
-  GenerateCommonBuilderMethods(writer);
+    generator->GenerateBuildingCode(printer);
+  }
+  printer->Print("return this;\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
+
+  printer->Print(
+    vars,
+    "public static Builder CreateBuilder() { return new Builder(); }\n"
+    "public override Builder ToBuilder() { return CreateBuilder(this); }\n"
+    "public override Builder CreateBuilderForType() { return new Builder(); }\n"
+    "public static Builder CreateBuilder($class_name$ prototype) {\n"
+    "  return new Builder(prototype);\n"
+    "}\n"
+    "\n"
+    "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]\n");
+  WriteGeneratedCodeAttributes(printer);
+  printer->Print(
+    vars,
+    "$access_level$ sealed partial class Builder : pb::$extendable_or_generated$Builder$suffix$<$class_name$, Builder> {\n");
+  printer->Indent();
+  printer->Print(
+    "protected override Builder ThisBuilder {\n"
+    "  get { return this; }\n"
+    "}\n");
+  GenerateCommonBuilderMethods(printer);
   if (optimize_speed()) {
-    GenerateBuilderParsingMethods(writer);
+    GenerateBuilderParsingMethods(printer);
   }
   for (int i = 0; i < descriptor_->field_count(); i++) {
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
-    writer->WriteLine();
+    printer->Print("\n");
     // No field comment :(
-    generator->GenerateBuilderMembers(writer);
+    generator->GenerateBuilderMembers(printer);
   }
 
   // oneof
   for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
-    writer->WriteLine();
+    printer->Print("\n");
     string name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false);
     string property_name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true);
-    writer->WriteLine("public $0$OneofCase $0$Case {", property_name);
-    writer->WriteLine("  get { return result.$0$Case_; }", name);
-    writer->WriteLine("}");
-    writer->WriteLine("public Builder Clear$0$() {", property_name);
-    writer->WriteLine("  PrepareBuilder();");
-    writer->WriteLine("  result.$0$_ = null;", name);
-    writer->WriteLine("  result.$0$Case_ = $1$OneofCase.None;", name, property_name);
-    writer->WriteLine("  return this;");
-    writer->WriteLine("}");
-  }
-
-  writer->Outdent();
-  writer->WriteLine("}");
+    printer->Print(
+      "public $property_name$OneofCase $property_name$Case {\n"
+      "  get { return result.$name$Case_; }\n"
+      "}\n"
+      "public Builder Clear$property_name$() {\n"
+      "  PrepareBuilder();\n"
+      "  result.$name$_ = null;\n"
+      "  result.$name$Case_ = $property_name$OneofCase.None;\n"
+      "  return this;\n"
+      "}\n",
+      "name", UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false),
+      "property_name",
+      UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
+  }
+
+  printer->Outdent();
+  printer->Print("}\n");
 }
 
-void MessageGenerator::GenerateCommonBuilderMethods(Writer* writer) {
-  //default constructor
-  writer->WriteLine("public Builder() {");
-  //Durring static initialization of message, DefaultInstance is expected to return null.
-  writer->WriteLine("  result = DefaultInstance;");
-  writer->WriteLine("  resultIsReadOnly = true;");
-  writer->WriteLine("}");
-  //clone constructor
-  writer->WriteLine("internal Builder($0$ cloneFrom) {", class_name());
-  writer->WriteLine("  result = cloneFrom;");
-  writer->WriteLine("  resultIsReadOnly = true;");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine("private bool resultIsReadOnly;");
-  writer->WriteLine("private $0$ result;", class_name());
-  writer->WriteLine();
-  writer->WriteLine("private $0$ PrepareBuilder() {", class_name());
-  writer->WriteLine("  if (resultIsReadOnly) {");
-  writer->WriteLine("    $0$ original = result;", class_name());
-  writer->WriteLine("    result = new $0$();", class_name());
-  writer->WriteLine("    resultIsReadOnly = false;");
-  writer->WriteLine("    MergeFrom(original);");
-  writer->WriteLine("  }");
-  writer->WriteLine("  return result;");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine("public override bool IsInitialized {");
-  writer->WriteLine("  get { return result.IsInitialized; }");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine("protected override $0$ MessageBeingBuilt {", class_name());
-  writer->WriteLine("  get { return PrepareBuilder(); }");
-  writer->WriteLine("}");
-  writer->WriteLine();
+void MessageGenerator::GenerateCommonBuilderMethods(io::Printer* printer) {
+  map<string, string> vars;
+  vars["class_name"] = class_name();
+  vars["full_class_name"] = full_class_name();
+  vars["suffix"] = runtime_suffix();
+
+  printer->Print(
+    vars,
+    //default constructor
+    "public Builder() {\n"
+    //Durring static initialization of message, DefaultInstance is expected to return null.
+    "  result = DefaultInstance;\n"
+    "  resultIsReadOnly = true;\n"
+    "}\n"
+    //clone constructor
+    "internal Builder($class_name$ cloneFrom) {\n"
+    "  result = cloneFrom;\n"
+    "  resultIsReadOnly = true;\n"
+    "}\n"
+    "\n"
+    "private bool resultIsReadOnly;\n"
+    "private $class_name$ result;\n"
+    "\n"
+    "private $class_name$ PrepareBuilder() {\n"
+    "  if (resultIsReadOnly) {\n"
+    "    $class_name$ original = result;\n"
+    "    result = new $class_name$();\n"
+    "    resultIsReadOnly = false;\n"
+    "    MergeFrom(original);\n"
+    "  }\n"
+    "  return result;\n"
+    "}\n"
+    "\n"
+    "public override bool IsInitialized {\n"
+    "  get { return result.IsInitialized; }\n"
+    "}\n"
+    "\n"
+    "protected override $class_name$ MessageBeingBuilt {\n"
+    "  get { return PrepareBuilder(); }\n"
+    "}\n"
+    "\n");
   //Not actually expecting that DefaultInstance would ever be null here; however, we will ensure it does not break
-  writer->WriteLine("public override Builder Clear() {");
-  writer->WriteLine("  result = DefaultInstance;");
-  writer->WriteLine("  resultIsReadOnly = true;");
-  writer->WriteLine("  return this;");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine("public override Builder Clone() {");
-  writer->WriteLine("  if (resultIsReadOnly) {");
-  writer->WriteLine("    return new Builder(result);");
-  writer->WriteLine("  } else {");
-  writer->WriteLine("    return new Builder().MergeFrom(result);");
-  writer->WriteLine("  }");
-  writer->WriteLine("}");
-  writer->WriteLine();
+  printer->Print(
+    "public override Builder Clear() {\n"
+    "  result = DefaultInstance;\n"
+    "  resultIsReadOnly = true;\n"
+    "  return this;\n"
+    "}\n"
+    "\n"
+    "public override Builder Clone() {\n"
+    "  if (resultIsReadOnly) {\n"
+    "    return new Builder(result);\n"
+    "  } else {\n"
+    "    return new Builder().MergeFrom(result);\n"
+    "  }\n"
+    "}\n"
+    "\n");
   if (!use_lite_runtime()) {
-    writer->WriteLine(
-        "public override pbd::MessageDescriptor DescriptorForType {");
-    writer->WriteLine("  get { return $0$.Descriptor; }", full_class_name());
-    writer->WriteLine("}");
-    writer->WriteLine();
-  }
-  writer->WriteLine("public override $0$ DefaultInstanceForType {",
-                    class_name());
-  writer->WriteLine("  get { return $0$.DefaultInstance; }", full_class_name());
-  writer->WriteLine("}");
-  writer->WriteLine();
-
-  writer->WriteLine("public override $0$ BuildPartial() {", class_name());
-  writer->Indent();
-  writer->WriteLine("if (resultIsReadOnly) {");
-  writer->WriteLine("  return result;");
-  writer->WriteLine("}");
-  writer->WriteLine("resultIsReadOnly = true;");
-  writer->WriteLine("return result.MakeReadOnly();");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
+    printer->Print(
+      vars,
+      "public override pbd::MessageDescriptor DescriptorForType {\n"
+      "  get { return $full_class_name$.Descriptor; }\n"
+      "}\n\n");
+  }
+  printer->Print(
+    vars,
+    "public override $class_name$ DefaultInstanceForType {\n"
+    "  get { return $full_class_name$.DefaultInstance; }\n"
+    "}\n\n");
+
+  printer->Print(
+    vars,
+    "public override $class_name$ BuildPartial() {\n"
+    "  if (resultIsReadOnly) {\n"
+    "    return result;\n"
+    "  }\n"
+    "  resultIsReadOnly = true;\n"
+    "  return result.MakeReadOnly();\n"
+    "}\n\n");
 
   if (optimize_speed()) {
-    writer->WriteLine(
-        "public override Builder MergeFrom(pb::IMessage$0$ other) {",
-        runtime_suffix());
-    writer->WriteLine("  if (other is $0$) {", class_name());
-    writer->WriteLine("    return MergeFrom(($0$) other);", class_name());
-    writer->WriteLine("  } else {");
-    writer->WriteLine("    base.MergeFrom(other);");
-    writer->WriteLine("    return this;");
-    writer->WriteLine("  }");
-    writer->WriteLine("}");
-    writer->WriteLine();
-    writer->WriteLine("public override Builder MergeFrom($0$ other) {",
-                      class_name());
+    printer->Print(
+      vars,
+      "public override Builder MergeFrom(pb::IMessage$suffix$ other) {\n"
+      "  if (other is $class_name$) {\n"
+      "    return MergeFrom(($class_name$) other);\n"
+      "  } else {\n"
+      "    base.MergeFrom(other);\n"
+      "    return this;\n"
+      "  }\n"
+      "}\n\n");
+
+    printer->Print(vars,"public override Builder MergeFrom($class_name$ other) {\n");
     // Optimization:  If other is the default instance, we know none of its
     // fields are set so we can skip the merge.
-    writer->Indent();
-    writer->WriteLine("if (other == $0$.DefaultInstance) return this;",
-                      full_class_name());
-    writer->WriteLine("PrepareBuilder();");
+    printer->Indent();
+    printer->Print(
+      vars,
+      "if (other == $full_class_name$.DefaultInstance) return this;\n"
+      "PrepareBuilder();\n");
     for (int i = 0; i < descriptor_->field_count(); i++) {
       if (!descriptor_->field(i)->containing_oneof()) {
 	scoped_ptr<FieldGeneratorBase> generator(
 	  CreateFieldGeneratorInternal(descriptor_->field(i)));
-	generator->GenerateMergingCode(writer);
+	generator->GenerateMergingCode(printer);
       }
      }
 
     // Merge oneof fields
     for (int i = 0; i < descriptor_->oneof_decl_count(); ++i) {
-      string name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false);
-      string property_name = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true);
-      writer->WriteLine("switch (other.$0$Case) {", property_name);
-      writer->Indent();
+      vars["name"] = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), false);
+      vars["property_name"] = UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true);
+      printer->Print(vars, "switch (other.$property_name$Case) {\n");
+      printer->Indent();
       for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
         const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
-	writer->WriteLine("case $0$OneofCase.$1$: {",
-          property_name, GetPropertyName(field));
+	vars["field_property_name"] = GetPropertyName(field);
+	printer->Print(
+          vars,
+          "case $property_name$OneofCase.$field_property_name$: {\n");
 	if (field->type() == FieldDescriptor::TYPE_GROUP ||
 	    field->type() == FieldDescriptor::TYPE_MESSAGE) {
-	  writer->WriteLine("  Merge$0$(other.$0$);", GetPropertyName(field));
+	  printer->Print(
+            vars,
+            "  Merge$field_property_name$(other.$field_property_name$);\n");
 	} else {
-	  writer->WriteLine("  Set$0$(other.$0$);", GetPropertyName(field));
+	  printer->Print(
+            vars,
+            "  Set$field_property_name$(other.$field_property_name$);\n");
 	}
-        writer->WriteLine("  break;");
-	writer->WriteLine("}");
+        printer->Print("  break;\n");
+	printer->Print("}\n");
       }
-      writer->WriteLine("case $0$OneofCase.None: { break; }", property_name);
-      writer->Outdent();
-      writer->WriteLine("}");
+      printer->Print(vars, "case $property_name$OneofCase.None: { break; }\n");
+      printer->Outdent();
+      printer->Print("}\n");
     }
 
     // if message type has extensions
     if (descriptor_->extension_range_count() > 0) {
-      writer->WriteLine("  this.MergeExtensionFields(other);");
+      printer->Print("  this.MergeExtensionFields(other);\n");
     }
     if (!use_lite_runtime()) {
-      writer->WriteLine("this.MergeUnknownFields(other.UnknownFields);");
+      printer->Print("this.MergeUnknownFields(other.UnknownFields);\n");
     }
-    writer->WriteLine("return this;");
-    writer->Outdent();
-    writer->WriteLine("}");
-    writer->WriteLine();
+    printer->Print("return this;\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
   }
 
 }
 
-void MessageGenerator::GenerateBuilderParsingMethods(Writer* writer) {
-  writer->WriteLine(
-      "public override Builder MergeFrom(pb::ICodedInputStream input) {");
-  writer->WriteLine("  return MergeFrom(input, pb::ExtensionRegistry.Empty);");
-  writer->WriteLine("}");
-  writer->WriteLine();
-  writer->WriteLine(
-      "public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {");
-  writer->Indent();
-  writer->WriteLine("PrepareBuilder();");
+void MessageGenerator::GenerateBuilderParsingMethods(io::Printer* printer) {
+  printer->Print(
+    "public override Builder MergeFrom(pb::ICodedInputStream input) {\n"
+    "  return MergeFrom(input, pb::ExtensionRegistry.Empty);\n"
+    "}\n\n");
+
+  printer->Print(
+    "public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {\n");
+  printer->Indent();
+  printer->Print("PrepareBuilder();\n");
   if (!use_lite_runtime()) {
-    writer->WriteLine("pb::UnknownFieldSet.Builder unknownFields = null;");
-  }
-  writer->WriteLine("uint tag;");
-  writer->WriteLine("string field_name;");
-  writer->WriteLine("while (input.ReadTag(out tag, out field_name)) {");
-  writer->Indent();
-  writer->WriteLine("if(tag == 0 && field_name != null) {");
-  writer->Indent();
+    printer->Print("pb::UnknownFieldSet.Builder unknownFields = null;\n");
+  }
+  printer->Print(
+    "uint tag;\n"
+    "string field_name;\n"
+    "while (input.ReadTag(out tag, out field_name)) {\n");
+  printer->Indent();
+  printer->Print("if(tag == 0 && field_name != null) {\n");
+  printer->Indent();
   //if you change from StringComparer.Ordinal, the array sort in FieldNames { get; } must also change
-  writer->WriteLine(
-      "int field_ordinal = global::System.Array.BinarySearch(_$0$FieldNames, field_name, global::System.StringComparer.Ordinal);",
-      UnderscoresToCamelCase(class_name(), false));
-  writer->WriteLine("if(field_ordinal >= 0)");
-  writer->WriteLine("  tag = _$0$FieldTags[field_ordinal];",
-                    UnderscoresToCamelCase(class_name(), false));
-  writer->WriteLine("else {");
+  printer->Print(
+    "int field_ordinal = global::System.Array.BinarySearch(_$camel_class_name$FieldNames, field_name, global::System.StringComparer.Ordinal);\n"
+    "if(field_ordinal >= 0)\n"
+    "  tag = _$camel_class_name$FieldTags[field_ordinal];\n"
+    "else {\n",
+    "camel_class_name", UnderscoresToCamelCase(class_name(), false));
   if (!use_lite_runtime()) {
-    writer->WriteLine("  if (unknownFields == null) {");  // First unknown field - create builder now
-    writer->WriteLine(
-        "    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);");
-    writer->WriteLine("  }");
-  }
-  writer->WriteLine(
-      "  ParseUnknownField(input, $0$extensionRegistry, tag, field_name);",
-      use_lite_runtime() ? "" : "unknownFields, ");
-  writer->WriteLine("  continue;");
-  writer->WriteLine("}");
-  writer->Outdent();
-  writer->WriteLine("}");
-
-  writer->WriteLine("switch (tag) {");
-  writer->Indent();
-  writer->WriteLine("case 0: {");  // 0 signals EOF / limit reached
-  writer->WriteLine("  throw pb::InvalidProtocolBufferException.InvalidTag();");
-  writer->WriteLine("}");
-  writer->WriteLine("default: {");
-  writer->WriteLine("  if (pb::WireFormat.IsEndGroupTag(tag)) {");
+    printer->Print(
+      "  if (unknownFields == null) {\n"  // First unknown field - create builder now
+      "    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);\n"
+      "  }\n");
+  }
+  printer->Print(
+    "  ParseUnknownField(input, $prefix$extensionRegistry, tag, field_name);\n",
+    "prefix", use_lite_runtime() ? "" : "unknownFields, ");
+  printer->Print("  continue;\n");
+  printer->Print("}\n");
+  printer->Outdent();
+  printer->Print("}\n");
+
+  printer->Print("switch (tag) {\n");
+  printer->Indent();
+  printer->Print(
+    "case 0: {\n"  // 0 signals EOF / limit reached
+    "  throw pb::InvalidProtocolBufferException.InvalidTag();\n"
+    "}\n"
+    "default: {\n"
+    "  if (pb::WireFormat.IsEndGroupTag(tag)) {\n");
   if (!use_lite_runtime()) {
-    writer->WriteLine("    if (unknownFields != null) {");
-    writer->WriteLine("      this.UnknownFields = unknownFields.Build();");
-    writer->WriteLine("    }");
-  }
-  writer->WriteLine("    return this;");  // it's an endgroup tag
-  writer->WriteLine("  }");
+    printer->Print(
+      "    if (unknownFields != null) {\n"
+      "      this.UnknownFields = unknownFields.Build();\n"
+      "    }\n");
+  }
+  printer->Print(
+    "    return this;\n"  // it's an endgroup tag
+    "  }\n");
   if (!use_lite_runtime()) {
-    writer->WriteLine("  if (unknownFields == null) {");  // First unknown field - create builder now
-    writer->WriteLine(
-        "    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);");
-    writer->WriteLine("  }");
+    printer->Print(
+      "  if (unknownFields == null) {\n"  // First unknown field - create builder now
+      "    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);\n"
+      "  }\n");
   }
-  writer->WriteLine(
-      "  ParseUnknownField(input, $0$extensionRegistry, tag, field_name);",
-      use_lite_runtime() ? "" : "unknownFields, ");
-  writer->WriteLine("  break;");
-  writer->WriteLine("}");
+  printer->Print(
+      "  ParseUnknownField(input, $prefix$extensionRegistry, tag, field_name);\n",
+      "prefix", use_lite_runtime() ? "" : "unknownFields, ");
+  printer->Print("  break;\n");
+  printer->Print("}\n");
 
   for (int i = 0; i < fields_by_number().size(); i++) {
     const FieldDescriptor* field = fields_by_number()[i];
@@ -853,53 +876,54 @@ void MessageGenerator::GenerateBuilderParsingMethods(Writer* writer) {
         && (wt == internal::WireFormatLite::WIRETYPE_VARINT
             || wt == internal::WireFormatLite::WIRETYPE_FIXED32
             || wt == internal::WireFormatLite::WIRETYPE_FIXED64)) {
-      writer->WriteLine(
-          "case $0$:",
-          SimpleItoa(
-              internal::WireFormatLite::MakeTag(
-                  field->number(),
-                  internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED)));
+      printer->Print(
+        "case $number$:\n",
+        "number",
+        SimpleItoa(
+            internal::WireFormatLite::MakeTag(
+                field->number(),
+                internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED)));
     }
 
-    writer->WriteLine("case $0$: {", SimpleItoa(tag));
-    writer->Indent();
+    printer->Print("case $tag$: {\n", "tag", SimpleItoa(tag));
+    printer->Indent();
     scoped_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(field));
-    generator->GenerateParsingCode(writer);
-    writer->WriteLine("break;");
-    writer->Outdent();
-    writer->WriteLine("}");
+    generator->GenerateParsingCode(printer);
+    printer->Print("break;\n");
+    printer->Outdent();
+    printer->Print("}\n");
   }
 
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print("\n");
   if (!use_lite_runtime()) {
-    writer->WriteLine("if (unknownFields != null) {");
-    writer->WriteLine("  this.UnknownFields = unknownFields.Build();");
-    writer->WriteLine("}");
-  }
-  writer->WriteLine("return this;");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
+    printer->Print(
+      "if (unknownFields != null) {\n"
+      "  this.UnknownFields = unknownFields.Build();\n"
+      "}\n");
+  }
+  printer->Print("return this;\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 }
 
-void MessageGenerator::GenerateIsInitialized(Writer* writer) {
-  writer->WriteLine("public override bool IsInitialized {");
-  writer->Indent();
-  writer->WriteLine("get {");
-  writer->Indent();
+void MessageGenerator::GenerateIsInitialized(io::Printer* printer) {
+  printer->Print("public override bool IsInitialized {\n");
+  printer->Indent();
+  printer->Print("get {\n");
+  printer->Indent();
 
   // Check that all required fields in this message are set.
   // TODO(kenton):  We can optimize this when we switch to putting all the
   // "has" fields into a single bitfield.
   for (int i = 0; i < descriptor_->field_count(); i++) {
     if (descriptor_->field(i)->is_required()) {
-      writer->WriteLine("if (!has$0$) return false;",
-                        GetPropertyName(descriptor_->field(i)));
+      printer->Print("if (!has$property_name$) return false;\n",
+		     "property_name", GetPropertyName(descriptor_->field(i)));
     }
   }
 
@@ -916,43 +940,48 @@ void MessageGenerator::GenerateIsInitialized(Writer* writer) {
       string propertyName = UnderscoresToPascalCase(GetFieldName(field));
       if (field->is_repeated())
       {
-          writer->WriteLine("foreach ($0$ element in $1$List) {",
-                           GetClassName(field->message_type()),
-                           propertyName);
-          writer->WriteLine("  if (!element.IsInitialized) return false;");
-          writer->WriteLine("}");
+        printer->Print(
+          "foreach ($class_name$ element in $property_name$List) {\n"
+          "  if (!element.IsInitialized) return false;\n"
+          "}\n",
+          "class_name", GetClassName(field->message_type()),
+          "property_name", propertyName);
       }
       else if (field->is_optional())
       {
-          writer->WriteLine("if (Has$0$) {", propertyName);
-          writer->WriteLine("  if (!$0$.IsInitialized) return false;", propertyName);
-          writer->WriteLine("}");
+        printer->Print(
+          "if (Has$property_name$) {\n"
+          "  if (!$property_name$.IsInitialized) return false;\n"
+          "}\n",
+          "property_name", propertyName);
       }
       else
       {
-          writer->WriteLine("if (!$0$.IsInitialized) return false;", propertyName);
+        printer->Print(
+          "if (!$property_name$.IsInitialized) return false;\n",
+          "property_name", propertyName);
       }
   }
 
   if (descriptor_->extension_range_count() > 0) {
-    writer->WriteLine("if (!ExtensionsAreInitialized) return false;");
-  }
-  writer->WriteLine("return true;");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->Outdent();
-  writer->WriteLine("}");
-  writer->WriteLine();
+    printer->Print("if (!ExtensionsAreInitialized) return false;\n");
+  }
+  printer->Print("return true;\n");
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print("\n");
 }
 
-void MessageGenerator::GenerateExtensionRegistrationCode(Writer* writer) {
+void MessageGenerator::GenerateExtensionRegistrationCode(io::Printer* printer) {
   for (int i = 0; i < descriptor_->extension_count(); i++) {
     ExtensionGenerator extensionGenerator(descriptor_->extension(i));
-    extensionGenerator.GenerateExtensionRegistrationCode(writer);
+    extensionGenerator.GenerateExtensionRegistrationCode(printer);
   }
   for (int i = 0; i < descriptor_->nested_type_count(); i++) {
     MessageGenerator messageGenerator(descriptor_->nested_type(i));
-    messageGenerator.GenerateExtensionRegistrationCode(writer);
+    messageGenerator.GenerateExtensionRegistrationCode(printer);
   }
 }