A few stylistic issues

14 files changed, 989 insertions, 990 deletions

diff --git a/src/ProtoGen.Test/DependencyResolutionTest.cs b/src/ProtoGen.Test/DependencyResolutionTest.cs
index 647ed872..7e19d443 100644
--- a/src/ProtoGen.Test/DependencyResolutionTest.cs
+++ b/src/ProtoGen.Test/DependencyResolutionTest.cs
@@ -50,7 +50,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
       FileDescriptorProto second = new FileDescriptorProto.Builder { Name="Second" }.Build();
       FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
 
-      IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
+      IList<FileDescriptor> converted = Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
       Assert.AreEqual(2, converted.Count);
       Assert.AreEqual("First", converted[0].Name);
       Assert.AreEqual(0, converted[0].Dependencies.Count);
@@ -63,7 +63,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
       FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = {"Second"} }.Build();
       FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second" }.Build();
       FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
-      IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
+      IList<FileDescriptor> converted = Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
       Assert.AreEqual(2, converted.Count);
       Assert.AreEqual("First", converted[0].Name);
       Assert.AreEqual(1, converted[0].Dependencies.Count);
@@ -77,7 +77,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
       FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First" }.Build();
       FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = {"First"} }.Build();
       FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
-      IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
+      IList<FileDescriptor> converted = Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
       Assert.AreEqual(2, converted.Count);
       Assert.AreEqual("First", converted[0].Name);
       Assert.AreEqual(0, converted[0].Dependencies.Count);
@@ -92,7 +92,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
       FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = { "First" } }.Build();
       FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
       try {
-        Generator.ConvertDescriptors(set);
+        Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
         Assert.Fail("Expected exception");
       } catch (DependencyResolutionException) {
         // Expected
@@ -104,7 +104,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
       FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build();
       FileDescriptorSet set = new FileDescriptorSet { FileList = { first } };
       try {
-        Generator.ConvertDescriptors(set);
+        Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
         Assert.Fail("Expected exception");
       } catch (DependencyResolutionException) {
         // Expected
@@ -116,7 +116,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
       FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "First" } }.Build();
       FileDescriptorSet set = new FileDescriptorSet { FileList = { first } };
       try {
-        Generator.ConvertDescriptors(set);
+        Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
         Assert.Fail("Expected exception");
       } catch (DependencyResolutionException) {
         // Expected
diff --git a/src/ProtoGen.Test/TempFile.cs b/src/ProtoGen.Test/TempFile.cs
index fdc637a8..e41b591b 100644
--- a/src/ProtoGen.Test/TempFile.cs
+++ b/src/ProtoGen.Test/TempFile.cs
@@ -5,44 +5,50 @@ using System.Text;
 
 namespace Google.ProtocolBuffers.ProtoGen
 {
-	class ProtoFile : TempFile
-	{
-		public ProtoFile (string filename, string contents)
-		{
-			_tempFile = filename;
-			File.WriteAllText(_tempFile, contents);
-		}
-	}
-	class TempFile : IDisposable
-	{
-		protected string _tempFile;
+    class ProtoFile : TempFile
+    {
+        public ProtoFile(string filename, string contents)
+            : base(filename, contents)
+        {
+        }
+    }
+    class TempFile : IDisposable
+    {
+        private string tempFile;
 
-		public static TempFile Attach(string path) 
-		{
-			TempFile f = new TempFile();
-			f._tempFile = path;
-			return f;
-		}
+        public static TempFile Attach(string path) 
+        {
+            return new TempFile(path, null);
+        }
 
-		protected TempFile() { }
-		public TempFile(string contents)
-		{
-			File.WriteAllText(_tempFile = Path.GetTempFileName(), contents, Encoding.ASCII);
-		}
+        protected TempFile(string filename, string contents) {
+            tempFile = filename;
+            if (contents != null)
+            {
+                File.WriteAllText(tempFile, contents, new UTF8Encoding(false));
+            }
+        }
 
-		public string TempPath { get { return _tempFile; } }
+        public TempFile(string contents)
+            : this(Path.GetTempFileName(), contents)
+        {
+        }
 
-		public void ChangeExtension(string ext)
-		{
-			string newFile = Path.ChangeExtension(_tempFile, ext);
-			File.Move(_tempFile, newFile);
-			_tempFile = newFile;
-		}
+        public string TempPath { get { return tempFile; } }
 
-		public void Dispose()
-		{
-			if(File.Exists(_tempFile))
-				File.Delete(_tempFile);
-		}
-	}
+        public void ChangeExtension(string ext)
+        {
+            string newFile = Path.ChangeExtension(tempFile, ext);
+            File.Move(tempFile, newFile);
+            tempFile = newFile;
+        }
+
+        public void Dispose()
+        {
+            if (File.Exists(tempFile))
+            {
+                File.Delete(tempFile);
+            }
+        }
+    }
 }
diff --git a/src/ProtoGen.Test/TestPreprocessing.cs b/src/ProtoGen.Test/TestPreprocessing.cs
index 7a2ea621..53cd5fec 100644
--- a/src/ProtoGen.Test/TestPreprocessing.cs
+++ b/src/ProtoGen.Test/TestPreprocessing.cs
@@ -40,381 +40,389 @@ using NUnit.Framework;
 
 namespace Google.ProtocolBuffers.ProtoGen
 {
-	[TestFixture]
-	[Category("Preprocessor")]
-	public partial class TestPreprocessing
-	{
-		private static readonly string TEMP = Path.Combine(Path.GetTempPath(), "proto-gen-test");
-		private const string DEFAULT_PROTO = @"
+    [TestFixture]
+    [Category("Preprocessor")]
+    public partial class TestPreprocessing
+    {
+        private static readonly string TempPath = Path.Combine(Path.GetTempPath(), "proto-gen-test");
+        private const string DefaultProto = @"
 package nunit.simple;
 // Test a very simple message.
 message MyMessage {
   optional string name = 1;
 }";
 
-		#region TestFixture SetUp/TearDown
-		private string OriginalWorkingDirectory = Environment.CurrentDirectory;
-		[TestFixtureSetUp]
-		public virtual void Setup()
-		{
-			Teardown();
-			Directory.CreateDirectory(TEMP);
-			Environment.CurrentDirectory = TEMP;
-		}
+        #region TestFixture SetUp/TearDown
+        private static readonly string OriginalWorkingDirectory = Environment.CurrentDirectory;
+        [TestFixtureSetUp]
+        public virtual void Setup()
+        {
+            Teardown();
+            Directory.CreateDirectory(TempPath);
+            Environment.CurrentDirectory = TempPath;
+        }
 
-		[TestFixtureTearDown]
-		public virtual void Teardown()
-		{
-			Environment.CurrentDirectory = OriginalWorkingDirectory;
-			if (Directory.Exists(TEMP))
-				Directory.Delete(TEMP, true);
-		}
-		#endregion
-		#region Helper Methods RunProtoGen / RunCsc
-		void RunProtoGen(int expect, params string[] args)
-		{
-			TextWriter tout = Console.Out, terr = Console.Error;
-			StringWriter temp = new StringWriter();
-			Console.SetOut(temp);
-			Console.SetError(temp);
-			try
-			{
-				Assert.AreEqual(expect, ProgramPreprocess.Run(args), "ProtoGen Failed: {0}", temp);
-			}
-			finally
-			{
-				Console.SetOut(tout);
-				Console.SetError(terr);
-			}
-		}
+        [TestFixtureTearDown]
+        public virtual void Teardown()
+        {
+            Environment.CurrentDirectory = OriginalWorkingDirectory;
+            if (Directory.Exists(TempPath))
+            {
+                Directory.Delete(TempPath, true);
+            }
+        }
+        #endregion
+        #region Helper Methods RunProtoGen / RunCsc
+        void RunProtoGen(int expect, params string[] args)
+        {
+            TextWriter tout = Console.Out, terr = Console.Error;
+            StringWriter temp = new StringWriter();
+            Console.SetOut(temp);
+            Console.SetError(temp);
+            try
+            {
+                Assert.AreEqual(expect, ProgramPreprocess.Run(args), "ProtoGen Failed: {0}", temp);
+            }
+            finally
+            {
+                Console.SetOut(tout);
+                Console.SetError(terr);
+            }
+        }
 
-		private Assembly RunCsc(int expect, params string[] sources)
-		{
-			using (TempFile tempDll = new TempFile(String.Empty))
-			{
-				tempDll.ChangeExtension(".dll");
-				List<string> args = new List<string>();
-				args.Add("/nologo");
-				args.Add("/target:library");
-				args.Add("/debug-");
-				args.Add(String.Format(@"""/out:{0}""", tempDll.TempPath));
-				args.Add("/r:System.dll");
-				args.Add(String.Format(@"""/r:{0}""", typeof (Google.ProtocolBuffers.DescriptorProtos.DescriptorProto).Assembly.Location));
-				args.AddRange(sources);
+        private Assembly RunCsc(int expect, params string[] sources)
+        {
+            using (TempFile tempDll = new TempFile(String.Empty))
+            {
+                tempDll.ChangeExtension(".dll");
+                List<string> args = new List<string>();
+                args.Add("/nologo");
+                args.Add("/target:library");
+                args.Add("/debug-");
+                args.Add(String.Format(@"""/out:{0}""", tempDll.TempPath));
+                args.Add("/r:System.dll");
+                args.Add(String.Format(@"""/r:{0}""", typeof (Google.ProtocolBuffers.DescriptorProtos.DescriptorProto).Assembly.Location));
+                args.AddRange(sources);
 
-				string exe = Path.Combine(System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(), "csc.exe");
-				ProcessStartInfo psi = new ProcessStartInfo(exe);
-				psi.CreateNoWindow = true;
-				psi.UseShellExecute = false;
-				psi.RedirectStandardOutput = true;
-				psi.RedirectStandardError = true;
-				psi.Arguments = string.Join(" ", args.ToArray());
-				Process p = Process.Start(psi);
-				p.WaitForExit();
-				string errorText = p.StandardOutput.ReadToEnd() + p.StandardError.ReadToEnd();
-				Assert.AreEqual(expect, p.ExitCode, "CSC.exe Failed: {0}", errorText);
+                string exe = Path.Combine(System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(), "csc.exe");
+                ProcessStartInfo psi = new ProcessStartInfo(exe);
+                psi.CreateNoWindow = true;
+                psi.UseShellExecute = false;
+                psi.RedirectStandardOutput = true;
+                psi.RedirectStandardError = true;
+                psi.Arguments = string.Join(" ", args.ToArray());
+                Process p = Process.Start(psi);
+                p.WaitForExit();
+                string errorText = p.StandardOutput.ReadToEnd() + p.StandardError.ReadToEnd();
+                Assert.AreEqual(expect, p.ExitCode, "CSC.exe Failed: {0}", errorText);
 
-				Assembly asm = null;
-				if (p.ExitCode == 0)
-				{
-					byte[] allbytes = File.ReadAllBytes(tempDll.TempPath);
-					asm = Assembly.Load(allbytes);
+                Assembly asm = null;
+                if (p.ExitCode == 0)
+                {
+                    byte[] allbytes = File.ReadAllBytes(tempDll.TempPath);
+                    asm = Assembly.Load(allbytes);
 
-					foreach (Type t in asm.GetTypes())
-						Debug.WriteLine(t.FullName, asm.FullName);
-				}
-				return asm;
-			}
-		}
-		#endregion
+                    foreach (Type t in asm.GetTypes())
+                    {
+                        Debug.WriteLine(t.FullName, asm.FullName);
+                    }
+                }
+                return asm;
+            }
+        }
+        #endregion
 
-		// *******************************************************************
-		// The following tests excercise options for protogen.exe
-		// *******************************************************************
+        // *******************************************************************
+        // The following tests excercise options for protogen.exe
+        // *******************************************************************
 
-		[Test]
-		public void TestProtoFile()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath);
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithConflictingType()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+        [Test]
+        public void TestProtoFile()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath);
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithConflictingType()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 package nunit.simple;
 // Test a very simple message.
 message " + test + @" {
   optional string name = 1;
 } "))
-			{
-				RunProtoGen(0, proto.TempPath);
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple." + test, true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple.Proto." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithNamespace()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath, "-namespace:MyNewNamespace");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("MyNewNamespace." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithUmbrellaClassName()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach("MyUmbrellaClassname.cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath, "/umbrella_classname=MyUmbrellaClassname");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple.MyUmbrellaClassname", true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithNestedClass()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath, "-nest_classes:true");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithExpandedNsDirectories()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(@"nunit\simple\" + test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath, "-expand_namespace_directories:true");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileDisablingClsComplianceFlags()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+            {
+                RunProtoGen(0, proto.TempPath);
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple." + test, true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple.Proto." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithNamespace()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath, "-namespace:MyNewNamespace");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("MyNewNamespace." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithUmbrellaClassName()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach("MyUmbrellaClassname.cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath, "/umbrella_classname=MyUmbrellaClassname");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple.MyUmbrellaClassname", true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithNestedClass()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath, "-nest_classes:true");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithExpandedNsDirectories()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(@"nunit\simple\" + test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath, "-expand_namespace_directories:true");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileDisablingClsComplianceFlags()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 package nunit.simple;
 // Test a very simple message.
 message MyMessage {
   optional uint32 name = 1;
 } "))
-			{
-				//CS3021: Warning as Error: xx does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute
-				RunProtoGen(0, proto.TempPath);
-				RunCsc(1, source.TempPath, "/warnaserror+");
-				//Now we know it fails, make it pass by turning off cls_compliance generation
-				RunProtoGen(0, proto.TempPath, "-cls_compliance:false");
-				Assembly a = RunCsc(0, source.TempPath, "/warnaserror+");
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithNewExtension()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".Generated.cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath, "-file_extension:.Generated.cs");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithUmbrellaNamespace()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath, "-umbrella_namespace:MyUmbrella.Namespace");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple.MyUmbrella.Namespace." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithIgnoredUmbrellaNamespaceDueToNesting()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(0, proto.TempPath, "-nest_classes:true", "-umbrella_namespace:MyUmbrella.Namespace");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithExplicitEmptyUmbrellaNamespace()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+            {
+                //CS3021: Warning as Error: xx does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute
+                RunProtoGen(0, proto.TempPath);
+                RunCsc(1, source.TempPath, "/warnaserror+");
+                //Now we know it fails, make it pass by turning off cls_compliance generation
+                RunProtoGen(0, proto.TempPath, "-cls_compliance:false");
+                Assembly a = RunCsc(0, source.TempPath, "/warnaserror+");
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithNewExtension()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".Generated.cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath, "-file_extension:.Generated.cs");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithUmbrellaNamespace()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath, "-umbrella_namespace:MyUmbrella.Namespace");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple.MyUmbrella.Namespace." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithIgnoredUmbrellaNamespaceDueToNesting()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(0, proto.TempPath, "-nest_classes:true", "-umbrella_namespace:MyUmbrella.Namespace");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithExplicitEmptyUmbrellaNamespace()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 package nunit.simple;
 // Test a very simple message.
 message " + test + @" {
   optional string name = 1;
 } "))
-			{
-				//Forces the umbrella class to not use a namespace even if a collision with a type is detected.
-				RunProtoGen(0, proto.TempPath, "-umbrella_namespace:");
-				//error CS0441: 'nunit.simple.TestProtoFileWithExplicitEmptyUmbrellaNamespace': a class cannot be both static and sealed
-				RunCsc(1, source.TempPath);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithNewOutputFolder()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(@"generated-code\" + test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				RunProtoGen(1, proto.TempPath, "-output_directory:generated-code");
-				Directory.CreateDirectory("generated-code");
-				RunProtoGen(0, proto.TempPath, "-output_directory:generated-code");
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileAndIgnoreGoogleProtobuf()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+            {
+                //Forces the umbrella class to not use a namespace even if a collision with a type is detected.
+                RunProtoGen(0, proto.TempPath, "-umbrella_namespace:");
+                //error CS0441: 'nunit.simple.TestProtoFileWithExplicitEmptyUmbrellaNamespace': a class cannot be both static and sealed
+                RunCsc(1, source.TempPath);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithNewOutputFolder()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(@"generated-code\" + test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                RunProtoGen(1, proto.TempPath, "-output_directory:generated-code");
+                Directory.CreateDirectory("generated-code");
+                RunProtoGen(0, proto.TempPath, "-output_directory:generated-code");
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileAndIgnoreGoogleProtobuf()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 import ""google/protobuf/csharp_options.proto"";
 option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace"";
-" + DEFAULT_PROTO))
-			{
-				string google = Path.Combine(TEMP, "google\\protobuf");
-				Directory.CreateDirectory(google);
-				foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
-					File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
+" + DefaultProto))
+            {
+                string google = Path.Combine(TempPath, "google\\protobuf");
+                Directory.CreateDirectory(google);
+                foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
+                {
+                    File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
+                }
 
-				Assert.AreEqual(0, Directory.GetFiles(TEMP, "*.cs").Length);
-				RunProtoGen(0, proto.TempPath, "-ignore_google_protobuf:true");
-				Assert.AreEqual(1, Directory.GetFiles(TEMP, "*.cs").Length);
+                Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length);
+                RunProtoGen(0, proto.TempPath, "-ignore_google_protobuf:true");
+                Assert.AreEqual(1, Directory.GetFiles(TempPath, "*.cs").Length);
 
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("MyNewNamespace." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithoutIgnoreGoogleProtobuf()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("MyNewNamespace." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithoutIgnoreGoogleProtobuf()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 import ""google/protobuf/csharp_options.proto"";
 option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace"";
-" + DEFAULT_PROTO))
-			{
-				string google = Path.Combine(TEMP, "google\\protobuf");
-				Directory.CreateDirectory(google);
-				foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
-					File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
+" + DefaultProto))
+            {
+                string google = Path.Combine(TempPath, "google\\protobuf");
+                Directory.CreateDirectory(google);
+                foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
+                {
+                    File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
+                }
 
-				Assert.AreEqual(0, Directory.GetFiles(TEMP, "*.cs").Length);
-				//Without the option this fails due to being unable to resolve google/protobuf descriptors
-				RunProtoGen(1, proto.TempPath, "-ignore_google_protobuf:false");
-			}
-		}
+                Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length);
+                //Without the option this fails due to being unable to resolve google/protobuf descriptors
+                RunProtoGen(1, proto.TempPath, "-ignore_google_protobuf:false");
+            }
+        }
 
-		// *******************************************************************
-		// The following tests excercise options for protoc.exe
-		// *******************************************************************
+        // *******************************************************************
+        // The following tests excercise options for protoc.exe
+        // *******************************************************************
 
-		[Test]
-		public void TestProtoFileWithIncludeImports()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+        [Test]
+        public void TestProtoFileWithIncludeImports()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 import ""google/protobuf/csharp_options.proto"";
 option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace"";
 
@@ -423,33 +431,35 @@ package nunit.simple;
 message MyMessage {
   optional string name = 1;
 } "))
-			{
-				string google = Path.Combine(TEMP, "google\\protobuf");
-				Directory.CreateDirectory(google);
-				foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
-					File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
+            {
+                string google = Path.Combine(TempPath, "google\\protobuf");
+                Directory.CreateDirectory(google);
+                foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
+                {
+                    File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
+                }
 
-				Assert.AreEqual(0, Directory.GetFiles(TEMP, "*.cs").Length);
-				//if you specify the protoc option --include_imports this should build three source files
-				RunProtoGen(0, proto.TempPath, "--include_imports");
-				Assert.AreEqual(3, Directory.GetFiles(TEMP, "*.cs").Length);
+                Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length);
+                //if you specify the protoc option --include_imports this should build three source files
+                RunProtoGen(0, proto.TempPath, "--include_imports");
+                Assert.AreEqual(3, Directory.GetFiles(TempPath, "*.cs").Length);
 
-				//you can (and should) simply omit the inclusion of the extra source files in your project
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("MyNewNamespace." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileWithIncludeImportsAndIgnoreGoogleProtobuf()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+                //you can (and should) simply omit the inclusion of the extra source files in your project
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("MyNewNamespace." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileWithIncludeImportsAndIgnoreGoogleProtobuf()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 import ""google/protobuf/csharp_options.proto"";
 option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace"";
 
@@ -458,143 +468,143 @@ package nunit.simple;
 message MyMessage {
   optional string name = 1;
 } "))
-			{
-				string google = Path.Combine(TEMP, "google\\protobuf");
-				Directory.CreateDirectory(google);
-				foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
-					File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
+            {
+                string google = Path.Combine(TempPath, "google\\protobuf");
+                Directory.CreateDirectory(google);
+                foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf")))
+                    File.Copy(file, Path.Combine(google, Path.GetFileName(file)));
 
-				Assert.AreEqual(0, Directory.GetFiles(TEMP, "*.cs").Length);
-				//Even with --include_imports, if you provide -ignore_google_protobuf:true you only get the one source file
-				RunProtoGen(0, proto.TempPath, "-ignore_google_protobuf:true", "--include_imports");
-				Assert.AreEqual(1, Directory.GetFiles(TEMP, "*.cs").Length);
+                Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length);
+                //Even with --include_imports, if you provide -ignore_google_protobuf:true you only get the one source file
+                RunProtoGen(0, proto.TempPath, "-ignore_google_protobuf:true", "--include_imports");
+                Assert.AreEqual(1, Directory.GetFiles(TempPath, "*.cs").Length);
 
-				//you can (and should) simply omit the inclusion of the extra source files in your project
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("MyNewNamespace." + test, true, true);
-			}
-		}
-		[Test]
-		public void TestProtoFileKeepingTheProtoBuffer()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile protobuf = TempFile.Attach(test + ".pb"))
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", @"
+                //you can (and should) simply omit the inclusion of the extra source files in your project
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("MyNewNamespace.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("MyNewNamespace." + test, true, true);
+            }
+        }
+        [Test]
+        public void TestProtoFileKeepingTheProtoBuffer()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile protobuf = TempFile.Attach(test + ".pb"))
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", @"
 package nunit.simple;
 // Test a very simple message.
 message MyMessage {
   optional string name = 1;
 } "))
-			{
-				RunProtoGen(0, proto.TempPath, "--descriptor_set_out=" + protobuf.TempPath);
-				Assert.IsTrue(File.Exists(protobuf.TempPath), "Missing: " + protobuf.TempPath);
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
-		//Seems the --proto_path or -I option is non-functional for me.  Maybe others have luck?
-		[Test, Ignore("http://code.google.com/p/protobuf/issues/detail?id=40")]
-		public void TestProtoFileInDifferentDirectory()
-		{
-			string test = new StackFrame(false).GetMethod().Name;
-			Setup();
-			using (TempFile source = TempFile.Attach(test + ".cs"))
-			using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO))
-			{
-				Environment.CurrentDirectory = OriginalWorkingDirectory;
-				RunProtoGen(0, proto.TempPath, "--proto_path=" + TEMP);
-				Assembly a = RunCsc(0, source.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple." + test, true, true);
-			}
-		}
+            {
+                RunProtoGen(0, proto.TempPath, "--descriptor_set_out=" + protobuf.TempPath);
+                Assert.IsTrue(File.Exists(protobuf.TempPath), "Missing: " + protobuf.TempPath);
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
+        //Seems the --proto_path or -I option is non-functional for me.  Maybe others have luck?
+        [Test, Ignore("http://code.google.com/p/protobuf/issues/detail?id=40")]
+        public void TestProtoFileInDifferentDirectory()
+        {
+            string test = new StackFrame(false).GetMethod().Name;
+            Setup();
+            using (TempFile source = TempFile.Attach(test + ".cs"))
+            using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto))
+            {
+                Environment.CurrentDirectory = OriginalWorkingDirectory;
+                RunProtoGen(0, proto.TempPath, "--proto_path=" + TempPath);
+                Assembly a = RunCsc(0, source.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple." + test, true, true);
+            }
+        }
 
-		// *******************************************************************
-		// Handling of mutliple input files
-		// *******************************************************************
+        // *******************************************************************
+        // Handling of mutliple input files
+        // *******************************************************************
 
-		[Test]
-		public void TestMultipleProtoFiles()
-		{
-			Setup();
-			using (TempFile source1 = TempFile.Attach("MyMessage.cs"))
-			using (ProtoFile proto1 = new ProtoFile("MyMessage.proto", @"
+        [Test]
+        public void TestMultipleProtoFiles()
+        {
+            Setup();
+            using (TempFile source1 = TempFile.Attach("MyMessage.cs"))
+            using (ProtoFile proto1 = new ProtoFile("MyMessage.proto", @"
 package nunit.simple;
 // Test a very simple message.
 message MyMessage {
   optional string name = 1;
 }"))
-			using (TempFile source2 = TempFile.Attach("MyMessageList.cs"))
-			using (ProtoFile proto2 = new ProtoFile("MyMessageList.proto", @"
+            using (TempFile source2 = TempFile.Attach("MyMessageList.cs"))
+            using (ProtoFile proto2 = new ProtoFile("MyMessageList.proto", @"
 package nunit.simple;
 import ""MyMessage.proto"";
 // Test a very simple message.
 message MyMessageList {
   repeated MyMessage messages = 1;
 }"))
-			{
-				RunProtoGen(0, proto1.TempPath, proto2.TempPath);
-				Assembly a = RunCsc(0, source1.TempPath, source2.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t1 = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage");
-				//assert that the message type is in the expected namespace
-				Type t2 = a.GetType("nunit.simple.MyMessageList", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple.Proto.MyMessage", true, true);
-				a.GetType("nunit.simple.Proto.MyMessageList", true, true);
-			}
-		}
-		[Test]
-		public void TestOneProtoFileWithBufferFile()
-		{
-			Setup();
-			using (TempFile source1 = TempFile.Attach("MyMessage.cs"))
-			using (TempFile protobuf = TempFile.Attach("MyMessage.pb"))
-			using (ProtoFile proto1 = new ProtoFile("MyMessage.proto", @"
+            {
+                RunProtoGen(0, proto1.TempPath, proto2.TempPath);
+                Assembly a = RunCsc(0, source1.TempPath, source2.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t1 = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage");
+                //assert that the message type is in the expected namespace
+                Type t2 = a.GetType("nunit.simple.MyMessageList", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple.Proto.MyMessage", true, true);
+                a.GetType("nunit.simple.Proto.MyMessageList", true, true);
+            }
+        }
+        [Test]
+        public void TestOneProtoFileWithBufferFile()
+        {
+            Setup();
+            using (TempFile source1 = TempFile.Attach("MyMessage.cs"))
+            using (TempFile protobuf = TempFile.Attach("MyMessage.pb"))
+            using (ProtoFile proto1 = new ProtoFile("MyMessage.proto", @"
 package nunit.simple;
 // Test a very simple message.
 message MyMessage {
   optional string name = 1;
 }"))
-			using (TempFile source2 = TempFile.Attach("MyMessageList.cs"))
-			using (ProtoFile proto2 = new ProtoFile("MyMessageList.proto", @"
+            using (TempFile source2 = TempFile.Attach("MyMessageList.cs"))
+            using (ProtoFile proto2 = new ProtoFile("MyMessageList.proto", @"
 package nunit.simple;
 import ""MyMessage.proto"";
 // Test a very simple message.
 message MyMessageList {
   repeated MyMessage messages = 1;
 }"))
-			{
-				//build the proto buffer for MyMessage
-				RunProtoGen(0, proto1.TempPath, "--descriptor_set_out=" + protobuf.TempPath);
-				//build the MyMessageList proto-buffer and generate code by including MyMessage.pb
-				RunProtoGen(0, proto2.TempPath, protobuf.TempPath);
-				Assembly a = RunCsc(0, source1.TempPath, source2.TempPath);
-				//assert that the message type is in the expected namespace
-				Type t1 = a.GetType("nunit.simple.MyMessage", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage");
-				//assert that the message type is in the expected namespace
-				Type t2 = a.GetType("nunit.simple.MyMessageList", true, true);
-				Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage");
-				//assert that we can find the static descriptor type
-				a.GetType("nunit.simple.Proto.MyMessage", true, true);
-				a.GetType("nunit.simple.Proto.MyMessageList", true, true);
-			}
-		}
-	}
+            {
+                //build the proto buffer for MyMessage
+                RunProtoGen(0, proto1.TempPath, "--descriptor_set_out=" + protobuf.TempPath);
+                //build the MyMessageList proto-buffer and generate code by including MyMessage.pb
+                RunProtoGen(0, proto2.TempPath, protobuf.TempPath);
+                Assembly a = RunCsc(0, source1.TempPath, source2.TempPath);
+                //assert that the message type is in the expected namespace
+                Type t1 = a.GetType("nunit.simple.MyMessage", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage");
+                //assert that the message type is in the expected namespace
+                Type t2 = a.GetType("nunit.simple.MyMessageList", true, true);
+                Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage");
+                //assert that we can find the static descriptor type
+                a.GetType("nunit.simple.Proto.MyMessage", true, true);
+                a.GetType("nunit.simple.Proto.MyMessageList", true, true);
+            }
+        }
+    }
 }
diff --git a/src/ProtoGen/DescriptorUtil.cs b/src/ProtoGen/DescriptorUtil.cs
index f485db6f..af5a2f9a 100644
--- a/src/ProtoGen/DescriptorUtil.cs
+++ b/src/ProtoGen/DescriptorUtil.cs
@@ -45,24 +45,25 @@ namespace Google.ProtocolBuffers.ProtoGen {
     internal static string GetFullUmbrellaClassName(IDescriptor descriptor) {
       CSharpFileOptions options = descriptor.File.CSharpOptions;
       string result = options.Namespace;
-      if (result != "") result += '.';
-	  result += QualifiedUmbrellaClassName(options);
+      if (result != "") {
+        result += '.';
+      }
+      result += GetQualifiedUmbrellaClassName(options);
       return "global::" + result;
     }
 
     /// <summary>
-    /// ROK 2010-09-03
     /// Evaluates the options and returns the qualified name of the umbrella class
-    /// relative to the descriptor type's namespace.  Basically contacts the
-	/// UmbrellaNamespace + UmbrellaClassname fields.
+    /// relative to the descriptor type's namespace.  Basically concatenates the
+    /// UmbrellaNamespace + UmbrellaClassname fields.
     /// </summary>
-	internal static string QualifiedUmbrellaClassName(CSharpFileOptions options)
-	{
-		string fullName = options.UmbrellaClassname;
-		if (!options.NestClasses && options.UmbrellaNamespace != "")
-			fullName = String.Format("{0}.{1}", options.UmbrellaNamespace, options.UmbrellaClassname);
-    	return fullName;
-	}
+    internal static string GetQualifiedUmbrellaClassName(CSharpFileOptions options) {
+      string fullName = options.UmbrellaClassname;
+      if (!options.NestClasses && options.UmbrellaNamespace != "") {
+        fullName = String.Format("{0}.{1}", options.UmbrellaNamespace, options.UmbrellaClassname);
+      }
+      return fullName;
+    }
 
     internal static string GetMappedTypeName(MappedType type) {
       switch(type) {
diff --git a/src/ProtoGen/Generator.cs b/src/ProtoGen/Generator.cs
index b2d4e23f..f588c141 100644
--- a/src/ProtoGen/Generator.cs
+++ b/src/ProtoGen/Generator.cs
@@ -60,30 +60,30 @@ namespace Google.ProtocolBuffers.ProtoGen {
     }
 
     public void Generate() {
-		
-	  List<FileDescriptorSet> descriptorProtos = new List<FileDescriptorSet>();
+        
+      List<FileDescriptorSet> descriptorProtos = new List<FileDescriptorSet>();
       foreach (string inputFile in options.InputFiles) {
         ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
         extensionRegistry.Add(CSharpOptions.CSharpFileOptions);
         extensionRegistry.Add(CSharpOptions.CSharpFieldOptions);
         using (Stream inputStream = File.OpenRead(inputFile)) {
-			descriptorProtos.Add(FileDescriptorSet.ParseFrom(inputStream, extensionRegistry));
+            descriptorProtos.Add(FileDescriptorSet.ParseFrom(inputStream, extensionRegistry));
         }
-	  }
+      }
       
-		IList<FileDescriptor> descriptors = ConvertDescriptors(options.FileOptions, descriptorProtos.ToArray());
+      IList<FileDescriptor> descriptors = ConvertDescriptors(options.FileOptions, descriptorProtos.ToArray());
 
-		//ROK Combine with Options...
-		foreach (FileDescriptor descriptor in descriptors)
-			descriptor.ConfigureWithDefaultOptions(options.FileOptions);
-
-        foreach (FileDescriptor descriptor in descriptors) {
-			//ROK 2010-09-03 Ignore google protobuf package
-			if(descriptor.CSharpOptions.IgnoreGoogleProtobuf && descriptor.Package == "google.protobuf")
-				continue;
+      // Combine with options from command line
+      foreach (FileDescriptor descriptor in descriptors) {
+        descriptor.ConfigureWithDefaultOptions(options.FileOptions);
+      }
 
-          Generate(descriptor);
-        
+      foreach (FileDescriptor descriptor in descriptors) {
+        // Optionally exclude descriptors in google.protobuf
+        if (descriptor.CSharpOptions.IgnoreGoogleProtobuf && descriptor.Package == "google.protobuf") {
+          continue;
+        }
+        Generate(descriptor);
       }
     }
 
@@ -102,13 +102,9 @@ namespace Google.ProtocolBuffers.ProtoGen {
     private string GetOutputFile(FileDescriptor descriptor) {
       CSharpFileOptions fileOptions = descriptor.CSharpOptions;
 
-	  //ROK 2010-09-03 - added the ability to sepcify the extension used within the options
-	  //string filename = descriptor.CSharpOptions.UmbrellaClassname + ".cs";
-	  string filename = descriptor.CSharpOptions.UmbrellaClassname + descriptor.CSharpOptions.FileExtension;
+      string filename = descriptor.CSharpOptions.UmbrellaClassname + descriptor.CSharpOptions.FileExtension;
 
-	  //ROK 2010-09-03 - output directory can be specific to a descriptor file
-	  //string outputDirectory = options.OutputDirectory;
-	  string outputDirectory = descriptor.CSharpOptions.OutputDirectory;
+      string outputDirectory = descriptor.CSharpOptions.OutputDirectory;
       if (fileOptions.ExpandNamespaceDirectories) {
         string package = fileOptions.Namespace;
         if (!string.IsNullOrEmpty(package)) {
@@ -117,29 +113,25 @@ namespace Google.ProtocolBuffers.ProtoGen {
             outputDirectory = Path.Combine(outputDirectory, bit);
           }
         }
-	  }
-	  //ROK 2010-09-03 - Always force output directory exists since they can specify this in .proto options
-	  Directory.CreateDirectory(outputDirectory);
+      }
+      
+      // As the directory can be explicitly specified in options, we need to make sure it exists
+      Directory.CreateDirectory(outputDirectory);
       return Path.Combine(outputDirectory, filename);
     }
 
-    // ROK 2010-09-03 - used by unit tests, we will continue to allow them to function as-is.
-	internal static IList<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos) {
-		return ConvertDescriptors(CSharpFileOptions.DefaultInstance, descriptorProtos);
-    }
-
     /// <summary>
     /// Resolves any dependencies and converts FileDescriptorProtos into FileDescriptors.
     /// The list returned is in the same order as the protos are listed in the descriptor set.
     /// Note: this method is internal rather than private to allow testing.
     /// </summary>
     /// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception>
-    private static IList<FileDescriptor> ConvertDescriptors(CSharpFileOptions options, params FileDescriptorSet[] descriptorProtos) {
+    internal static IList<FileDescriptor> ConvertDescriptors(CSharpFileOptions options, params FileDescriptorSet[] descriptorProtos) {
       // Simple strategy: Keep going through the list of protos to convert, only doing ones where
       // we've already converted all the dependencies, until we get to a stalemate
       List<FileDescriptorProto> fileList = new List<FileDescriptorProto>();
-	  foreach (FileDescriptorSet set in descriptorProtos)
-	    fileList.AddRange(set.FileList);
+      foreach (FileDescriptorSet set in descriptorProtos)
+        fileList.AddRange(set.FileList);
 
       FileDescriptor[] converted = new FileDescriptor[fileList.Count];
 
@@ -158,31 +150,28 @@ namespace Google.ProtocolBuffers.ProtoGen {
           FileDescriptorProto candidate = fileList[i];
           FileDescriptor[] dependencies = new FileDescriptor[candidate.DependencyList.Count];
 
-			
-		  CSharpFileOptions.Builder builder = options.ToBuilder();
-		  if (candidate.Options.HasExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions)) {
-			builder.MergeFrom(candidate.Options.GetExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions));
-		  }
+            
+          CSharpFileOptions.Builder builder = options.ToBuilder();
+          if (candidate.Options.HasExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions)) {
+            builder.MergeFrom(candidate.Options.GetExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions));
+          }
           CSharpFileOptions localOptions = builder.Build();
 
           bool foundAllDependencies = true;
           for (int j = 0; j < dependencies.Length; j++) {
             if (!convertedMap.TryGetValue(candidate.DependencyList[j], out dependencies[j])) {
-
-				// ROK 2010-09-03 - we can auto-magically resolve these since we already have their description
-				// This way if the file is only referencing options it does not need to be built with the
-				// --include_imports definition.
-				if (localOptions.IgnoreGoogleProtobuf && (candidate.DependencyList[j] == "google/protobuf/csharp_options.proto"))
-				{
-					dependencies[j] = CSharpOptions.Descriptor;
-					continue;
-				}
-				if (localOptions.IgnoreGoogleProtobuf && (candidate.DependencyList[j] == "google/protobuf/descriptor.proto"))
-				{
-					dependencies[j] = DescriptorProtoFile.Descriptor;
-					continue;
-				}
-            	foundAllDependencies = false;
+              // We can auto-magically resolve these since we already have their description
+              // This way if the file is only referencing options it does not need to be built with the
+              // --include_imports definition.
+              if (localOptions.IgnoreGoogleProtobuf && (candidate.DependencyList[j] == "google/protobuf/csharp_options.proto")) {
+                dependencies[j] = CSharpOptions.Descriptor;
+                continue;
+              }
+              if (localOptions.IgnoreGoogleProtobuf && (candidate.DependencyList[j] == "google/protobuf/descriptor.proto")) {
+                dependencies[j] = DescriptorProtoFile.Descriptor;
+                continue;
+              }
+              foundAllDependencies = false;
               break;
             }
           }
diff --git a/src/ProtoGen/GeneratorOptions.cs b/src/ProtoGen/GeneratorOptions.cs
index 53c65a40..8781c5ec 100644
--- a/src/ProtoGen/GeneratorOptions.cs
+++ b/src/ProtoGen/GeneratorOptions.cs
@@ -1,4 +1,5 @@
 #region Copyright notice and license
+
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // http://github.com/jskeet/dotnet-protobufs/
@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 #endregion
 
 using System;
@@ -40,7 +42,6 @@ using Google.ProtocolBuffers.DescriptorProtos;
 using Google.ProtocolBuffers.Descriptors;
 
 namespace Google.ProtocolBuffers.ProtoGen {
-
   /// <summary>
   /// All the configuration required for the generator - where to generate
   /// output files, the location of input files etc. While this isn't immutable
@@ -48,7 +49,6 @@ namespace Google.ProtocolBuffers.ProtoGen {
   /// the generator.
   /// </summary>
   public sealed class GeneratorOptions {
-	//ROK, see below - public string OutputDirectory  { get; set; }
     public IList<string> InputFiles { get; set; }
 
     /// <summary>
@@ -61,13 +61,13 @@ namespace Google.ProtocolBuffers.ProtoGen {
     public bool TryValidate(out IList<string> reasons) {
       List<string> tmpReasons = new List<string>();
 
-	  //ROK 2010-09-03 see population of options below
-	  ParseArguments(tmpReasons);
+      ParseArguments(tmpReasons);
 
       // Output directory validation
       if (string.IsNullOrEmpty(FileOptions.OutputDirectory)) {
         tmpReasons.Add("No output directory specified");
-      } else {
+      }
+      else {
         if (!Directory.Exists(FileOptions.OutputDirectory)) {
           tmpReasons.Add("Specified output directory (" + FileOptions.OutputDirectory + " doesn't exist.");
         }
@@ -76,7 +76,8 @@ namespace Google.ProtocolBuffers.ProtoGen {
       // Input file validation (just in terms of presence)
       if (InputFiles == null || InputFiles.Count == 0) {
         tmpReasons.Add("No input files specified");
-      } else {
+      }
+      else {
         foreach (string input in InputFiles) {
           FileInfo fi = new FileInfo(input);
           if (!fi.Exists) {
@@ -106,178 +107,160 @@ namespace Google.ProtocolBuffers.ProtoGen {
       }
     }
 
+    // Raw arguments, used to provide defaults for proto file options
+    public IList<string> Arguments { get; set; }
+
+    [Obsolete("Please use GeneratorOptions.FileOptions.OutputDirectory instead")]
+    public string OutputDirectory {
+      get { return FileOptions.OutputDirectory; }
+      set {
+        CSharpFileOptions.Builder bld = FileOptions.ToBuilder();
+        bld.OutputDirectory = value;
+        FileOptions = bld.Build();
+      }
+    }
+
+    private static readonly Regex ArgMatch = new Regex(@"^[-/](?<name>[\w_]+?)[:=](?<value>.*)$");
+    private CSharpFileOptions fileOptions;
 
+    public CSharpFileOptions FileOptions {
+      get { return fileOptions ?? (fileOptions = CSharpFileOptions.DefaultInstance); }
+      set { fileOptions = value; }
+    }
+
+    private void ParseArguments(IList<string> tmpReasons) {
+      bool doHelp = Arguments.Count == 0;
 
-	// ROK - added to provide defaults for any of the options
-	//Raw arguments
-	public IList<string> Arguments { get; set; }
-	[Obsolete("Please use GeneratorOptions.FileOptions.OutputDirectory instead")]
-  	public string OutputDirectory
-  	{
-  		get {
-			return FileOptions.OutputDirectory;
-  		}
-  		set {
-			CSharpFileOptions.Builder bld = FileOptions.ToBuilder();
-			bld.OutputDirectory = value;
-			FileOptions = bld.Build();
-  		}
-  	}
-
-	private static readonly Regex ArgMatch = new Regex(@"^[-/](?<name>[\w_]+?)[:=](?<value>.*)$");
-	CSharpFileOptions _fileOptions;
-	public CSharpFileOptions FileOptions
-	{
-		get { return _fileOptions ?? (_fileOptions = CSharpFileOptions.DefaultInstance); }
-		set { _fileOptions = value; }
-	}
-
-	private void ParseArguments(IList<string> tmpReasons)
-	{
-		bool doHelp = Arguments.Count == 0;
-
-		//ROK Parse the raw arguments
-		InputFiles = new List<string>();
-		CSharpFileOptions.Builder builder = FileOptions.ToBuilder();
-		Dictionary<string, FieldDescriptor> fields =
-			new Dictionary<string, FieldDescriptor>(StringComparer.OrdinalIgnoreCase);
-		foreach (FieldDescriptor fld in builder.DescriptorForType.Fields)
-			fields.Add(fld.Name, fld);
-
-		foreach (string argument in Arguments)
-		{
-			if (StringComparer.OrdinalIgnoreCase.Equals("-help", argument) ||
-				StringComparer.OrdinalIgnoreCase.Equals("/help", argument) ||
-				StringComparer.OrdinalIgnoreCase.Equals("-?", argument) ||
-				StringComparer.OrdinalIgnoreCase.Equals("/?", argument))
-			{
-				doHelp = true;
-				break;
-			}
-
-			Match m = ArgMatch.Match(argument);
-			if (m.Success)
-			{
-				FieldDescriptor fld;
-				string name = m.Groups["name"].Value;
-				string value = m.Groups["value"].Value;
-
-				if (fields.TryGetValue(name, out fld))
-				{
-					object obj;
-					if (TryCoerceType(value, fld, out obj, tmpReasons))
-						builder[fld] = obj;
-				}
-				else if (!File.Exists(argument))
-				{
-					doHelp = true;
-					tmpReasons.Add("Unknown argument '" + name + "'.");
-				}
-				else
-					InputFiles.Add(argument);
-			}
-			else
-				InputFiles.Add(argument);
-		}
-
-		if (doHelp || InputFiles.Count == 0)
-		{
-			tmpReasons.Add("Arguments:");
-			foreach (KeyValuePair<string, FieldDescriptor> field in fields)
-			{
-				tmpReasons.Add(String.Format("-{0}=[{1}]", field.Key, field.Value.FieldType));
-			}
-			tmpReasons.Add("followed by one or more file paths.");
-		}
-		else
-			FileOptions = builder.Build();
-	}
-
-	private static bool TryCoerceType(string text, FieldDescriptor field, out object value, IList<string> tmpReasons)
-	{
-		value = null;
-
-		switch (field.FieldType)
-		{
-			case FieldType.Int32:
-			case FieldType.SInt32:
-			case FieldType.SFixed32:
-				value = Int32.Parse(text);
-				break;
-
-			case FieldType.Int64:
-			case FieldType.SInt64:
-			case FieldType.SFixed64:
-				value = Int64.Parse(text);
-				break;
-
-			case FieldType.UInt32:
-			case FieldType.Fixed32:
-				value = UInt32.Parse(text);
-				break;
-
-			case FieldType.UInt64:
-			case FieldType.Fixed64:
-				value = UInt64.Parse(text);
-				break;
-
-			case FieldType.Float:
-				value = float.Parse(text);
-				break;
-
-			case FieldType.Double:
-				value = Double.Parse(text);
-				break;
-
-			case FieldType.Bool:
-				value = Boolean.Parse(text);
-				break;
-
-			case FieldType.String:
-				value = text;
-				break;
-
-			case FieldType.Enum:
-				{
-
-					EnumDescriptor enumType = field.EnumType;
-
-					int number;
-					if (int.TryParse(text, out number))
-					{
-						value = enumType.FindValueByNumber(number);
-						if (value == null)
-						{
-							tmpReasons.Add(
-								"Enum type \"" + enumType.FullName +
-								"\" has no value with number " + number + ".");
-							return false;
-						}
-					}
-					else
-					{
-						value = enumType.FindValueByName(text);
-						if (value == null)
-						{
-							tmpReasons.Add(
-								"Enum type \"" + enumType.FullName +
-								"\" has no value named \"" + text + "\".");
-							return false;
-						}
-					}
-
-					break;
-				}
-
-			case FieldType.Bytes:
-			case FieldType.Message:
-			case FieldType.Group:
-				tmpReasons.Add("Unhandled field type " + field.FieldType.ToString() + ".");
-				return false;
-		}
-
-		return true;
-	}
+      InputFiles = new List<string>();
+      CSharpFileOptions.Builder builder = FileOptions.ToBuilder();
+      Dictionary<string, FieldDescriptor> fields =
+        new Dictionary<string, FieldDescriptor>(StringComparer.OrdinalIgnoreCase);
+      foreach (FieldDescriptor fld in builder.DescriptorForType.Fields) {
+        fields.Add(fld.Name, fld);
+      }
+
+      foreach (string argument in Arguments) {
+        if (StringComparer.OrdinalIgnoreCase.Equals("-help", argument) ||
+            StringComparer.OrdinalIgnoreCase.Equals("/help", argument) ||
+            StringComparer.OrdinalIgnoreCase.Equals("-?", argument) ||
+            StringComparer.OrdinalIgnoreCase.Equals("/?", argument)) {
+          doHelp = true;
+          break;
+        }
 
+        Match m = ArgMatch.Match(argument);
+        if (m.Success) {
+          FieldDescriptor fld;
+          string name = m.Groups["name"].Value;
+          string value = m.Groups["value"].Value;
+
+          if (fields.TryGetValue(name, out fld)) {
+            object obj;
+            if (TryCoerceType(value, fld, out obj, tmpReasons)) {
+              builder[fld] = obj;
+            }
+          }
+          else if (!File.Exists(argument)) {
+            doHelp = true;
+            tmpReasons.Add("Unknown argument '" + name + "'.");
+          }
+          else {
+            InputFiles.Add(argument);
+          }
+        }
+        else {
+          InputFiles.Add(argument);
+        }
+      }
+
+      if (doHelp || InputFiles.Count == 0) {
+        tmpReasons.Add("Arguments:");
+        foreach (KeyValuePair<string, FieldDescriptor> field in fields) {
+          tmpReasons.Add(String.Format("-{0}=[{1}]", field.Key, field.Value.FieldType));
+        }
+        tmpReasons.Add("followed by one or more file paths.");
+      }
+      else {
+        FileOptions = builder.Build();
+      }
+    }
+
+    private static bool TryCoerceType(string text, FieldDescriptor field, out object value, IList<string> tmpReasons) {
+      value = null;
+
+      switch (field.FieldType) {
+        case FieldType.Int32:
+        case FieldType.SInt32:
+        case FieldType.SFixed32:
+          value = Int32.Parse(text);
+          break;
+
+        case FieldType.Int64:
+        case FieldType.SInt64:
+        case FieldType.SFixed64:
+          value = Int64.Parse(text);
+          break;
+
+        case FieldType.UInt32:
+        case FieldType.Fixed32:
+          value = UInt32.Parse(text);
+          break;
+
+        case FieldType.UInt64:
+        case FieldType.Fixed64:
+          value = UInt64.Parse(text);
+          break;
+
+        case FieldType.Float:
+          value = float.Parse(text);
+          break;
+
+        case FieldType.Double:
+          value = Double.Parse(text);
+          break;
+
+        case FieldType.Bool:
+          value = Boolean.Parse(text);
+          break;
+
+        case FieldType.String:
+          value = text;
+          break;
+
+        case FieldType.Enum: {
+          EnumDescriptor enumType = field.EnumType;
+
+          int number;
+          if (int.TryParse(text, out number)) {
+            value = enumType.FindValueByNumber(number);
+            if (value == null) {
+              tmpReasons.Add(
+                "Enum type \"" + enumType.FullName +
+                "\" has no value with number " + number + ".");
+              return false;
+            }
+          }
+          else {
+            value = enumType.FindValueByName(text);
+            if (value == null) {
+              tmpReasons.Add(
+                "Enum type \"" + enumType.FullName +
+                "\" has no value named \"" + text + "\".");
+              return false;
+            }
+          }
+
+          break;
+        }
+
+        case FieldType.Bytes:
+        case FieldType.Message:
+        case FieldType.Group:
+          tmpReasons.Add("Unhandled field type " + field.FieldType.ToString() + ".");
+          return false;
+      }
+
+      return true;
+    }
   }
-}
+}
\ No newline at end of file
diff --git a/src/ProtoGen/Program.cs b/src/ProtoGen/Program.cs
index a9bc47ce..e8c486cf 100644
--- a/src/ProtoGen/Program.cs
+++ b/src/ProtoGen/Program.cs
@@ -1,4 +1,5 @@
 #region Copyright notice and license
+
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // http://github.com/jskeet/dotnet-protobufs/
@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 #endregion
 
 using System;
@@ -40,12 +42,12 @@ namespace Google.ProtocolBuffers.ProtoGen {
   /// <summary>
   /// Entry point for the Protocol Buffers generator.
   /// </summary>
-  class Program {
-  	internal static int Main(string[] args) {
+  internal class Program {
+    internal static int Main(string[] args) {
       try {
         // Hack to make sure everything's initialized
         DescriptorProtoFile.Descriptor.ToString();
-        GeneratorOptions options = ParseCommandLineArguments(args);
+        GeneratorOptions options = new GeneratorOptions {Arguments = args};
 
         IList<string> validationFailures;
         if (!options.TryValidate(out validationFailures)) {
@@ -58,25 +60,13 @@ namespace Google.ProtocolBuffers.ProtoGen {
         Generator generator = Generator.CreateGenerator(options);
         generator.Generate();
         return 0;
-      } catch (Exception e) {
+      }
+      catch (Exception e) {
         Console.Error.WriteLine("Error: {0}", e.Message);
         Console.Error.WriteLine();
         Console.Error.WriteLine("Detailed exception information: {0}", e);
         return 1;
       }
     }
-
-    private static GeneratorOptions ParseCommandLineArguments(string[] args) {
-      GeneratorOptions options = new GeneratorOptions();
-      //string baseDir = "c:\\Users\\Jon\\Documents\\Visual Studio 2008\\Projects\\ProtocolBuffers";
-      //options.OutputDirectory = baseDir + "\\tmp";
-      //options.InputFiles = new[] { baseDir + "\\protos\\nwind-solo.protobin" };
-
-	  //ROK 2010-09-03 - fixes to allow parsing these options...
-      //options.OutputDirectory = ".";
-	  //options.InputFiles = args;
-      options.Arguments = args;
-      return options;
-    }
   }
 }
\ No newline at end of file
diff --git a/src/ProtoGen/ProgramPreprocess.cs b/src/ProtoGen/ProgramPreprocess.cs
index 2081b016..f6032a54 100644
--- a/src/ProtoGen/ProgramPreprocess.cs
+++ b/src/ProtoGen/ProgramPreprocess.cs
@@ -3,148 +3,151 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 
-namespace Google.ProtocolBuffers.ProtoGen
-{
-	/// <summary>
-	/// Preprocesses any input files with an extension of '.proto' by running protoc.exe.  If arguments
-	/// are supplied with '--' prefix they are provided to protoc.exe, otherwise they are assumed to
-	/// be used for ProtoGen.exe which is run on the resulting output proto buffer.  If the option
-	/// --descriptor_set_out= is specified the proto buffer file is kept, otherwise it will be removed
-	/// after code generation.
-	/// </summary>
-    internal class ProgramPreprocess
-    {
-        static int Main(string[] args)
-        {
-            try
-			{
-				return Environment.ExitCode = Run(args);
-			}
-			catch (Exception ex)
-			{
-				Console.Error.WriteLine(ex);
-				return Environment.ExitCode = 2;
-			}
+namespace Google.ProtocolBuffers.ProtoGen {
+  /// <summary>
+  /// Preprocesses any input files with an extension of '.proto' by running protoc.exe.  If arguments
+  /// are supplied with '--' prefix they are provided to protoc.exe, otherwise they are assumed to
+  /// be used for ProtoGen.exe which is run on the resulting output proto buffer.  If the option
+  /// --descriptor_set_out= is specified the proto buffer file is kept, otherwise it will be removed
+  /// after code generation.
+  /// </summary>
+  internal class ProgramPreprocess {
+    private static int Main(string[] args) {
+      try {
+        return Environment.ExitCode = Run(args);
+      }
+      catch (Exception ex) {
+        Console.Error.WriteLine(ex);
+        return Environment.ExitCode = 2;
+      }
+    }
+
+    internal static int Run(params string[] args) {
+      bool deleteFile = false;
+      string tempFile = null;
+      int result;
+      bool doHelp = args.Length == 0;
+      try {
+        List<string> protocArgs = new List<string>();
+        List<string> protoGenArgs = new List<string>();
+
+        foreach (string arg in args) {
+          doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "/?");
+          doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "/help");
+          doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "-?");
+          doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "-help");
+
+          if (arg.StartsWith("--descriptor_set_out=")) {
+            tempFile = arg.Substring("--descriptor_set_out=".Length);
+            protoGenArgs.Add(tempFile);
+          }
         }
-		
-		internal static int Run(params string[] args)
-		{
-			bool deleteFile = false;
-            string tempFile = null;
-            int result = 1;
-        	bool doHelp = args.Length == 0;
-            try
-            {
-                List<string> protocArgs = new List<string>();
-                List<string> protoGenArgs = new List<string>();
-
-                foreach (string arg in args)
-				{
-					doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "/?");
-					doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "/help");
-					doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "-?");
-					doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "-help");
-
-                    if(arg.StartsWith("--descriptor_set_out="))
-                    {
-                        tempFile = arg.Substring("--descriptor_set_out=".Length);
-                        protoGenArgs.Add(tempFile);
-                    }
-                }
-
-				if (doHelp)
-				{
-					Console.WriteLine();
-					Console.WriteLine("PROTOC.exe: Use any of the following options that begin with '--':");
-					Console.WriteLine();
-					try { RunProtoc("--help"); }
-					catch (Exception ex) { Console.Error.WriteLine(ex.Message); }
-					Console.WriteLine();
-					Console.WriteLine();
-					Console.WriteLine("PRTOGEN.exe: The following options are used to specify defaults for code generation.");
-					Console.WriteLine();
-					Program.Main(new string[0]);
-					return 0;
-				}
-
-				foreach (string arg in args)
-				{
-					if (arg.StartsWith("--"))
-						protocArgs.Add(arg);
-					else if (File.Exists(arg) && StringComparer.OrdinalIgnoreCase.Equals(".proto", Path.GetExtension(arg)))
-					{
-						if (tempFile == null)
-						{
-							deleteFile = true;
-							tempFile = Path.GetTempFileName();
-							protocArgs.Add(String.Format("--descriptor_set_out={0}", tempFile));
-							protoGenArgs.Add(tempFile);
-						}
-						protocArgs.Add(arg);
-					}
-					else
-						protoGenArgs.Add(arg);
-				}
-
-            	if (tempFile != null)
-                {
-                    result = RunProtoc(protocArgs.ToArray());
-                    if (result != 0)
-                        return result;
-                }
-
-                result = Program.Main(protoGenArgs.ToArray());
-            }
-            finally
-            {
-                if (deleteFile && tempFile != null && File.Exists(tempFile))
-                    File.Delete(tempFile);
+
+        if (doHelp) {
+          Console.WriteLine();
+          Console.WriteLine("PROTOC.exe: Use any of the following options that begin with '--':");
+          Console.WriteLine();
+          try {
+            RunProtoc("--help");
+          }
+          catch (Exception ex) {
+            Console.Error.WriteLine(ex.Message);
+          }
+          Console.WriteLine();
+          Console.WriteLine();
+          Console.WriteLine("PRTOGEN.exe: The following options are used to specify defaults for code generation.");
+          Console.WriteLine();
+          Program.Main(new string[0]);
+          return 0;
+        }
+
+        foreach (string arg in args) {
+          if (arg.StartsWith("--")) {
+            protocArgs.Add(arg);
+          }
+          else if (File.Exists(arg) && StringComparer.OrdinalIgnoreCase.Equals(".proto", Path.GetExtension(arg))) {
+            if (tempFile == null) {
+              deleteFile = true;
+              tempFile = Path.GetTempFileName();
+              protocArgs.Add(String.Format("--descriptor_set_out={0}", tempFile));
+              protoGenArgs.Add(tempFile);
             }
+            protocArgs.Add(arg);
+          }
+          else {
+            protoGenArgs.Add(arg);
+          }
+        }
+
+        if (tempFile != null) {
+          result = RunProtoc(protocArgs.ToArray());
+          if (result != 0) {
             return result;
+          }
         }
 
-        private static int RunProtoc(params string[] args)
-        {
-            const string protoc = "protoc.exe";
-            string exePath = protoc;
-
-            //why oh why is this not in System.IO.Path or Environment...
-            List<string> searchPath = new List<string>();
-            searchPath.Add(Environment.CurrentDirectory);
-            searchPath.Add(AppDomain.CurrentDomain.BaseDirectory);
-            searchPath.AddRange((Environment.GetEnvironmentVariable("PATH") ?? String.Empty).Split(Path.PathSeparator));
-
-            foreach (string path in searchPath)
-                if (File.Exists(exePath = Path.Combine(path, protoc)))
-                    break;
-
-            if (!File.Exists(exePath))
-                throw new FileNotFoundException("Unable to locate " + protoc + " make sure it is in the PATH, cwd, or exe dir.");
-
-            for (int i = 0; i < args.Length; i++)
-                if (args[i].IndexOf(' ') > 0 && args[i][0] != '"')
-                    args[i] = '"' + args[i] + '"';
-
-            ProcessStartInfo psi = new ProcessStartInfo(exePath);
-            psi.Arguments = String.Join(" ", args);
-            psi.RedirectStandardError = true;
-            psi.RedirectStandardInput = false;
-            psi.RedirectStandardOutput = true;
-            psi.ErrorDialog = false;
-            psi.CreateNoWindow = true;
-            psi.UseShellExecute = false;
-            psi.WorkingDirectory = Environment.CurrentDirectory;
-
-            Process process = Process.Start(psi);
-            if (process == null) return 1;
-
-            process.WaitForExit();
-
-        	string tmp = process.StandardOutput.ReadToEnd();
-			if(tmp.Trim().Length > 0) Console.Out.WriteLine(tmp);
-			tmp = process.StandardError.ReadToEnd();
-			if (tmp.Trim().Length > 0) Console.Error.WriteLine(tmp);
-            return process.ExitCode;
+        result = Program.Main(protoGenArgs.ToArray());
+      }
+      finally {
+        if (deleteFile && tempFile != null && File.Exists(tempFile)) {
+          File.Delete(tempFile);
+        }
+      }
+      return result;
+    }
+
+    private static int RunProtoc(params string[] args) {
+      const string protoc = "protoc.exe";
+      string exePath = protoc;
+
+      // Why oh why is this not in System.IO.Path or Environment...?
+      List<string> searchPath = new List<string>();
+      searchPath.Add(Environment.CurrentDirectory);
+      searchPath.Add(AppDomain.CurrentDomain.BaseDirectory);
+      searchPath.AddRange((Environment.GetEnvironmentVariable("PATH") ?? String.Empty).Split(Path.PathSeparator));
+
+      foreach (string path in searchPath) {
+        if (File.Exists(exePath = Path.Combine(path, protoc))) {
+          break;
+        }
+      }
+
+      if (!File.Exists(exePath)) {
+        throw new FileNotFoundException("Unable to locate " + protoc + " make sure it is in the PATH, cwd, or exe dir.");
+      }
+
+      for (int i = 0; i < args.Length; i++) {
+        if (args[i].IndexOf(' ') > 0 && args[i][0] != '"') {
+          args[i] = '"' + args[i] + '"';
         }
+      }
+
+      ProcessStartInfo psi = new ProcessStartInfo(exePath);
+      psi.Arguments = String.Join(" ", args);
+      psi.RedirectStandardError = true;
+      psi.RedirectStandardInput = false;
+      psi.RedirectStandardOutput = true;
+      psi.ErrorDialog = false;
+      psi.CreateNoWindow = true;
+      psi.UseShellExecute = false;
+      psi.WorkingDirectory = Environment.CurrentDirectory;
+
+      Process process = Process.Start(psi);
+      if (process == null) {
+        return 1;
+      }
+
+      process.WaitForExit();
+
+      string tmp = process.StandardOutput.ReadToEnd();
+      if (tmp.Trim().Length > 0) {
+        Console.Out.WriteLine(tmp);
+      }
+      tmp = process.StandardError.ReadToEnd();
+      if (tmp.Trim().Length > 0) {
+        Console.Error.WriteLine(tmp);
+      }
+      return process.ExitCode;
     }
+  }
 }
diff --git a/src/ProtoGen/ServiceGenerator.cs b/src/ProtoGen/ServiceGenerator.cs
index 83d8a6a3..03d2f120 100644
--- a/src/ProtoGen/ServiceGenerator.cs
+++ b/src/ProtoGen/ServiceGenerator.cs
@@ -61,7 +61,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
       writer.WriteLine();
       writer.WriteLine("{0} static pbd::ServiceDescriptor Descriptor {{", ClassAccessLevel);
       writer.WriteLine("  get {{ return {0}.Descriptor.Services[{1}]; }}",
-        DescriptorUtil.QualifiedUmbrellaClassName(Descriptor.File.CSharpOptions), Descriptor.Index);
+        DescriptorUtil.GetQualifiedUmbrellaClassName(Descriptor.File.CSharpOptions), Descriptor.Index);
       writer.WriteLine("}");
       writer.WriteLine("{0} pbd::ServiceDescriptor DescriptorForType {{", ClassAccessLevel);
       writer.WriteLine("  get { return Descriptor; }");
diff --git a/src/ProtoGen/UmbrellaClassGenerator.cs b/src/ProtoGen/UmbrellaClassGenerator.cs
index d596f1a1..cdc275c6 100644
--- a/src/ProtoGen/UmbrellaClassGenerator.cs
+++ b/src/ProtoGen/UmbrellaClassGenerator.cs
@@ -93,12 +93,12 @@ namespace Google.ProtocolBuffers.ProtoGen {
         writer.Outdent();
         writer.WriteLine("}");
 
-		//ROK 2010-09-03 - close the namespace around the umbrella class if defined
-		if (!Descriptor.CSharpOptions.NestClasses && Descriptor.CSharpOptions.UmbrellaNamespace != "") {
-			writer.Outdent();
-			writer.WriteLine("}");
-		}
-	  }
+        // Close the namespace around the umbrella class if defined
+        if (!Descriptor.CSharpOptions.NestClasses && Descriptor.CSharpOptions.UmbrellaNamespace != "") {
+          writer.Outdent();
+          writer.WriteLine("}");
+        }
+      }
       WriteChildren(writer, "Enums", Descriptor.EnumTypes);
       WriteChildren(writer, "Messages", Descriptor.MessageTypes);
       WriteChildren(writer, "Services", Descriptor.Services);
@@ -122,12 +122,12 @@ namespace Google.ProtocolBuffers.ProtoGen {
         writer.Indent();
         writer.WriteLine();
       }
-	  //ROK 2010-09-03 - add the namespace around the umbrella class if defined
-	  if(!Descriptor.CSharpOptions.NestClasses && Descriptor.CSharpOptions.UmbrellaNamespace != "") {
+      // Add the namespace around the umbrella class if defined
+      if(!Descriptor.CSharpOptions.NestClasses && Descriptor.CSharpOptions.UmbrellaNamespace != "") {
         writer.WriteLine("namespace {0} {{", Descriptor.CSharpOptions.UmbrellaNamespace);
         writer.Indent();
         writer.WriteLine();
-	  }
+      }
     
       if (Descriptor.CSharpOptions.CodeContracts) {
           writer.WriteLine("[global::System.Diagnostics.Contracts.ContractVerificationAttribute(false)]");
diff --git a/src/ProtocolBuffers.Test/DynamicMessageTest.cs b/src/ProtocolBuffers.Test/DynamicMessageTest.cs
index 6a93f450..e2971692 100644
--- a/src/ProtocolBuffers.Test/DynamicMessageTest.cs
+++ b/src/ProtocolBuffers.Test/DynamicMessageTest.cs
@@ -76,7 +76,7 @@ namespace Google.ProtocolBuffers {
     public void DynamicMessageSettersRejectNull() {
       IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
       reflectionTester.AssertReflectionSettersRejectNull(builder);
-	  }
+      }
 
     [Test]
     public void DynamicMessageExtensionAccessors() {
@@ -93,7 +93,7 @@ namespace Google.ProtocolBuffers {
     public void DynamicMessageExtensionSettersRejectNull() {
       IBuilder builder = DynamicMessage.CreateBuilder(TestAllExtensions.Descriptor);
       extensionsReflectionTester.AssertReflectionSettersRejectNull(builder);
-	  }
+      }
 
     [Test]
     public void DynamicMessageRepeatedSetters() {
diff --git a/src/ProtocolBuffers/Descriptors/FileDescriptor.cs b/src/ProtocolBuffers/Descriptors/FileDescriptor.cs
index be4a054f..f1eba496 100644
--- a/src/ProtocolBuffers/Descriptors/FileDescriptor.cs
+++ b/src/ProtocolBuffers/Descriptors/FileDescriptor.cs
@@ -32,17 +32,17 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.IO;
 using Google.ProtocolBuffers.DescriptorProtos;
+using FileOptions = Google.ProtocolBuffers.DescriptorProtos.FileOptions;
 
 namespace Google.ProtocolBuffers.Descriptors {
-
   /// <summary>
   /// Describes a .proto file, including everything defined within.
   /// IDescriptor is implemented such that the File property returns this descriptor,
   /// and the FullName is the same as the Name.
   /// </summary>
   public sealed class FileDescriptor : IDescriptor<FileDescriptorProto> {
-
     private FileDescriptorProto proto;
     private readonly IList<MessageDescriptor> messageTypes;
     private readonly IList<EnumDescriptor> enumTypes;
@@ -52,7 +52,7 @@ namespace Google.ProtocolBuffers.Descriptors {
     private readonly DescriptorPool pool;
     private CSharpFileOptions csharpFileOptions;
     private readonly object optionsLock = new object();
-    
+
     private FileDescriptor(FileDescriptorProto proto, FileDescriptor[] dependencies, DescriptorPool pool) {
       this.pool = pool;
       this.proto = proto;
@@ -60,49 +60,60 @@ namespace Google.ProtocolBuffers.Descriptors {
 
       pool.AddPackage(Package, this);
 
-      messageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageTypeList, 
-          (message, index) => new MessageDescriptor(message, this, null, index));
+      messageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageTypeList,
+                                                           (message, index) =>
+                                                           new MessageDescriptor(message, this, null, index));
 
       enumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumTypeList,
-        (enumType, index) => new EnumDescriptor(enumType, this, null, index));
+                                                        (enumType, index) =>
+                                                        new EnumDescriptor(enumType, this, null, index));
 
       services = DescriptorUtil.ConvertAndMakeReadOnly(proto.ServiceList,
-        (service, index) => new ServiceDescriptor(service, this, index));
+                                                       (service, index) => new ServiceDescriptor(service, this, index));
 
       extensions = DescriptorUtil.ConvertAndMakeReadOnly(proto.ExtensionList,
-        (field, index) => new FieldDescriptor(field, this, null, index, true));
+                                                         (field, index) =>
+                                                         new FieldDescriptor(field, this, null, index, true));
     }
 
 
-	/// <summary>
-	/// ROK - Added to allow the GeneratorOptions to sepcify the default for any or all of these values
-	/// </summary>
-	internal void ConfigureWithDefaultOptions(CSharpFileOptions options)
-	{
-		csharpFileOptions = BuildOrFakeWithDefaultOptions(options);
-	}
-	private CSharpFileOptions BuildOrFakeWithDefaultOptions(CSharpFileOptions defaultOptions)
-	{
-	  // ROK 2010-09-03 - fix for being able to relocate these files to any directory structure
-	  if(proto.Package == "google.protobuf") {
-	  	string filename = System.IO.Path.GetFileName(proto.Name);
-		// TODO(jonskeet): Check if we could use FileDescriptorProto.Descriptor.Name - interesting bootstrap issues)
-		if (filename == "descriptor.proto") {
-			return new CSharpFileOptions.Builder {
-			  Namespace = "Google.ProtocolBuffers.DescriptorProtos",
-			  UmbrellaClassname = "DescriptorProtoFile", NestClasses = false, MultipleFiles = false, PublicClasses = true,
-			  OutputDirectory = defaultOptions.OutputDirectory, IgnoreGoogleProtobuf = defaultOptions.IgnoreGoogleProtobuf
-			}.Build();
-		}
-		if (filename == "csharp_options.proto") {
-			return new CSharpFileOptions.Builder {
-			  Namespace = "Google.ProtocolBuffers.DescriptorProtos",
-			  UmbrellaClassname = "CSharpOptions", NestClasses = false, MultipleFiles = false, PublicClasses = true,
-			  OutputDirectory = defaultOptions.OutputDirectory, IgnoreGoogleProtobuf = defaultOptions.IgnoreGoogleProtobuf
-			}.Build();
-		}
-	  }
-	  CSharpFileOptions.Builder builder = defaultOptions.ToBuilder();
+    /// <summary>
+    /// Allows a file descriptor to be configured with a set of external options, e.g. from the
+    /// command-line arguments to protogen.
+    /// </summary>
+    internal void ConfigureWithDefaultOptions(CSharpFileOptions options) {
+      csharpFileOptions = BuildOrFakeWithDefaultOptions(options);
+    }
+
+    private CSharpFileOptions BuildOrFakeWithDefaultOptions(CSharpFileOptions defaultOptions) {
+      // Fix for being able to relocate these files to any directory structure
+      if (proto.Package == "google.protobuf") {
+        string filename = Path.GetFileName(proto.Name);
+        // TODO(jonskeet): Check if we could use FileDescriptorProto.Descriptor.Name - interesting bootstrap issues)
+        if (filename == "descriptor.proto") {
+          return new CSharpFileOptions.Builder {
+            Namespace = "Google.ProtocolBuffers.DescriptorProtos",
+            UmbrellaClassname = "DescriptorProtoFile",
+            NestClasses = false,
+            MultipleFiles = false,
+            PublicClasses = true,
+            OutputDirectory = defaultOptions.OutputDirectory,
+            IgnoreGoogleProtobuf = defaultOptions.IgnoreGoogleProtobuf
+          }.Build();
+        }
+        if (filename == "csharp_options.proto") {
+          return new CSharpFileOptions.Builder {
+            Namespace = "Google.ProtocolBuffers.DescriptorProtos",
+            UmbrellaClassname = "CSharpOptions",
+            NestClasses = false,
+            MultipleFiles = false,
+            PublicClasses = true,
+            OutputDirectory = defaultOptions.OutputDirectory,
+            IgnoreGoogleProtobuf = defaultOptions.IgnoreGoogleProtobuf
+          }.Build();
+        }
+      }
+      CSharpFileOptions.Builder builder = defaultOptions.ToBuilder();
       if (proto.Options.HasExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions)) {
         builder.MergeFrom(proto.Options.GetExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions));
       }
@@ -112,22 +123,26 @@ namespace Google.ProtocolBuffers.Descriptors {
       if (!builder.HasUmbrellaClassname) {
         int lastSlash = Name.LastIndexOf('/');
         string baseName = Name.Substring(lastSlash + 1);
-        builder.UmbrellaClassname = NameHelpers.UnderscoresToPascalCase(NameHelpers.StripProto(baseName));        
+        builder.UmbrellaClassname = NameHelpers.UnderscoresToPascalCase(NameHelpers.StripProto(baseName));
       }
 
-	  // ROK 2010-09-03 - auto fix for name collision by placing umbrella class into a new namespace.  This
-	  // still won't fix the collisions with nesting enabled; however, you have to turn that on so whatever.
-	  if(!builder.NestClasses && !builder.HasUmbrellaNamespace) {
-		  bool collision = false;
-		  foreach (IDescriptor d in MessageTypes)
-			  collision |= d.Name == builder.UmbrellaClassname;
-		  foreach (IDescriptor d in Services)
-			  collision |= d.Name == builder.UmbrellaClassname;
-		  foreach (IDescriptor d in EnumTypes)
-			  collision |= d.Name == builder.UmbrellaClassname;
-		  if (collision)
-			  builder.UmbrellaNamespace = "Proto";
-	  }
+      // Auto-fix for name collision by placing umbrella class into a new namespace.  This
+      // still won't fix the collisions with nesting enabled; however, you have to turn that on explicitly anyway.
+      if (!builder.NestClasses && !builder.HasUmbrellaNamespace) {
+        bool collision = false;
+        foreach (IDescriptor d in MessageTypes) {
+          collision |= d.Name == builder.UmbrellaClassname;
+        }
+        foreach (IDescriptor d in Services) {
+          collision |= d.Name == builder.UmbrellaClassname;
+        }
+        foreach (IDescriptor d in EnumTypes) {
+          collision |= d.Name == builder.UmbrellaClassname;
+        }
+        if (collision) {
+          builder.UmbrellaNamespace = "Proto";
+        }
+      }
 
       return builder.Build();
     }
@@ -140,7 +155,7 @@ namespace Google.ProtocolBuffers.Descriptors {
     }
 
     /// <value>
-    /// The <see cref="FileOptions" /> defined in <c>descriptor.proto</c>.
+    /// The <see cref="DescriptorProtos.FileOptions" /> defined in <c>descriptor.proto</c>.
     /// </value>
     public FileOptions Options {
       get { return proto.Options; }
@@ -238,15 +253,15 @@ namespace Google.ProtocolBuffers.Descriptors {
     internal DescriptorPool DescriptorPool {
       get { return pool; }
     }
-    
+
     /// <summary>
     /// Finds a type (message, enum, service or extension) in the file by name. Does not find nested types.
     /// </summary>
     /// <param name="name">The unqualified type name to look for.</param>
     /// <typeparam name="T">The type of descriptor to look for (or ITypeDescriptor for any)</typeparam>
     /// <returns>The type's descriptor, or null if not found.</returns>
-    public T FindTypeByName<T>(String name) 
-        where T : class, IDescriptor {
+    public T FindTypeByName<T>(String name)
+      where T : class, IDescriptor {
       // Don't allow looking up nested types.  This will make optimization
       // easier later.
       if (name.IndexOf('.') != -1) {
@@ -291,20 +306,20 @@ namespace Google.ProtocolBuffers.Descriptors {
 
       if (dependencies.Length != proto.DependencyCount) {
         throw new DescriptorValidationException(result,
-          "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
-          "those listed in the FileDescriptorProto.");
+                                                "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
+                                                "those listed in the FileDescriptorProto.");
       }
       for (int i = 0; i < proto.DependencyCount; i++) {
         if (dependencies[i].Name != proto.DependencyList[i]) {
           throw new DescriptorValidationException(result,
-            "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
-            "those listed in the FileDescriptorProto.");
+                                                  "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
+                                                  "those listed in the FileDescriptorProto.");
         }
       }
 
       result.CrossLink();
       return result;
-    }                                 
+    }
 
     private void CrossLink() {
       foreach (MessageDescriptor message in messageTypes) {
@@ -323,7 +338,7 @@ namespace Google.ProtocolBuffers.Descriptors {
         message.CheckRequiredFields();
       }
     }
-    
+
     /// <summary>
     /// This method is to be called by generated code only.  It is equivalent
     /// to BuildFrom except that the FileDescriptorProto is encoded in
@@ -350,19 +365,21 @@ namespace Google.ProtocolBuffers.Descriptors {
     public delegate ExtensionRegistry InternalDescriptorAssigner(FileDescriptor descriptor);
 
     public static FileDescriptor InternalBuildGeneratedFileFrom(byte[] descriptorData,
-      FileDescriptor[] dependencies,InternalDescriptorAssigner descriptorAssigner) {
-      
+                                                                FileDescriptor[] dependencies,
+                                                                InternalDescriptorAssigner descriptorAssigner) {
       FileDescriptorProto proto;
       try {
         proto = FileDescriptorProto.ParseFrom(descriptorData);
-      } catch (InvalidProtocolBufferException e) {
+      }
+      catch (InvalidProtocolBufferException e) {
         throw new ArgumentException("Failed to parse protocol buffer descriptor for generated code.", e);
       }
 
       FileDescriptor result;
       try {
         result = BuildFrom(proto, dependencies);
-      } catch (DescriptorValidationException e) {
+      }
+      catch (DescriptorValidationException e) {
         throw new ArgumentException("Invalid embedded descriptor for \"" + proto.Name + "\".", e);
       }
 
@@ -372,7 +389,8 @@ namespace Google.ProtocolBuffers.Descriptors {
         // We must re-parse the proto using the registry.
         try {
           proto = FileDescriptorProto.ParseFrom(descriptorData, registry);
-        } catch (InvalidProtocolBufferException e) {
+        }
+        catch (InvalidProtocolBufferException e) {
           throw new ArgumentException("Failed to parse protocol buffer descriptor for generated code.", e);
         }
 
@@ -381,7 +399,6 @@ namespace Google.ProtocolBuffers.Descriptors {
       return result;
     }
 
-
     /// <summary>
     /// Replace our FileDescriptorProto with the given one, which is
     /// identical except that it might contain extensions that weren't present
@@ -412,4 +429,4 @@ namespace Google.ProtocolBuffers.Descriptors {
       }
     }
   }
-}
+}
\ No newline at end of file
diff --git a/src/ProtocolBuffers/DynamicMessage.cs b/src/ProtocolBuffers/DynamicMessage.cs
index 00d7494f..12f2186c 100644
--- a/src/ProtocolBuffers/DynamicMessage.cs
+++ b/src/ProtocolBuffers/DynamicMessage.cs
@@ -335,7 +335,7 @@ namespace Google.ProtocolBuffers {
       }
 
       public override bool IsInitialized {
-      	get { return fields.IsInitializedWithRespectTo(type); }
+          get { return fields.IsInitializedWithRespectTo(type); }
       }
 
       public override Builder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) {
diff --git a/src/ProtocolBuffers/UnknownField.cs b/src/ProtocolBuffers/UnknownField.cs
index dc0b1b6a..fdc00650 100644
--- a/src/ProtocolBuffers/UnknownField.cs
+++ b/src/ProtocolBuffers/UnknownField.cs
@@ -273,7 +273,7 @@ namespace Google.ProtocolBuffers {
         if (extras.Count == 0) {
           return current;
         }
- 	      if (current == null) {
+           if (current == null) {
           current = new List<T>(extras);
         } else {
           current.AddRange(extras);
@@ -359,7 +359,7 @@ namespace Google.ProtocolBuffers {
       /// <returns></returns>
       private static ReadOnlyCollection<T> MakeReadOnly<T>(ref List<T> list) {
         ReadOnlyCollection<T> ret = list == null ? Lists<T>.Empty : new ReadOnlyCollection<T>(list);
- 	      list = null;
+           list = null;
         return ret;
       }
     }