Testing and related fixes

18 files changed, 174 insertions, 62 deletions

diff --git a/src/ProtocolBuffers/AbstractBuilder.cs b/src/ProtocolBuffers/AbstractBuilder.cs
index 381e3ab4..d613eca4 100644
--- a/src/ProtocolBuffers/AbstractBuilder.cs
+++ b/src/ProtocolBuffers/AbstractBuilder.cs
@@ -72,7 +72,10 @@ namespace Google.ProtocolBuffers {
     }
 
     public sealed override TBuilder MergeFrom(IMessageLite other) {
-      return MergeFrom((IMessage)other);
+      if (other is IMessage) {
+        return MergeFrom((IMessage) other);
+      }
+      throw new ArgumentException("MergeFrom(Message) can only merge messages of the same type.");
     }
 
     /// <summary>
@@ -112,13 +115,13 @@ namespace Google.ProtocolBuffers {
           }
         } else if (field.MappedType == MappedType.Message) {
           // Merge singular messages
-          IMessage existingValue = (IMessage) this[field];
+          IMessageLite existingValue = (IMessageLite)this[field];
           if (existingValue == existingValue.WeakDefaultInstanceForType) {
             this[field] = entry.Value;
           } else {
             this[field] = existingValue.WeakCreateBuilderForType()
                                        .WeakMergeFrom(existingValue)
-                                       .WeakMergeFrom((IMessage) entry.Value)
+                                       .WeakMergeFrom((IMessageLite)entry.Value)
                                        .WeakBuild();
           }
         } else {
diff --git a/src/ProtocolBuffers/AbstractMessage.cs b/src/ProtocolBuffers/AbstractMessage.cs
index 44864302..e2cf3827 100644
--- a/src/ProtocolBuffers/AbstractMessage.cs
+++ b/src/ProtocolBuffers/AbstractMessage.cs
@@ -81,13 +81,13 @@ namespace Google.ProtocolBuffers {
             if (field.IsRepeated) {
               // We know it's an IList<T>, but not the exact type - so
               // IEnumerable is the best we can do. (C# generics aren't covariant yet.)
-              foreach (IMessage element in (IEnumerable) entry.Value) {
+              foreach (IMessageLite element in (IEnumerable)entry.Value) {
                 if (!element.IsInitialized) {
                   return false;
                 }
               }
             } else {
-              if (!((IMessage)entry.Value).IsInitialized) {
+              if (!((IMessageLite)entry.Value).IsInitialized) {
                 return false;
               }
             }
diff --git a/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs b/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs
index e62360fc..b0bf5de1 100644
--- a/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs
+++ b/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs
@@ -30,6 +30,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using System;
+using System.Collections.Generic;
+using Google.ProtocolBuffers.Collections;
 
 namespace Google.ProtocolBuffers.Descriptors {
 
@@ -46,5 +48,29 @@ namespace Google.ProtocolBuffers.Descriptors {
 
     internal MappedType MappedType { get; private set; }
     internal WireFormat.WireType WireType { get; private set; }
+
+
+    /// <summary>
+    /// Immutable mapping from field type to mapped type. Built using the attributes on
+    /// FieldType values.
+    /// </summary>
+    static readonly IDictionary<FieldType, FieldMappingAttribute> FieldTypeToMappedTypeMap = MapFieldTypes();
+
+    private static IDictionary<FieldType, FieldMappingAttribute> MapFieldTypes() {
+      var map = new Dictionary<FieldType, FieldMappingAttribute>();
+      foreach (System.Reflection.FieldInfo field in typeof(FieldType).GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)) {
+        FieldType fieldType = (FieldType)field.GetValue(null);
+        FieldMappingAttribute mapping = (FieldMappingAttribute)field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0];
+        map[fieldType] = mapping;
+      }
+      return Dictionaries.AsReadOnly(map);
+    }
+
+    internal static MappedType MappedTypeFromFieldType(FieldType type) {
+      return FieldTypeToMappedTypeMap[type].MappedType;
+    }
+    internal static WireFormat.WireType WireTypeFromFieldType(FieldType type, bool packed) {
+      return packed ? WireFormat.WireType.LengthDelimited : FieldTypeToMappedTypeMap[type].WireType;
+    }
   }
 }
diff --git a/src/ProtocolBuffers/DynamicMessage.cs b/src/ProtocolBuffers/DynamicMessage.cs
index 34a50c5b..44fe0f39 100644
--- a/src/ProtocolBuffers/DynamicMessage.cs
+++ b/src/ProtocolBuffers/DynamicMessage.cs
@@ -295,7 +295,8 @@ namespace Google.ProtocolBuffers {
       }
 
       public override Builder MergeFrom(DynamicMessage other) {
-        return MergeFrom((IMessage)other);
+        IMessage downcast = other;
+        return MergeFrom(downcast);
       }
 
       public override DynamicMessage Build() {
diff --git a/src/ProtocolBuffers/EnumLite.cs b/src/ProtocolBuffers/EnumLite.cs
index 0418d77e..ab13c9ab 100644
--- a/src/ProtocolBuffers/EnumLite.cs
+++ b/src/ProtocolBuffers/EnumLite.cs
@@ -68,16 +68,13 @@ namespace Google.ProtocolBuffers {
   public class EnumLiteMap<TEnum> : IEnumLiteMap<IEnumLite>
     where TEnum : struct, IComparable, IFormattable {
     
-    struct EnumValue : IEnumLite, IComparable<IEnumLite> {
-      int _value;
+    struct EnumValue : IEnumLite {
+      readonly int value;
       public EnumValue(int value) {
-        _value = value;
+        this.value = value;
       }
       int IEnumLite.Number {
-        get { return _value; }
-      }
-      int IComparable<IEnumLite>.CompareTo(IEnumLite other) {
-        return _value.CompareTo(other.Number);
+        get { return value; }
       }
     }
 
diff --git a/src/ProtocolBuffers/ExtendableBuilder.cs b/src/ProtocolBuffers/ExtendableBuilder.cs
index 803ceb1e..ad97cdc4 100644
--- a/src/ProtocolBuffers/ExtendableBuilder.cs
+++ b/src/ProtocolBuffers/ExtendableBuilder.cs
@@ -94,21 +94,21 @@ namespace Google.ProtocolBuffers {
     /// <summary>
     /// Appends a value to a repeated extension.
     /// </summary>
-    public ExtendableBuilder<TMessage, TBuilder> AddExtension<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension, TExtension value) {
+    public TBuilder AddExtension<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension, TExtension value) {
       ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt;
       message.VerifyExtensionContainingType(extension);
       message.Extensions.AddRepeatedField(extension.Descriptor, extension.SingularToReflectionType(value));
-      return this;
+      return ThisBuilder;
     }
 
     /// <summary>
     /// Clears an extension.
     /// </summary>
-    public ExtendableBuilder<TMessage, TBuilder> ClearExtension<TExtension>(GeneratedExtensionBase<TExtension> extension) {
+    public TBuilder ClearExtension<TExtension>(GeneratedExtensionBase<TExtension> extension) {
       ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt;
       message.VerifyExtensionContainingType(extension);
       message.Extensions.ClearField(extension.Descriptor);
-      return this;
+      return ThisBuilder;
     }
 
     /// <summary>
diff --git a/src/ProtocolBuffers/ExtendableBuilderLite.cs b/src/ProtocolBuffers/ExtendableBuilderLite.cs
index df0323ba..b3d37eda 100644
--- a/src/ProtocolBuffers/ExtendableBuilderLite.cs
+++ b/src/ProtocolBuffers/ExtendableBuilderLite.cs
@@ -34,6 +34,7 @@
 
 using System;
 using System.Collections.Generic;
+using Google.ProtocolBuffers.Descriptors;
 
 namespace Google.ProtocolBuffers {
   public abstract class ExtendableBuilderLite<TMessage, TBuilder> : GeneratedBuilderLite<TMessage, TBuilder>
@@ -93,21 +94,21 @@ namespace Google.ProtocolBuffers {
     /// <summary>
     /// Appends a value to a repeated extension.
     /// </summary>
-    public ExtendableBuilderLite<TMessage, TBuilder> AddExtension<TExtension>(GeneratedExtensionLite<TMessage, IList<TExtension>> extension, TExtension value) {
+    public TBuilder AddExtension<TExtension>(GeneratedExtensionLite<TMessage, IList<TExtension>> extension, TExtension value) {
       ExtendableMessageLite<TMessage, TBuilder> message = MessageBeingBuilt;
       message.VerifyExtensionContainingType(extension);
       message.Extensions.AddRepeatedField(extension.Descriptor, extension.SingularToReflectionType(value));
-      return this;
+      return ThisBuilder;
     }
 
     /// <summary>
     /// Clears an extension.
     /// </summary>
-    public ExtendableBuilderLite<TMessage, TBuilder> ClearExtension<TExtension>(GeneratedExtensionLite<TMessage, TExtension> extension) {
+    public TBuilder ClearExtension<TExtension>(GeneratedExtensionLite<TMessage, TExtension> extension) {
       ExtendableMessageLite<TMessage, TBuilder> message = MessageBeingBuilt;
       message.VerifyExtensionContainingType(extension);
       message.Extensions.ClearField(extension.Descriptor);
-      return this;
+      return ThisBuilder;
     }
 
     /// <summary>
@@ -117,11 +118,99 @@ namespace Google.ProtocolBuffers {
     [CLSCompliant(false)]
     protected override bool ParseUnknownField(CodedInputStream input,
         ExtensionRegistry extensionRegistry, uint tag) {
-      return input.SkipField(tag);
+      FieldSet extensions = MessageBeingBuilt.Extensions;
+
+      WireFormat.WireType wireType = WireFormat.GetTagWireType(tag);
+      int fieldNumber = WireFormat.GetTagFieldNumber(tag);
+      IGeneratedExtensionLite extension = extensionRegistry[DefaultInstanceForType, fieldNumber];
+
+      bool unknown = false;
+      bool packed = false;
+      if (extension == null) {
+        unknown = true;  // Unknown field.
+      } else if (wireType == FieldMappingAttribute.WireTypeFromFieldType(extension.Descriptor.FieldType, false /* isPacked */)) {
+        packed = false;  // Normal, unpacked value.
+      } else if (extension.Descriptor.IsRepeated &&
+                 //?? just returns true ?? extension.Descriptor.type.isPackable() &&
+                 wireType == FieldMappingAttribute.WireTypeFromFieldType(extension.Descriptor.FieldType, true /* isPacked */)) {
+        packed = true;  // Packed value.
+      } else {
+        unknown = true;  // Wrong wire type.
+      }
+
+      if (unknown) {  // Unknown field or wrong wire type.  Skip.
+        return input.SkipField(tag);
+      }
+
+      if (packed) {
+        int length = (int)Math.Min(int.MaxValue, input.ReadRawVarint32());
+        int limit = input.PushLimit(length);
+        if (extension.Descriptor.FieldType == FieldType.Enum) {
+          while (!input.ReachedLimit) {
+            int rawValue = input.ReadEnum();
+            Object value =
+                extension.Descriptor.EnumType.FindValueByNumber(rawValue);
+            if (value == null) {
+              // If the number isn't recognized as a valid value for this
+              // enum, drop it (don't even add it to unknownFields).
+              return true;
+            }
+            extensions.AddRepeatedField(extension.Descriptor, value);
+          }
+        } else {
+          while (!input.ReachedLimit) {
+            Object value = input.ReadPrimitiveField(extension.Descriptor.FieldType);
+            extensions.AddRepeatedField(extension.Descriptor, value);
+          }
+        }
+        input.PopLimit(limit);
+      } else {
+        Object value;
+        switch (extension.Descriptor.MappedType) {
+          case MappedType.Message: {
+            IBuilderLite subBuilder = null;
+            if (!extension.Descriptor.IsRepeated) {
+              IMessageLite existingValue = extensions[extension.Descriptor] as IMessageLite;
+              if (existingValue != null) {
+                subBuilder = existingValue.WeakToBuilder();
+              }
+            }
+            if (subBuilder == null) {
+              subBuilder = extension.MessageDefaultInstance.WeakCreateBuilderForType();
+            }
+            if (extension.Descriptor.FieldType == FieldType.Group) {
+              input.ReadGroup(extension.Number, subBuilder, extensionRegistry);
+            } else {
+              input.ReadMessage(subBuilder, extensionRegistry);
+            }
+            value = subBuilder.WeakBuild();
+            break;
+          }
+          case MappedType.Enum:
+            int rawValue = input.ReadEnum();
+            value = extension.Descriptor.EnumType.FindValueByNumber(rawValue);
+            // If the number isn't recognized as a valid value for this enum,
+            // drop it.
+            if (value == null) {
+              return true;
+            }
+            break;
+          default:
+            value = input.ReadPrimitiveField(extension.Descriptor.FieldType);
+            break;
+        }
+
+        if (extension.Descriptor.IsRepeated) {
+          extensions.AddRepeatedField(extension.Descriptor, value);
+        } else {
+          extensions[extension.Descriptor] = value;
+        }
+      }
+
+      return true;
     }
 
-    // ---------------------------------------------------------------
-    // Reflection
+    #region Reflection
 
     public object this[IFieldDescriptorLite field, int index] {
       set {
@@ -168,5 +257,6 @@ namespace Google.ProtocolBuffers {
     protected void MergeExtensionFields(ExtendableMessageLite<TMessage, TBuilder> other) {
       MessageBeingBuilt.Extensions.MergeFrom(other.Extensions);
     }
+    #endregion
   }
 }
diff --git a/src/ProtocolBuffers/ExtensionInfo.cs b/src/ProtocolBuffers/ExtensionInfo.cs
index 43dd5158..482f006a 100644
--- a/src/ProtocolBuffers/ExtensionInfo.cs
+++ b/src/ProtocolBuffers/ExtensionInfo.cs
@@ -42,7 +42,9 @@ namespace Google.ProtocolBuffers
     /// </summary>
     public FieldDescriptor Descriptor { get; private set; }
 
-    /// <summary>
+    IFieldDescriptorLite IGeneratedExtensionLite.Descriptor { get { return Descriptor; } }
+
+      /// <summary>
     /// A default instance of the extensions's type, if it has a message type,
     /// or null otherwise.
     /// </summary>
diff --git a/src/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs b/src/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs
index 893b0285..df6680cb 100644
--- a/src/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs
+++ b/src/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs
@@ -71,7 +71,7 @@ namespace Google.ProtocolBuffers.FieldAccess {
       }
 
       // No... so let's create a builder of the right type, and merge the value in.
-      IMessage message = (IMessage) value;
+      IMessageLite message = (IMessageLite) value;
       return CreateBuilder().WeakMergeFrom(message).WeakBuild();
     }
 
diff --git a/src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs b/src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs
index ea422c94..838bc5a2 100644
--- a/src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs
+++ b/src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs
@@ -67,7 +67,7 @@ namespace Google.ProtocolBuffers.FieldAccess {
       }
       
       // No... so let's create a builder of the right type, and merge the value in.
-      IMessage message = (IMessage) value;
+      IMessageLite message = (IMessageLite) value;
       return CreateBuilder().WeakMergeFrom(message).WeakBuild();
     }
 
diff --git a/src/ProtocolBuffers/FieldSet.cs b/src/ProtocolBuffers/FieldSet.cs
index 3ac3e3d3..838d0568 100644
--- a/src/ProtocolBuffers/FieldSet.cs
+++ b/src/ProtocolBuffers/FieldSet.cs
@@ -486,7 +486,9 @@ namespace Google.ProtocolBuffers {
           IMessageLite messageValue = value as IMessageLite;
           isValid = messageValue != null;
 #if !LITE
-          isValid = isValid && ((IMessage)messageValue).DescriptorForType == ((Google.ProtocolBuffers.Descriptors.FieldDescriptor)field).MessageType;
+          if (isValid && messageValue is IMessage && field is FieldDescriptor) {
+            isValid = ((IMessage) messageValue).DescriptorForType == ((FieldDescriptor) field).MessageType;
+          }
 #endif
           break;
       }
diff --git a/src/ProtocolBuffers/GeneratedBuilder.cs b/src/ProtocolBuffers/GeneratedBuilder.cs
index 1124fc86..01d3d2dd 100644
--- a/src/ProtocolBuffers/GeneratedBuilder.cs
+++ b/src/ProtocolBuffers/GeneratedBuilder.cs
@@ -148,10 +148,10 @@ namespace Google.ProtocolBuffers {
           }
         } else if (field.MappedType == MappedType.Message && HasField(field)) {
           // Merge singular embedded messages
-          IMessage oldValue = (IMessage)this[field];
+          IMessageLite oldValue = (IMessageLite)this[field];
           this[field] = oldValue.WeakCreateBuilderForType()
               .WeakMergeFrom(oldValue)
-              .WeakMergeFrom((IMessage)entry.Value)
+              .WeakMergeFrom((IMessageLite)entry.Value)
               .WeakBuildPartial();
         } else {
           // Just overwrite
diff --git a/src/ProtocolBuffers/GeneratedExtensionBase.cs b/src/ProtocolBuffers/GeneratedExtensionBase.cs
index 9896a462..36da58e6 100644
--- a/src/ProtocolBuffers/GeneratedExtensionBase.cs
+++ b/src/ProtocolBuffers/GeneratedExtensionBase.cs
@@ -80,6 +80,7 @@ namespace Google.ProtocolBuffers {
         if (defaultInstanceProperty == null) {
           throw new ArgumentException("No public static DefaultInstance property for type " + typeof(TExtension).Name);
         }
+#warning ToDo - Invalid cast, could be IMessageLite
         messageDefaultInstance = (IMessage)defaultInstanceProperty.GetValue(null, null);
       }
     }
@@ -112,7 +113,7 @@ namespace Google.ProtocolBuffers {
             // This should not happen in normal use.  But, to be nice, we'll
             // copy the message to whatever type the caller was expecting.
             return MessageDefaultInstance.WeakCreateBuilderForType()
-                           .WeakMergeFrom((IMessage)value).WeakBuild();
+                           .WeakMergeFrom((IMessageLite)value).WeakBuild();
           }
         case MappedType.Enum:
           // Just return a boxed int - that can be unboxed to the enum
diff --git a/src/ProtocolBuffers/GeneratedExtensionLite.cs b/src/ProtocolBuffers/GeneratedExtensionLite.cs
index 87009cf8..a26088f8 100644
--- a/src/ProtocolBuffers/GeneratedExtensionLite.cs
+++ b/src/ProtocolBuffers/GeneratedExtensionLite.cs
@@ -44,25 +44,10 @@ namespace Google.ProtocolBuffers {
     int Number { get; }
     object ContainingType { get; }
     IMessageLite MessageDefaultInstance { get; }
+    IFieldDescriptorLite Descriptor { get; }
   }
 
   public class ExtensionDescriptorLite : IFieldDescriptorLite {
-    /// <summary>
-    /// Immutable mapping from field type to mapped type. Built using the attributes on
-    /// FieldType values.
-    /// </summary>
-    public static readonly IDictionary<FieldType, MappedType> FieldTypeToMappedTypeMap = MapFieldTypes();
-
-    private static IDictionary<FieldType, MappedType> MapFieldTypes() {
-      var map = new Dictionary<FieldType, MappedType>();
-      foreach (System.Reflection.FieldInfo field in typeof(FieldType).GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)) {
-        FieldType fieldType = (FieldType)field.GetValue(null);
-        FieldMappingAttribute mapping = (FieldMappingAttribute)field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0];
-        map[fieldType] = mapping.MappedType;
-      }
-      return Dictionaries.AsReadOnly(map);
-    }
-
     private readonly IEnumLiteMap enumTypeMap;
     private readonly int number;
     private readonly FieldType type;
@@ -75,7 +60,7 @@ namespace Google.ProtocolBuffers {
       this.enumTypeMap = enumTypeMap;
       this.number = number;
       this.type = type;
-      this.mapType = FieldTypeToMappedTypeMap[type];
+      this.mapType = FieldMappingAttribute.MappedTypeFromFieldType(type);
       this.isRepeated = isRepeated;
       this.isPacked = isPacked;
       this.defaultValue = defaultValue;
@@ -99,7 +84,7 @@ namespace Google.ProtocolBuffers {
 
 #warning ToDo - Discover the meaning and purpose of this durring serialization and return the correct value
     public bool MessageSetWireFormat {
-      get { return true; }
+      get { return false; }
     }
 
     public int FieldNumber {
@@ -135,11 +120,11 @@ namespace Google.ProtocolBuffers {
     }
 
     public override object ToReflectionType(object value) {
-        IList<TExtensionType> result = new List<TExtensionType>();
-        foreach (object element in (IEnumerable)value) {
-          result.Add((TExtensionType)SingularToReflectionType(element));
-        }
-        return result;
+      IList<object> result = new List<object>();
+      foreach (object element in (IEnumerable) value) {
+        result.Add(SingularToReflectionType(element));
+      }
+      return result;
     }
 
     public override object FromReflectionType(object value) {
@@ -191,6 +176,7 @@ namespace Google.ProtocolBuffers {
             false /* isRepeated */, false /* isPacked */)) {
     }
 
+    private static readonly IList<object> Empty = new object[0];
     /** Repeating fields: For use by generated code only. */
     protected GeneratedExtensionLite(
       TContainingType containingTypeDefaultInstance,
@@ -201,7 +187,7 @@ namespace Google.ProtocolBuffers {
       FieldType type,
       bool isPacked)
       : this(containingTypeDefaultInstance, defaultValue, messageDefaultInstance,
-          new ExtensionDescriptorLite(enumTypeMap, number, type, defaultValue,
+          new ExtensionDescriptorLite(enumTypeMap, number, type, Empty,
             true /* isRepeated */, isPacked)) {
     }
 
diff --git a/src/ProtocolBuffers/GeneratedMessage.cs b/src/ProtocolBuffers/GeneratedMessage.cs
index d60f2b9c..fe1188b6 100644
--- a/src/ProtocolBuffers/GeneratedMessage.cs
+++ b/src/ProtocolBuffers/GeneratedMessage.cs
@@ -99,13 +99,13 @@ namespace Google.ProtocolBuffers {
             if (field.IsRepeated) {
               // We know it's an IList<T>, but not the exact type - so
               // IEnumerable is the best we can do. (C# generics aren't covariant yet.)
-              foreach (IMessage element in (IEnumerable) this[field]) {
+              foreach (IMessageLite element in (IEnumerable) this[field]) {
                 if (!element.IsInitialized) {
                   return false;
                 }
               }
             } else {
-              if (HasField(field) && !((IMessage) this[field]).IsInitialized) {
+              if (HasField(field) && !((IMessageLite) this[field]).IsInitialized) {
                 return false;
               }
             }
diff --git a/src/ProtocolBuffers/TextFormat.cs b/src/ProtocolBuffers/TextFormat.cs
index 5f07e693..81033087 100644
--- a/src/ProtocolBuffers/TextFormat.cs
+++ b/src/ProtocolBuffers/TextFormat.cs
@@ -176,7 +176,11 @@ namespace Google.ProtocolBuffers {
 
         case FieldType.Message:
         case FieldType.Group:
-          Print((IMessage) value, generator);
+          if (value is IMessage) {
+            Print((IMessage)value, generator);
+          } else {
+#warning ToDo - What do we print for IMessageLite?
+          }
           break;
       }
     }
diff --git a/src/ProtocolBuffers/UninitializedMessageException.cs b/src/ProtocolBuffers/UninitializedMessageException.cs
index 12db07df..c5bcd822 100644
--- a/src/ProtocolBuffers/UninitializedMessageException.cs
+++ b/src/ProtocolBuffers/UninitializedMessageException.cs
@@ -124,7 +124,7 @@ namespace Google.ProtocolBuffers {
       foreach (KeyValuePair<FieldDescriptor, object> entry in message.AllFields) {
         FieldDescriptor field = entry.Key;
         object value = entry.Value;
-
+#warning ToDo - bad assumption, could be IMessageLite
         if (field.MappedType == MappedType.Message) {
           if (field.IsRepeated) {
             int i = 0;
diff --git a/src/ProtocolBuffers/UnknownFieldSet.cs b/src/ProtocolBuffers/UnknownFieldSet.cs
index a3e6d7e7..515637cc 100644
--- a/src/ProtocolBuffers/UnknownFieldSet.cs
+++ b/src/ProtocolBuffers/UnknownFieldSet.cs
@@ -578,14 +578,14 @@ namespace Google.ProtocolBuffers {
           switch (field.FieldType) {
             case FieldType.Group:
             case FieldType.Message: {
-                IBuilder subBuilder;
+                IBuilderLite subBuilder;
                 if (defaultFieldInstance != null) {
                   subBuilder = defaultFieldInstance.WeakCreateBuilderForType();
                 } else {
                   subBuilder = builder.CreateBuilderForField(field);
                 }
                 if (!field.IsRepeated) {
-                  subBuilder.WeakMergeFrom((IMessage)builder[field]);
+                  subBuilder.WeakMergeFrom((IMessageLite)builder[field]);
                 }
                 if (field.FieldType == FieldType.Group) {
                   input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry);
@@ -661,7 +661,7 @@ namespace Google.ProtocolBuffers {
               if (extension != null) {
                 field = extension.Descriptor;
                 subBuilder = extension.DefaultInstance.WeakCreateBuilderForType();
-                IMessage originalMessage = (IMessage)builder[field];
+                IMessageLite originalMessage = (IMessageLite)builder[field];
                 if (originalMessage != null) {
                   subBuilder.WeakMergeFrom(originalMessage);
                 }