reflect/protoreflect: replace Mutable with NewMessage

Remove the Mutable methods from KnownFields, List, and Map, replacing
them with methods which return a new, empty message value without adding
that value to the collection.

The new API is simpler, since it clearly applies only to message values,
and more orthogonal, since it provides a way to create a value without
mutating the collection. This latter point is particularly useful in
map deserialization, where the key may be unknown at the time the value
is deserialized.

Drop the Mutable interface, since it is no longer necessary.

Change-Id: Ic5f3d06a2aa331a5d5cd2b4e670a3dba4a74f77c
Reviewed-on: https://go-review.googlesource.com/c/153278
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
diff --git a/internal/impl/message_test.go b/internal/impl/message_test.go
index 935b9f8..f49e5c1 100644
--- a/internal/impl/message_test.go
+++ b/internal/impl/message_test.go
@@ -229,7 +229,6 @@
 func (m *ScalarProto2) UnknownFields() pref.UnknownFields { return scalarProto2Type.UnknownFieldsOf(m) }
 func (m *ScalarProto2) Interface() pref.ProtoMessage      { return m }
 func (m *ScalarProto2) ProtoReflect() pref.Message        { return m }
-func (m *ScalarProto2) ProtoMutable()                     {}
 
 func TestScalarProto2(t *testing.T) {
 	testMessage(t, nil, &ScalarProto2{}, messageOps{
@@ -336,7 +335,6 @@
 func (m *ScalarProto3) UnknownFields() pref.UnknownFields { return scalarProto3Type.UnknownFieldsOf(m) }
 func (m *ScalarProto3) Interface() pref.ProtoMessage      { return m }
 func (m *ScalarProto3) ProtoReflect() pref.Message        { return m }
-func (m *ScalarProto3) ProtoMutable()                     {}
 
 func TestScalarProto3(t *testing.T) {
 	testMessage(t, nil, &ScalarProto3{}, messageOps{
@@ -454,7 +452,6 @@
 func (m *ListScalars) UnknownFields() pref.UnknownFields { return listScalarsType.UnknownFieldsOf(m) }
 func (m *ListScalars) Interface() pref.ProtoMessage      { return m }
 func (m *ListScalars) ProtoReflect() pref.Message        { return m }
-func (m *ListScalars) ProtoMutable()                     {}
 
 func TestListScalars(t *testing.T) {
 	empty := &ListScalars{}
@@ -645,7 +642,6 @@
 func (m *MapScalars) UnknownFields() pref.UnknownFields { return mapScalarsType.UnknownFieldsOf(m) }
 func (m *MapScalars) Interface() pref.ProtoMessage      { return m }
 func (m *MapScalars) ProtoReflect() pref.Message        { return m }
-func (m *MapScalars) ProtoMutable()                     {}
 
 func TestMapScalars(t *testing.T) {
 	empty := &MapScalars{}
@@ -804,7 +800,6 @@
 func (m *OneofScalars) UnknownFields() pref.UnknownFields { return oneofScalarsType.UnknownFieldsOf(m) }
 func (m *OneofScalars) Interface() pref.ProtoMessage      { return m }
 func (m *OneofScalars) ProtoReflect() pref.Message        { return m }
-func (m *OneofScalars) ProtoMutable()                     {}
 
 func (*OneofScalars) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
@@ -1030,7 +1025,6 @@
 func (m *EnumMessages) UnknownFields() pref.UnknownFields { return enumMessagesType.UnknownFieldsOf(m) }
 func (m *EnumMessages) Interface() pref.ProtoMessage      { return m }
 func (m *EnumMessages) ProtoReflect() pref.Message        { return m }
-func (m *EnumMessages) ProtoMutable()                     {}
 
 func (*EnumMessages) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
@@ -1223,7 +1217,10 @@
 		case messageFields:
 			for n, tt := range op {
 				p.Push(int(n))
-				testMessage(t, p, fs.Mutable(n).(pref.Message), tt)
+				if !fs.Has(n) {
+					fs.Set(n, V(fs.NewMessage(n)))
+				}
+				testMessage(t, p, fs.Get(n).Message(), tt)
 				p.Pop()
 			}
 		case listFields:
@@ -1285,7 +1282,9 @@
 				v.Append(e)
 			}
 		case appendMessageList:
-			testMessage(t, p, v.MutableAppend().(pref.Message), messageOps(op))
+			m := v.NewMessage().ProtoReflect()
+			v.Append(V(m))
+			testMessage(t, p, m, messageOps(op))
 		case truncList:
 			v.Truncate(int(op))
 		default:
@@ -1335,7 +1334,11 @@
 			}
 		case messageMap:
 			for k, tt := range op {
-				testMessage(t, p, m.Mutable(V(k).MapKey()).(pref.Message), tt)
+				mk := V(k).MapKey()
+				if !m.Has(mk) {
+					m.Set(mk, V(m.NewMessage()))
+				}
+				testMessage(t, p, m.Get(mk).Message(), tt)
 			}
 		case rangeMap:
 			got := map[interface{}]pref.Value{}