Refactored options

4 files changed, 505 insertions, 24 deletions

diff --git a/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs b/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
index 14d6bb64..55a30030 100644
--- a/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
+++ b/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
@@ -15,35 +15,381 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(
         global::System.Convert.FromBase64String(
         "CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds" + 
-        "ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG86" + 
-        "NwoPQ1NoYXJwTmFtZXNwYWNlEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRp" + 
-        "b25zGKCcASABKAk6PwoXQ1NoYXJwVW1icmVsbGFDbGFzc25hbWUSHC5nb29n" + 
-        "bGUucHJvdG9idWYuRmlsZU9wdGlvbnMYoZwBIAEoCTo7ChNDU2hhcnBNdWx0" + 
-        "aXBsZUZpbGVzEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKKcASAB" + 
-        "KAg6OQoRQ1NoYXJwTmVzdENsYXNzZXMSHC5nb29nbGUucHJvdG9idWYuRmls" + 
-        "ZU9wdGlvbnMYo5wBIAEoCDo7ChNDU2hhcnBQdWJsaWNDbGFzc2VzEhwuZ29v" + 
-        "Z2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKScASABKAhCPILiCSdHb29nbGUu" + 
-        "UHJvdG9jb2xCdWZmZXJzLkRlc2NyaXB0b3JQcm90b3OK4gkNQ1NoYXJwT3B0" + 
-        "aW9ucw=="),
+        "ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG8i" + 
+        "4wEKEUNTaGFycEZpbGVPcHRpb25zEhEKCW5hbWVzcGFjZRgBIAEoCRIaChJ1" + 
+        "bWJyZWxsYV9jbGFzc25hbWUYAiABKAkSFgoOcHVibGljX2NsYXNzZXMYAyAB" + 
+        "KAgSFgoObXVsdGlwbGVfZmlsZXMYBCABKAgSFAoMbmVzdF9jbGFzc2VzGAUg" + 
+        "ASgIMlkKDmNzaGFycF9vcHRpb25zEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVP" + 
+        "cHRpb25zGOgHIAEoCzIiLmdvb2dsZS5wcm90b2J1Zi5DU2hhcnBGaWxlT3B0" + 
+        "aW9ucyKIAQoSQ1NoYXJwRmllbGRPcHRpb25zEhUKDXByb3BlcnR5X25hbWUY" + 
+        "ASABKAkyWwoOY3NoYXJwX29wdGlvbnMSHS5nb29nbGUucHJvdG9idWYuRmll" + 
+        "bGRPcHRpb25zGOgHIAEoCzIjLmdvb2dsZS5wcm90b2J1Zi5DU2hhcnBGaWVs" + 
+        "ZE9wdGlvbnM="),
         new pbd::FileDescriptor[] {
           global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, 
         });
     #endregion
     
-    #region Extensions
-    public static readonly pb::GeneratedExtensionBase<string> CSharpNamespace =
-        pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[0]);
-    public static readonly pb::GeneratedExtensionBase<string> CSharpUmbrellaClassname =
-        pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[1]);
-    public static readonly pb::GeneratedExtensionBase<bool> CSharpMultipleFiles =
-        pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[2]);
-    public static readonly pb::GeneratedExtensionBase<bool> CSharpNestClasses =
-        pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[3]);
-    public static readonly pb::GeneratedExtensionBase<bool> CSharpPublicClasses =
-        pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[4]);
-    #endregion
-    
     #region Static variables
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_CSharpFileOptions__Descriptor
+        = Descriptor.MessageTypes[0];
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder> internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable
+        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder>(internal__static_google_protobuf_CSharpFileOptions__Descriptor,
+            new string[] { "Namespace", "UmbrellaClassname", "PublicClasses", "MultipleFiles", "NestClasses", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_CSharpFieldOptions__Descriptor
+        = Descriptor.MessageTypes[1];
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder> internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable
+        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder>(internal__static_google_protobuf_CSharpFieldOptions__Descriptor,
+            new string[] { "PropertyName", });
     #endregion
   }
+  #region Messages
+  public sealed partial class CSharpFileOptions : pb::GeneratedMessage<CSharpFileOptions, CSharpFileOptions.Builder> {
+    private static readonly CSharpFileOptions defaultInstance = new Builder().BuildPartial();
+    public static CSharpFileOptions DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override CSharpFileOptions DefaultInstanceForType {
+      get { return defaultInstance; }
+    }
+    
+    protected override CSharpFileOptions ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<CSharpFileOptions, CSharpFileOptions.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable; }
+    }
+    
+    public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions> CSharpOptions =
+        pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions>.CreateInstance(Descriptor.Extensions[0]);
+    private bool hasNamespace;
+    private string namespace_ = "";
+    public bool HasNamespace {
+      get { return hasNamespace; }
+    }
+    public string Namespace {
+      get { return namespace_; }
+    }
+    
+    private bool hasUmbrellaClassname;
+    private string umbrellaClassname_ = "";
+    public bool HasUmbrellaClassname {
+      get { return hasUmbrellaClassname; }
+    }
+    public string UmbrellaClassname {
+      get { return umbrellaClassname_; }
+    }
+    
+    private bool hasPublicClasses;
+    private bool publicClasses_ = false;
+    public bool HasPublicClasses {
+      get { return hasPublicClasses; }
+    }
+    public bool PublicClasses {
+      get { return publicClasses_; }
+    }
+    
+    private bool hasMultipleFiles;
+    private bool multipleFiles_ = false;
+    public bool HasMultipleFiles {
+      get { return hasMultipleFiles; }
+    }
+    public bool MultipleFiles {
+      get { return multipleFiles_; }
+    }
+    
+    private bool hasNestClasses;
+    private bool nestClasses_ = false;
+    public bool HasNestClasses {
+      get { return hasNestClasses; }
+    }
+    public bool NestClasses {
+      get { return nestClasses_; }
+    }
+    
+    public static CSharpFileOptions ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CSharpFileOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CSharpFileOptions ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CSharpFileOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CSharpFileOptions ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CSharpFileOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static CSharpFileOptions ParseFrom(pb::CodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CSharpFileOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(CSharpFileOptions prototype) {
+      return (Builder) new Builder().MergeFrom(prototype);
+    }
+    
+    public sealed partial class Builder : pb::GeneratedBuilder<CSharpFileOptions, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {}
+      
+      CSharpFileOptions result = new CSharpFileOptions();
+      
+      protected override CSharpFileOptions MessageBeingBuilt {
+        get { return result; }
+      }
+      
+      public override Builder Clear() {
+        result = new CSharpFileOptions();
+        return this;
+      }
+      
+      public override Builder Clone() {
+        return new Builder().MergeFrom(result);
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return CSharpFileOptions.Descriptor; }
+      }
+      
+      public override CSharpFileOptions DefaultInstanceForType {
+        get { return CSharpFileOptions.DefaultInstance; }
+      }
+      
+      public override CSharpFileOptions BuildPartial() {
+        CSharpFileOptions returnMe = result;
+        result = null;
+        return returnMe;
+      }
+      
+      
+      public bool HasNamespace {
+        get { return result.HasNamespace; }
+      }
+      public string Namespace {
+        get { return result.Namespace; }
+        set { SetNamespace(value); }
+      }
+      public Builder SetNamespace(string value) {
+        result.hasNamespace = true;
+        result.namespace_ = value;
+        return this;
+      }
+      public Builder ClearNamespace() {
+        result.hasNamespace = false;
+        result.namespace_ = "";
+        return this;
+      }
+      
+      public bool HasUmbrellaClassname {
+        get { return result.HasUmbrellaClassname; }
+      }
+      public string UmbrellaClassname {
+        get { return result.UmbrellaClassname; }
+        set { SetUmbrellaClassname(value); }
+      }
+      public Builder SetUmbrellaClassname(string value) {
+        result.hasUmbrellaClassname = true;
+        result.umbrellaClassname_ = value;
+        return this;
+      }
+      public Builder ClearUmbrellaClassname() {
+        result.hasUmbrellaClassname = false;
+        result.umbrellaClassname_ = "";
+        return this;
+      }
+      
+      public bool HasPublicClasses {
+        get { return result.HasPublicClasses; }
+      }
+      public bool PublicClasses {
+        get { return result.PublicClasses; }
+        set { SetPublicClasses(value); }
+      }
+      public Builder SetPublicClasses(bool value) {
+        result.hasPublicClasses = true;
+        result.publicClasses_ = value;
+        return this;
+      }
+      public Builder ClearPublicClasses() {
+        result.hasPublicClasses = false;
+        result.publicClasses_ = false;
+        return this;
+      }
+      
+      public bool HasMultipleFiles {
+        get { return result.HasMultipleFiles; }
+      }
+      public bool MultipleFiles {
+        get { return result.MultipleFiles; }
+        set { SetMultipleFiles(value); }
+      }
+      public Builder SetMultipleFiles(bool value) {
+        result.hasMultipleFiles = true;
+        result.multipleFiles_ = value;
+        return this;
+      }
+      public Builder ClearMultipleFiles() {
+        result.hasMultipleFiles = false;
+        result.multipleFiles_ = false;
+        return this;
+      }
+      
+      public bool HasNestClasses {
+        get { return result.HasNestClasses; }
+      }
+      public bool NestClasses {
+        get { return result.NestClasses; }
+        set { SetNestClasses(value); }
+      }
+      public Builder SetNestClasses(bool value) {
+        result.hasNestClasses = true;
+        result.nestClasses_ = value;
+        return this;
+      }
+      public Builder ClearNestClasses() {
+        result.hasNestClasses = false;
+        result.nestClasses_ = false;
+        return this;
+      }
+    }
+  }
+  
+  public sealed partial class CSharpFieldOptions : pb::GeneratedMessage<CSharpFieldOptions, CSharpFieldOptions.Builder> {
+    private static readonly CSharpFieldOptions defaultInstance = new Builder().BuildPartial();
+    public static CSharpFieldOptions DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override CSharpFieldOptions DefaultInstanceForType {
+      get { return defaultInstance; }
+    }
+    
+    protected override CSharpFieldOptions ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<CSharpFieldOptions, CSharpFieldOptions.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable; }
+    }
+    
+    public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions> CSharpOptions =
+        pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions>.CreateInstance(Descriptor.Extensions[0]);
+    private bool hasPropertyName;
+    private string propertyName_ = "";
+    public bool HasPropertyName {
+      get { return hasPropertyName; }
+    }
+    public string PropertyName {
+      get { return propertyName_; }
+    }
+    
+    public static CSharpFieldOptions ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CSharpFieldOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CSharpFieldOptions ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CSharpFieldOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static CSharpFieldOptions ParseFrom(pb::CodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CSharpFieldOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(CSharpFieldOptions prototype) {
+      return (Builder) new Builder().MergeFrom(prototype);
+    }
+    
+    public sealed partial class Builder : pb::GeneratedBuilder<CSharpFieldOptions, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {}
+      
+      CSharpFieldOptions result = new CSharpFieldOptions();
+      
+      protected override CSharpFieldOptions MessageBeingBuilt {
+        get { return result; }
+      }
+      
+      public override Builder Clear() {
+        result = new CSharpFieldOptions();
+        return this;
+      }
+      
+      public override Builder Clone() {
+        return new Builder().MergeFrom(result);
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return CSharpFieldOptions.Descriptor; }
+      }
+      
+      public override CSharpFieldOptions DefaultInstanceForType {
+        get { return CSharpFieldOptions.DefaultInstance; }
+      }
+      
+      public override CSharpFieldOptions BuildPartial() {
+        CSharpFieldOptions returnMe = result;
+        result = null;
+        return returnMe;
+      }
+      
+      
+      public bool HasPropertyName {
+        get { return result.HasPropertyName; }
+      }
+      public string PropertyName {
+        get { return result.PropertyName; }
+        set { SetPropertyName(value); }
+      }
+      public Builder SetPropertyName(string value) {
+        result.hasPropertyName = true;
+        result.propertyName_ = value;
+        return this;
+      }
+      public Builder ClearPropertyName() {
+        result.hasPropertyName = false;
+        result.propertyName_ = "";
+        return this;
+      }
+    }
+  }
+  
+  #endregion
+  
 }
diff --git a/src/ProtocolBuffers/Descriptors/FileDescriptor.cs b/src/ProtocolBuffers/Descriptors/FileDescriptor.cs
index ebb6b159..79e034a1 100644
--- a/src/ProtocolBuffers/Descriptors/FileDescriptor.cs
+++ b/src/ProtocolBuffers/Descriptors/FileDescriptor.cs
@@ -50,6 +50,8 @@ namespace Google.ProtocolBuffers.Descriptors {
     private readonly IList<FieldDescriptor> extensions;
     private readonly IList<FileDescriptor> dependencies;
     private readonly DescriptorPool pool;
+    private CSharpFileOptions csharpFileOptions;
+    private readonly object optionsLock = new object();
     
     private FileDescriptor(FileDescriptorProto proto, FileDescriptor[] dependencies, DescriptorPool pool) {
       this.pool = pool;
@@ -71,6 +73,44 @@ namespace Google.ProtocolBuffers.Descriptors {
         (field, index) => new FieldDescriptor(field, this, null, index, true));
     }
 
+    private CSharpFileOptions BuildOrFakeCSharpOptions() {
+      // TODO(jonskeet): Check if we could use FileDescriptorProto.Descriptor.Name - interesting bootstrap issues
+      if (proto.Name == "google/protobuf/descriptor.proto") {
+        return new CSharpFileOptions.Builder {
+          Namespace = "Google.ProtocolBuffers.DescriptorProtos",
+          UmbrellaClassname = "DescriptorProtoFile", NestClasses = false, MultipleFiles = false, PublicClasses = true
+        }.Build();
+      }
+      if (proto.Name == "google/protobuf/csharp_options.proto") {
+        return new CSharpFileOptions.Builder {
+          Namespace = "Google.ProtocolBuffers.DescriptorProtos",
+          UmbrellaClassname = "CSharpOptions", NestClasses = false, MultipleFiles = false, PublicClasses = true
+        }.Build();
+      }
+      CSharpFileOptions.Builder builder = CSharpFileOptions.CreateBuilder();
+      if (proto.Options.HasExtension(CSharpFileOptions.CSharpOptions)) {
+        builder.MergeFrom(proto.Options.GetExtension(CSharpFileOptions.CSharpOptions));
+      }
+      if (!builder.HasNamespace) {
+        builder.Namespace = Package;
+      }
+      if (!builder.HasMultipleFiles) {
+        builder.MultipleFiles = false;
+      }
+      if (!builder.HasNestClasses) {
+        builder.NestClasses = false;
+      }
+      if (!builder.HasPublicClasses) {
+        builder.PublicClasses = true;
+      }
+      if (!builder.HasUmbrellaClassname) {
+        int lastSlash = Name.LastIndexOf('/');
+        string baseName = Name.Substring(lastSlash + 1);
+        builder.UmbrellaClassname = NameHelpers.UnderscoresToPascalCase(NameHelpers.StripProto(baseName));        
+      }
+      return builder.Build();
+    }
+
     /// <value>
     /// The descriptor in its protocol message representation.
     /// </value>
@@ -85,6 +125,22 @@ namespace Google.ProtocolBuffers.Descriptors {
       get { return proto.Options; }
     }
 
+    /// <summary>
+    /// Returns the C#-specific options for this file descriptor. This will always be
+    /// completely filled in.
+    /// FIXME: This isn't thread-safe. Can't do it at construction time due to bootstrapping issues.
+    /// </summary>
+    public CSharpFileOptions CSharpOptions {
+      get {
+        lock (optionsLock) {
+          if (csharpFileOptions == null) {
+            csharpFileOptions = BuildOrFakeCSharpOptions();
+          }
+        }
+        return csharpFileOptions;
+      }
+    }
+
     /// <value>
     /// The file name.
     /// </value>
@@ -250,7 +306,7 @@ namespace Google.ProtocolBuffers.Descriptors {
     
     /// <summary>
     /// This method is to be called by generated code only.  It is equivalent
-    /// to BuilderFrom except that the FileDescriptorProto is encoded in
+    /// to BuildFrom except that the FileDescriptorProto is encoded in
     /// protocol buffer wire format.
     /// </summary>
     public static FileDescriptor InternalBuildGeneratedFileFrom(byte[] descriptorData,
diff --git a/src/ProtocolBuffers/NameHelpers.cs b/src/ProtocolBuffers/NameHelpers.cs
new file mode 100644
index 00000000..8b297f95
--- /dev/null
+++ b/src/ProtocolBuffers/NameHelpers.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Helpers for converting names to pascal case etc.
+  /// </summary>
+  internal class NameHelpers {
+
+    internal static string UnderscoresToPascalCase(string input) {
+      return UnderscoresToPascalOrCamelCase(input, true);
+    }
+
+    internal static string UnderscoresToCamelCase(string input) {
+      return UnderscoresToPascalOrCamelCase(input, false);
+    }
+
+    /// <summary>
+    /// Converts a string to Pascal or Camel case. The first letter is capitalized or
+    /// lower-cased depending on <paramref name="pascal"/> is true. 
+    /// After the first letter, any punctuation is removed but triggers capitalization
+    /// of the next letter. Digits are preserved but trigger capitalization of the next
+    /// letter.
+    /// All capitalisation is done in the invariant culture. 
+    /// </summary>
+    private static string UnderscoresToPascalOrCamelCase(string input, bool pascal) {
+      StringBuilder result = new StringBuilder();
+      bool capitaliseNext = pascal;
+      for (int i = 0; i < input.Length; i++) {
+        char c = input[i];
+        if ('a' <= c && c <= 'z') {
+          if (capitaliseNext) {
+            result.Append(char.ToUpperInvariant(c));
+          } else {
+            result.Append(c);
+          }
+          capitaliseNext = false;
+        } else if ('A' <= c && c <= 'Z') {
+          if (i == 0 && !pascal) {
+            // Force first letter to lower-case unless explicitly told to
+            // capitalize it.
+            result.Append(char.ToLowerInvariant(c));
+          } else {
+            // Capital letters after the first are left as-is.
+            result.Append(c);
+          }
+          capitaliseNext = false;
+        } else if ('0' <= c && c <= '9') {
+          result.Append(c);
+          capitaliseNext = true;
+        } else {
+          capitaliseNext = true;
+        }
+      }
+      return result.ToString();
+    }
+
+    internal static string StripProto(string text) {
+      if (!StripSuffix(ref text, ".protodevel")) {
+        StripSuffix(ref text, ".proto");
+      }
+      return text;
+    }
+
+    /// <summary>
+    /// Attempts to strip a suffix from a string, returning whether
+    /// or not the suffix was actually present.
+    /// </summary>
+    internal static bool StripSuffix(ref string text, string suffix) {
+      if (text.EndsWith(suffix)) {
+        text = text.Substring(0, text.Length - suffix.Length);
+        return true;
+      }
+      return false;
+    }
+  }
+}
diff --git a/src/ProtocolBuffers/ProtocolBuffers.csproj b/src/ProtocolBuffers/ProtocolBuffers.csproj
index 3f76aa7f..6a746cc9 100644
--- a/src/ProtocolBuffers/ProtocolBuffers.csproj
+++ b/src/ProtocolBuffers/ProtocolBuffers.csproj
@@ -97,6 +97,7 @@
     <Compile Include="IService.cs" />
     <Compile Include="MessageStreamIterator.cs" />
     <Compile Include="MessageStreamWriter.cs" />
+    <Compile Include="NameHelpers.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="RpcUtil.cs" />
     <Compile Include="TextFormat.cs" />