internal/impl: support legacy extension fields

Implement support for extension fields for messages that use the v1
data structures for extensions. The legacyExtensionFields type wraps a
v1 map to implement the v2 protoreflect.KnownFields interface.

Working on this change revealed a bug in the dynamic construction of
message types for protobuf messages that had cyclic dependencies (e.g.,
message Foo has a sub-field of message Bar, and Bar has a sub-field of Foo).
In such a situation, a deadlock occurs because initialization code depends on
the very initialization code that is currently running. To break these cycles,
we make some systematic changes listed in the following paragraphs.
Generally speaking, we separate the logic for construction and wrapping,
where constuction does not recursively rely on dependencies,
while wrapping may recursively inspect dependencies.

Promote the MessageType.MessageOf method as a standalone MessageOf function
that dynamically finds the proper *MessageType to use. We make it such that
MessageType only supports two forms of messages types:
* Those that fully implement the v2 API.
* Those that do not implement the v2 API at all.
This removes support for the hybrid form that was exploited by message_test.go

In impl/message_test.go, switch each message to look more like how future
generated messages will look like. This is done in reaction to the fact that
MessageType.MessageOf no longer exists.

In value/{map,vector}.go, fix Unwrap to return a pointer since the underlying
reflect.Value is addressable reference value, not a pointer value.

In value/convert.go, split the logic apart so that obtaining a v2 type and
wrapping a type as v2 are distinct operations. Wrapping requires further
initialization than simply creating the initial message type, and calling it
during initial construction would lead to a deadlock.

In protoreflect/go_type.go, we switch back to a lazy initialization of GoType
to avoid a deadlock since the user-provided fn may rely on the fact that
prototype.GoMessage returned.

Change-Id: I5dea00e36fe1a9899bd2ac0aed2c8e51d5d87420
Reviewed-on: https://go-review.googlesource.com/c/148826
Reviewed-by: Herbie Ong <herbie@google.com>

internal/impl/legacy_enum.go

@@ -16,29 +16,36 @@ import (
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )
 
+// legacyWrapEnum wraps v as a protoreflect.ProtoEnum,
+// where v must be a *struct kind and not implement the v2 API already.
+func legacyWrapEnum(v reflect.Value) pref.ProtoEnum {
+	et := legacyLoadEnumType(v.Type())
+	return et.New(pref.EnumNumber(v.Int()))
+}
+
 var enumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
 
-// wrapLegacyEnum wraps v as a protoreflect.ProtoEnum,
-// where v must be an int32 kind and not implement the v2 API already.
-func wrapLegacyEnum(v reflect.Value) pref.ProtoEnum {
+// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
+// where t must be an int32 kind and not implement the v2 API already.
+func legacyLoadEnumType(t reflect.Type) pref.EnumType {
 	// Fast-path: check if a EnumType is cached for this concrete type.
-	if et, ok := enumTypeCache.Load(v.Type()); ok {
-		return et.(pref.EnumType).New(pref.EnumNumber(v.Int()))
+	if et, ok := enumTypeCache.Load(t); ok {
+		return et.(pref.EnumType)
 	}
 
 	// Slow-path: derive enum descriptor and initialize EnumType.
 	var m sync.Map // map[protoreflect.EnumNumber]proto.Enum
-	ed := loadEnumDesc(v.Type())
+	ed := legacyLoadEnumDesc(t)
 	et := ptype.GoEnum(ed, func(et pref.EnumType, n pref.EnumNumber) pref.ProtoEnum {
 		if e, ok := m.Load(n); ok {
 			return e.(pref.ProtoEnum)
 		}
-		e := &legacyEnumWrapper{num: n, pbTyp: et, goTyp: v.Type()}
+		e := &legacyEnumWrapper{num: n, pbTyp: et, goTyp: t}
 		m.Store(n, e)
 		return e
 	})
-	enumTypeCache.Store(v.Type(), et)
-	return et.(pref.EnumType).New(pref.EnumNumber(v.Int()))
+	enumTypeCache.Store(t, et)
+	return et.(pref.EnumType)
 }
 
 type legacyEnumWrapper struct {
@@ -70,9 +77,11 @@ var (
 
 var enumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
 
-// loadEnumDesc returns an EnumDescriptor derived from the Go type,
+var enumNumberType = reflect.TypeOf(pref.EnumNumber(0))
+
+// legacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
 // which must be an int32 kind and not implement the v2 API already.
-func loadEnumDesc(t reflect.Type) pref.EnumDescriptor {
+func legacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
 	// Fast-path: check if an EnumDescriptor is cached for this concrete type.
 	if v, ok := enumDescCache.Load(t); ok {
 		return v.(pref.EnumDescriptor)
@@ -82,6 +91,9 @@ func loadEnumDesc(t reflect.Type) pref.EnumDescriptor {
 	if t.Kind() != reflect.Int32 || t.PkgPath() == "" {
 		panic(fmt.Sprintf("got %v, want named int32 kind", t))
 	}
+	if t == enumNumberType {
+		panic(fmt.Sprintf("cannot be %v", t))
+	}
 
 	// Derive the enum descriptor from the raw descriptor proto.
 	e := new(ptype.StandaloneEnum)
@@ -91,7 +103,7 @@ func loadEnumDesc(t reflect.Type) pref.EnumDescriptor {
 	}
 	if ed, ok := ev.(legacyEnum); ok {
 		b, idxs := ed.EnumDescriptor()
-		fd := loadFileDesc(b)
+		fd := legacyLoadFileDesc(b)
 
 		// Derive syntax.
 		switch fd.GetSyntax() {

internal/impl/legacy_extension.go

@@ -0,0 +1,353 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package impl
+
+import (
+	"fmt"
+	"reflect"
+
+	protoV1 "github.com/golang/protobuf/proto"
+	ptag "github.com/golang/protobuf/v2/internal/encoding/tag"
+	pvalue "github.com/golang/protobuf/v2/internal/value"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+	ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+func makeLegacyExtensionFieldsFunc(t reflect.Type) func(p *messageDataType) pref.KnownFields {
+	f := makeLegacyExtensionMapFunc(t)
+	if f == nil {
+		return nil
+	}
+	return func(p *messageDataType) pref.KnownFields {
+		return legacyExtensionFields{p.mi, f(p)}
+	}
+}
+
+type legacyExtensionFields struct {
+	mi *MessageType
+	x  legacyExtensionIface
+}
+
+func (p legacyExtensionFields) Len() (n int) {
+	p.x.Range(func(num pref.FieldNumber, _ legacyExtensionEntry) bool {
+		if p.Has(num) {
+			n++
+		}
+		return true
+	})
+	return n
+}
+
+func (p legacyExtensionFields) Has(n pref.FieldNumber) bool {
+	x := p.x.Get(n)
+	if x.val == nil {
+		return false
+	}
+	t := legacyExtensionTypeOf(x.desc)
+	if t.Cardinality() == pref.Repeated {
+		return legacyExtensionValueOf(x.val, t).Vector().Len() > 0
+	}
+	return true
+}
+
+func (p legacyExtensionFields) Get(n pref.FieldNumber) pref.Value {
+	x := p.x.Get(n)
+	if x.desc == nil {
+		return pref.Value{}
+	}
+	t := legacyExtensionTypeOf(x.desc)
+	if x.val == nil {
+		if t.Cardinality() == pref.Repeated {
+			// TODO: What is the zero value for Vectors?
+			// TODO: This logic is racy.
+			v := t.ValueOf(t.New())
+			x.val = legacyExtensionInterfaceOf(v, t)
+			p.x.Set(n, x)
+			return v
+		}
+		if t.Kind() == pref.MessageKind || t.Kind() == pref.GroupKind {
+			// TODO: What is the zero value for Messages?
+			return pref.Value{}
+		}
+		return t.Default()
+	}
+	return legacyExtensionValueOf(x.val, t)
+}
+
+func (p legacyExtensionFields) Set(n pref.FieldNumber, v pref.Value) {
+	x := p.x.Get(n)
+	if x.desc == nil {
+		panic("no extension descriptor registered")
+	}
+	t := legacyExtensionTypeOf(x.desc)
+	x.val = legacyExtensionInterfaceOf(v, t)
+	p.x.Set(n, x)
+}
+
+func (p legacyExtensionFields) Clear(n pref.FieldNumber) {
+	x := p.x.Get(n)
+	if x.desc == nil {
+		return
+	}
+	x.val = nil
+	p.x.Set(n, x)
+}
+
+func (p legacyExtensionFields) Mutable(n pref.FieldNumber) pref.Mutable {
+	x := p.x.Get(n)
+	if x.desc == nil {
+		panic("no extension descriptor registered")
+	}
+	t := legacyExtensionTypeOf(x.desc)
+	if x.val == nil {
+		v := t.ValueOf(t.New())
+		x.val = legacyExtensionInterfaceOf(v, t)
+		p.x.Set(n, x)
+	}
+	return legacyExtensionValueOf(x.val, t).Interface().(pref.Mutable)
+}
+
+func (p legacyExtensionFields) Range(f func(pref.FieldNumber, pref.Value) bool) {
+	p.x.Range(func(n pref.FieldNumber, x legacyExtensionEntry) bool {
+		if p.Has(n) {
+			return f(n, p.Get(n))
+		}
+		return true
+	})
+}
+
+func (p legacyExtensionFields) ExtensionTypes() pref.ExtensionFieldTypes {
+	return legacyExtensionTypes(p)
+}
+
+type legacyExtensionTypes legacyExtensionFields
+
+func (p legacyExtensionTypes) Len() (n int) {
+	p.x.Range(func(_ pref.FieldNumber, x legacyExtensionEntry) bool {
+		if x.desc != nil {
+			n++
+		}
+		return true
+	})
+	return n
+}
+
+func (p legacyExtensionTypes) Register(t pref.ExtensionType) {
+	if p.mi.Type.FullName() != t.ExtendedType().FullName() {
+		panic("extended type mismatch")
+	}
+	if !p.mi.Type.ExtensionRanges().Has(t.Number()) {
+		panic("invalid extension field number")
+	}
+	x := p.x.Get(t.Number())
+	if x.desc != nil {
+		panic("extension descriptor already registered")
+	}
+	x.desc = legacyExtensionDescOf(t, p.mi.goType)
+	p.x.Set(t.Number(), x)
+}
+
+func (p legacyExtensionTypes) Remove(t pref.ExtensionType) {
+	if !p.mi.Type.ExtensionRanges().Has(t.Number()) {
+		return
+	}
+	x := p.x.Get(t.Number())
+	if x.val != nil {
+		panic("value for extension descriptor still populated")
+	}
+	x.desc = nil
+	if len(x.raw) == 0 {
+		p.x.Clear(t.Number())
+	} else {
+		p.x.Set(t.Number(), x)
+	}
+}
+
+func (p legacyExtensionTypes) ByNumber(n pref.FieldNumber) pref.ExtensionType {
+	x := p.x.Get(n)
+	if x.desc != nil {
+		return legacyExtensionTypeOf(x.desc)
+	}
+	return nil
+}
+
+func (p legacyExtensionTypes) ByName(s pref.FullName) (t pref.ExtensionType) {
+	p.x.Range(func(_ pref.FieldNumber, x legacyExtensionEntry) bool {
+		if x.desc != nil && x.desc.Name == string(s) {
+			t = legacyExtensionTypeOf(x.desc)
+			return false
+		}
+		return true
+	})
+	return t
+}
+
+func (p legacyExtensionTypes) Range(f func(pref.ExtensionType) bool) {
+	p.x.Range(func(_ pref.FieldNumber, x legacyExtensionEntry) bool {
+		if x.desc != nil {
+			if !f(legacyExtensionTypeOf(x.desc)) {
+				return false
+			}
+		}
+		return true
+	})
+}
+
+func legacyExtensionDescOf(t pref.ExtensionType, parent reflect.Type) *protoV1.ExtensionDesc {
+	if t, ok := t.(*legacyExtensionType); ok {
+		return t.desc
+	}
+
+	// Determine the v1 extension type, which is unfortunately not the same as
+	// the v2 ExtensionType.GoType.
+	extType := t.GoType()
+	switch extType.Kind() {
+	case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+		extType = reflect.PtrTo(extType) // T -> *T for singular scalar fields
+	case reflect.Ptr:
+		if extType.Elem().Kind() == reflect.Slice {
+			extType = extType.Elem() // *[]T -> []T for repeated fields
+		}
+	}
+
+	// Reconstruct the legacy enum full name, which is an odd mixture of the
+	// proto package name with the Go type name.
+	var enumName string
+	if t.Kind() == pref.EnumKind {
+		enumName = t.GoType().Name()
+		for d, ok := pref.Descriptor(t.EnumType()), true; ok; d, ok = d.Parent() {
+			if fd, _ := d.(pref.FileDescriptor); fd != nil && fd.Package() != "" {
+				enumName = string(fd.Package()) + "." + enumName
+			}
+		}
+	}
+
+	// Construct and return a v1 ExtensionDesc.
+	return &protoV1.ExtensionDesc{
+		ExtendedType:  reflect.Zero(parent).Interface().(protoV1.Message),
+		ExtensionType: reflect.Zero(extType).Interface(),
+		Field:         int32(t.Number()),
+		Name:          string(t.FullName()),
+		Tag:           ptag.Marshal(t, enumName),
+	}
+}
+
+func legacyExtensionTypeOf(d *protoV1.ExtensionDesc) pref.ExtensionType {
+	// TODO: Add a field to protoV1.ExtensionDesc to contain a v2 descriptor.
+
+	// Derive basic field information from the struct tag.
+	t := reflect.TypeOf(d.ExtensionType)
+	isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
+	isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+	if isOptional || isRepeated {
+		t = t.Elem()
+	}
+	f := ptag.Unmarshal(d.Tag, t)
+
+	// Construct a v2 ExtensionType.
+	conv := newConverter(t, f.Kind)
+	xd, err := ptype.NewExtension(&ptype.StandaloneExtension{
+		FullName:     pref.FullName(d.Name),
+		Number:       pref.FieldNumber(d.Field),
+		Cardinality:  f.Cardinality,
+		Kind:         f.Kind,
+		Default:      f.Default,
+		Options:      f.Options,
+		EnumType:     conv.EnumType,
+		MessageType:  conv.MessageType,
+		ExtendedType: legacyLoadMessageDesc(reflect.TypeOf(d.ExtendedType)),
+	})
+	if err != nil {
+		panic(err)
+	}
+	xt := ptype.GoExtension(xd, conv.EnumType, conv.MessageType)
+
+	// Return the extension type as is if the dependencies already support v2.
+	xt2 := &legacyExtensionType{ExtensionType: xt, desc: d}
+	if !conv.IsLegacy {
+		return xt2
+	}
+
+	// If the dependency is a v1 enum or message, we need to create a custom
+	// extension type where ExtensionType.GoType continues to use the legacy
+	// v1 Go type, instead of the wrapped versions that satisfy the v2 API.
+	if xd.Cardinality() != pref.Repeated {
+		// Custom extension type for singular enums and messages.
+		// The legacy wrappers use legacyEnumWrapper and legacyMessageWrapper
+		// to implement the v2 interfaces for enums and messages.
+		// Both of those type satisfy the value.Unwrapper interface.
+		xt2.typ = t
+		xt2.new = func() interface{} {
+			return xt.New().(pvalue.Unwrapper).Unwrap()
+		}
+		xt2.valueOf = func(v interface{}) pref.Value {
+			if reflect.TypeOf(v) != xt2.typ {
+				panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
+			}
+			if xd.Kind() == pref.EnumKind {
+				return xt.ValueOf(legacyWrapEnum(reflect.ValueOf(v)))
+			} else {
+				return xt.ValueOf(legacyWrapMessage(reflect.ValueOf(v)))
+			}
+		}
+		xt2.interfaceOf = func(v pref.Value) interface{} {
+			return xt.InterfaceOf(v).(pvalue.Unwrapper).Unwrap()
+		}
+	} else {
+		// Custom extension type for repeated enums and messages.
+		xt2.typ = reflect.PtrTo(reflect.SliceOf(t))
+		xt2.new = func() interface{} {
+			return reflect.New(xt2.typ.Elem()).Interface()
+		}
+		xt2.valueOf = func(v interface{}) pref.Value {
+			if reflect.TypeOf(v) != xt2.typ {
+				panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
+			}
+			return pref.ValueOf(pvalue.VectorOf(v, conv))
+		}
+		xt2.interfaceOf = func(pv pref.Value) interface{} {
+			v := pv.Vector().(pvalue.Unwrapper).Unwrap()
+			if reflect.TypeOf(v) != xt2.typ {
+				panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
+			}
+			return v
+		}
+	}
+	return xt2
+}
+
+type legacyExtensionType struct {
+	pref.ExtensionType
+	desc        *protoV1.ExtensionDesc
+	typ         reflect.Type
+	new         func() interface{}
+	valueOf     func(interface{}) pref.Value
+	interfaceOf func(pref.Value) interface{}
+}
+
+func (x *legacyExtensionType) GoType() reflect.Type {
+	if x.typ != nil {
+		return x.typ
+	}
+	return x.ExtensionType.GoType()
+}
+func (x *legacyExtensionType) New() interface{} {
+	if x.new != nil {
+		return x.new()
+	}
+	return x.ExtensionType.New()
+}
+func (x *legacyExtensionType) ValueOf(v interface{}) pref.Value {
+	if x.valueOf != nil {
+		return x.valueOf(v)
+	}
+	return x.ExtensionType.ValueOf(v)
+}
+func (x *legacyExtensionType) InterfaceOf(v pref.Value) interface{} {
+	if x.interfaceOf != nil {
+		return x.interfaceOf(v)
+	}
+	return x.ExtensionType.InterfaceOf(v)
+}

internal/impl/legacy_extension_hack.go

@@ -13,10 +13,13 @@ import (
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 )
 
-// TODO: The logic below this is a hack since v1 currently exposes no
-// exported functionality for interacting with these data structures.
-// Eventually make changes to v1 such that v2 can access the necessary
-// fields without relying on unsafe.
+// TODO: The logic in the file is a hack and should be in the v1 repository.
+// We need to break the dependency on proto v1 since it is v1 that will
+// eventually need to depend on v2.
+
+// TODO: The v1 API currently exposes no exported functionality for interacting
+// with the extension data structures. We will need to make changes in v1 so
+// that v2 can access these data structures without relying on unsafe.
 
 var (
 	extTypeA = reflect.TypeOf(map[int32]protoV1.Extension(nil))
@@ -25,8 +28,10 @@ var (
 
 type legacyExtensionIface interface {
 	Len() int
+	Has(pref.FieldNumber) bool
 	Get(pref.FieldNumber) legacyExtensionEntry
 	Set(pref.FieldNumber, legacyExtensionEntry)
+	Clear(pref.FieldNumber)
 	Range(f func(pref.FieldNumber, legacyExtensionEntry) bool)
 }
 
@@ -49,6 +54,13 @@ func makeLegacyExtensionMapFunc(t reflect.Type) func(*messageDataType) legacyExt
 	}
 }
 
+// TODO: We currently don't do locking with legacyExtensionSyncMap.p.mu.
+// The locking behavior was already obscure "feature" beforehand,
+// and it is not obvious how it translates to the v2 API.
+// The v2 API presents a Range method, which calls a user provided function,
+// which may in turn call other methods on the map. In such a use case,
+// acquiring a lock within each method would result in a reentrant deadlock.
+
 // legacyExtensionSyncMap is identical to protoV1.XXX_InternalExtensions.
 // It implements legacyExtensionIface.
 type legacyExtensionSyncMap struct {
@@ -62,16 +74,15 @@ func (m legacyExtensionSyncMap) Len() int {
 	if m.p == nil {
 		return 0
 	}
-	m.p.mu.Lock()
-	defer m.p.mu.Unlock()
 	return m.p.m.Len()
 }
+func (m legacyExtensionSyncMap) Has(n pref.FieldNumber) bool {
+	return m.p.m.Has(n)
+}
 func (m legacyExtensionSyncMap) Get(n pref.FieldNumber) legacyExtensionEntry {
 	if m.p == nil {
 		return legacyExtensionEntry{}
 	}
-	m.p.mu.Lock()
-	defer m.p.mu.Unlock()
 	return m.p.m.Get(n)
 }
 func (m *legacyExtensionSyncMap) Set(n pref.FieldNumber, x legacyExtensionEntry) {
@@ -81,16 +92,15 @@ func (m *legacyExtensionSyncMap) Set(n pref.FieldNumber, x legacyExtensionEntry)
 			m  legacyExtensionMap
 		})
 	}
-	m.p.mu.Lock()
-	defer m.p.mu.Unlock()
 	m.p.m.Set(n, x)
 }
+func (m legacyExtensionSyncMap) Clear(n pref.FieldNumber) {
+	m.p.m.Clear(n)
+}
 func (m legacyExtensionSyncMap) Range(f func(pref.FieldNumber, legacyExtensionEntry) bool) {
 	if m.p == nil {
 		return
 	}
-	m.p.mu.Lock()
-	defer m.p.mu.Unlock()
 	m.p.m.Range(f)
 }
 
@@ -101,6 +111,10 @@ type legacyExtensionMap map[pref.FieldNumber]legacyExtensionEntry
 func (m legacyExtensionMap) Len() int {
 	return len(m)
 }
+func (m legacyExtensionMap) Has(n pref.FieldNumber) bool {
+	_, ok := m[n]
+	return ok
+}
 func (m legacyExtensionMap) Get(n pref.FieldNumber) legacyExtensionEntry {
 	return m[n]
 }
@@ -110,6 +124,9 @@ func (m *legacyExtensionMap) Set(n pref.FieldNumber, x legacyExtensionEntry) {
 	}
 	(*m)[n] = x
 }
+func (m *legacyExtensionMap) Clear(n pref.FieldNumber) {
+	delete(*m, n)
+}
 func (m legacyExtensionMap) Range(f func(pref.FieldNumber, legacyExtensionEntry) bool) {
 	for n, x := range m {
 		if !f(n, x) {
@@ -124,3 +141,76 @@ type legacyExtensionEntry struct {
 	val  interface{}
 	raw  []byte
 }
+
+// TODO: The legacyExtensionInterfaceOf and legacyExtensionValueOf converters
+// exist since the current storage representation in the v1 data structures use
+// *T for scalars and []T for repeated fields, but the v2 API operates on
+// T for scalars and *[]T for repeated fields.
+//
+// Instead of maintaining this technical debt in the v2 repository,
+// we can offload this into the v1 implementation such that it uses a
+// storage representation that is appropriate for v2, and uses the these
+// functions to present the illusion that that the underlying storage
+// is still *T and []T.
+//
+// See https://github.com/golang/protobuf/pull/746
+const hasPR746 = true
+
+// legacyExtensionInterfaceOf converts a protoreflect.Value to the
+// storage representation used in v1 extension data structures.
+//
+// In particular, it represents scalars (except []byte) a pointer to the value,
+// and repeated fields as the a slice value itself.
+func legacyExtensionInterfaceOf(pv pref.Value, t pref.ExtensionType) interface{} {
+	v := t.InterfaceOf(pv)
+	if !hasPR746 {
+		switch rv := reflect.ValueOf(v); rv.Kind() {
+		case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+			// Represent primitive types as a pointer to the value.
+			rv2 := reflect.New(rv.Type())
+			rv2.Elem().Set(rv)
+			v = rv2.Interface()
+		case reflect.Ptr:
+			// Represent pointer to slice types as the value itself.
+			switch rv.Type().Elem().Kind() {
+			case reflect.Slice:
+				if rv.IsNil() {
+					v = reflect.Zero(rv.Type().Elem()).Interface()
+				} else {
+					v = rv.Elem().Interface()
+				}
+			}
+		}
+	}
+	return v
+}
+
+// legacyExtensionValueOf converts the storage representation of a value in
+// the v1 extension data structures to a protoreflect.Value.
+//
+// In particular, it represents scalars as the value itself,
+// and repeated fields as a pointer to the slice value.
+func legacyExtensionValueOf(v interface{}, t pref.ExtensionType) pref.Value {
+	if !hasPR746 {
+		switch rv := reflect.ValueOf(v); rv.Kind() {
+		case reflect.Ptr:
+			// Represent slice types as the value itself.
+			switch rv.Type().Elem().Kind() {
+			case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+				if rv.IsNil() {
+					v = reflect.Zero(rv.Type().Elem()).Interface()
+				} else {
+					v = rv.Elem().Interface()
+				}
+			}
+		case reflect.Slice:
+			// Represent slice types (except []byte) as a pointer to the value.
+			if rv.Type().Elem().Kind() != reflect.Uint8 {
+				rv2 := reflect.New(rv.Type())
+				rv2.Elem().Set(rv)
+				v = rv2.Interface()
+			}
+		}
+	}
+	return t.ValueOf(v)
+}

internal/impl/legacy_file.go

@@ -36,13 +36,13 @@ type (
 
 var fileDescCache sync.Map // map[*byte]*descriptorV1.FileDescriptorProto
 
-// loadFileDesc unmarshals b as a compressed FileDescriptorProto message.
+// legacyLoadFileDesc unmarshals b as a compressed FileDescriptorProto message.
 //
 // This assumes that b is immutable and that b does not refer to part of a
 // concatenated series of GZIP files (which would require shenanigans that
 // rely on the concatenation properties of both protobufs and GZIP).
 // File descriptors generated by protoc-gen-go do not rely on that property.
-func loadFileDesc(b []byte) *descriptorV1.FileDescriptorProto {
+func legacyLoadFileDesc(b []byte) *descriptorV1.FileDescriptorProto {
 	// Fast-path: check whether we already have a cached file descriptor.
 	if v, ok := fileDescCache.Load(&b[0]); ok {
 		return v.(*descriptorV1.FileDescriptorProto)

internal/impl/legacy_message.go

@@ -19,26 +19,38 @@ import (
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )
 
+// legacyWrapMessage wraps v as a protoreflect.ProtoMessage,
+// where v must be a *struct kind and not implement the v2 API already.
+func legacyWrapMessage(v reflect.Value) pref.ProtoMessage {
+	mt := legacyLoadMessageType(v.Type())
+	return (*legacyMessageWrapper)(mt.dataTypeOf(v.Interface()))
+}
+
 var messageTypeCache sync.Map // map[reflect.Type]*MessageType
 
-// wrapLegacyMessage wraps v as a protoreflect.ProtoMessage,
-// where v must be a *struct kind and not implement the v2 API already.
-func wrapLegacyMessage(v reflect.Value) pref.ProtoMessage {
+// legacyLoadMessageType dynamically loads a *MessageType for t,
+// where t must be a *struct kind and not implement the v2 API already.
+func legacyLoadMessageType(t reflect.Type) *MessageType {
 	// Fast-path: check if a MessageType is cached for this concrete type.
-	if mt, ok := messageTypeCache.Load(v.Type()); ok {
-		return mt.(*MessageType).MessageOf(v.Interface()).Interface()
+	if mt, ok := messageTypeCache.Load(t); ok {
+		return mt.(*MessageType)
 	}
 
 	// Slow-path: derive message descriptor and initialize MessageType.
-	mt := &MessageType{Desc: loadMessageDesc(v.Type())}
-	messageTypeCache.Store(v.Type(), mt)
-	return mt.MessageOf(v.Interface()).Interface()
+	md := legacyLoadMessageDesc(t)
+	mt := new(MessageType)
+	mt.Type = ptype.GoMessage(md, func(pref.MessageType) pref.ProtoMessage {
+		p := reflect.New(t.Elem()).Interface()
+		return (*legacyMessageWrapper)(mt.dataTypeOf(p))
+	})
+	messageTypeCache.Store(t, mt)
+	return mt
 }
 
 type legacyMessageWrapper messageDataType
 
 func (m *legacyMessageWrapper) Type() pref.MessageType {
-	return m.mi.pbType
+	return m.mi.Type
 }
 func (m *legacyMessageWrapper) KnownFields() pref.KnownFields {
 	return (*knownFields)(m)
@@ -65,9 +77,9 @@ var (
 
 var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
 
-// loadMessageDesc returns an MessageDescriptor derived from the Go type,
+// legacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
 // which must be a *struct kind and not implement the v2 API already.
-func loadMessageDesc(t reflect.Type) pref.MessageDescriptor {
+func legacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
 	return messageDescSet{}.Load(t)
 }
 
@@ -126,7 +138,7 @@ func (ms *messageDescSet) processMessage(t reflect.Type) pref.MessageDescriptor
 	}
 	if md, ok := mv.(legacyMessage); ok {
 		b, idxs := md.Descriptor()
-		fd := loadFileDesc(b)
+		fd := legacyLoadFileDesc(b)
 
 		// Derive syntax.
 		switch fd.GetSyntax() {
@@ -231,7 +243,7 @@ func (ms *messageDescSet) parseField(tag, tagKey, tagVal string, goType reflect.
 		if ev, ok := reflect.Zero(t).Interface().(pref.ProtoEnum); ok {
 			f.EnumType = ev.ProtoReflect().Type()
 		} else {
-			f.EnumType = loadEnumDesc(t)
+			f.EnumType = legacyLoadEnumDesc(t)
 		}
 	}
 	if f.MessageType == nil && (f.Kind == pref.MessageKind || f.Kind == pref.GroupKind) {

internal/impl/legacy_test.go

@@ -30,7 +30,7 @@ import (
 )
 
 func mustLoadFileDesc(b []byte, _ []int) pref.FileDescriptor {
-	fd, err := ptype.NewFileFromDescriptorProto(loadFileDesc(b), nil)
+	fd, err := ptype.NewFileFromDescriptorProto(legacyLoadFileDesc(b), nil)
 	if err != nil {
 		panic(err)
 	}
@@ -42,286 +42,286 @@ func TestLegacyDescriptor(t *testing.T) {
 
 	fileDescP2_20160225 := mustLoadFileDesc(new(proto2_20160225.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
 		want: fileDescP2_20160225.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
 		want: fileDescP2_20160225.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
 		want: fileDescP2_20160225.Messages().ByName("Message"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("NamedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OptionalGroup))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RequiredGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RequiredGroup))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RepeatedGroup))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OneofGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OneofGroup))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OneofGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionOptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionOptionalGroup))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionRepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionRepeatedGroup))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
 	}}...)
 
 	fileDescP3_20160225 := mustLoadFileDesc(new(proto3_20160225.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
 		want: fileDescP3_20160225.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
 		want: fileDescP3_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
 		want: fileDescP3_20160225.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
 		want: fileDescP3_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message))),
 		want: fileDescP3_20160225.Messages().ByName("Message"),
 	}}...)
 
 	fileDescP2_20160519 := mustLoadFileDesc(new(proto2_20160519.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
 		want: fileDescP2_20160519.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
 		want: fileDescP2_20160519.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
 		want: fileDescP2_20160519.Messages().ByName("Message"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("NamedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OptionalGroup))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RequiredGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RequiredGroup))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RepeatedGroup))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OneofGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OneofGroup))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OneofGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionOptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionOptionalGroup))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionRepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionRepeatedGroup))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
 	}}...)
 
 	fileDescP3_20160519 := mustLoadFileDesc(new(proto3_20160519.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
 		want: fileDescP3_20160519.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
 		want: fileDescP3_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
 		want: fileDescP3_20160519.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
 		want: fileDescP3_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message))),
 		want: fileDescP3_20160519.Messages().ByName("Message"),
 	}}...)
 
 	fileDescP2_20180125 := mustLoadFileDesc(new(proto2_20180125.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
 		want: fileDescP2_20180125.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
 		want: fileDescP2_20180125.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
 		want: fileDescP2_20180125.Messages().ByName("Message"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("NamedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OptionalGroup))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RequiredGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RequiredGroup))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RepeatedGroup))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OneofGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OneofGroup))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OneofGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionOptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionOptionalGroup))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionRepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionRepeatedGroup))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
 	}}...)
 
 	fileDescP3_20180125 := mustLoadFileDesc(new(proto3_20180125.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
 		want: fileDescP3_20180125.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
 		want: fileDescP3_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
 		want: fileDescP3_20180125.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
 		want: fileDescP3_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message))),
 		want: fileDescP3_20180125.Messages().ByName("Message"),
 	}}...)
 
 	fileDescP2_20180430 := mustLoadFileDesc(new(proto2_20180430.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
 		want: fileDescP2_20180430.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
 		want: fileDescP2_20180430.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
 		want: fileDescP2_20180430.Messages().ByName("Message"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("NamedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OptionalGroup))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RequiredGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RequiredGroup))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RepeatedGroup))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OneofGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OneofGroup))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OneofGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionOptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionOptionalGroup))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionRepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionRepeatedGroup))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
 	}}...)
 
 	fileDescP3_20180430 := mustLoadFileDesc(new(proto3_20180430.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
 		want: fileDescP3_20180430.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
 		want: fileDescP3_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
 		want: fileDescP3_20180430.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
 		want: fileDescP3_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message))),
 		want: fileDescP3_20180430.Messages().ByName("Message"),
 	}}...)
 
 	fileDescP2_20180814 := mustLoadFileDesc(new(proto2_20180814.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
 		want: fileDescP2_20180814.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
 		want: fileDescP2_20180814.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
 		want: fileDescP2_20180814.Messages().ByName("Message"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("NamedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OptionalGroup))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RequiredGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RequiredGroup))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RepeatedGroup))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OneofGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OneofGroup))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OneofGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionOptionalGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionOptionalGroup))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionRepeatedGroup))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionRepeatedGroup))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
 	}}...)
 
 	fileDescP3_20180814 := mustLoadFileDesc(new(proto3_20180814.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
 		want: fileDescP3_20180814.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  loadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
 		want: fileDescP3_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
 		want: fileDescP3_20180814.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
 		want: fileDescP3_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
 		want: fileDescP3_20180814.Messages().ByName("Message"),
 	}}...)
 
@@ -383,13 +383,16 @@ func TestLegacyDescriptor(t *testing.T) {
 	}
 }
 
-type legacyUnknownMessage struct {
+type legacyTestMessage struct {
 	XXX_unrecognized []byte
 	protoV1.XXX_InternalExtensions
 }
 
-func (*legacyUnknownMessage) ExtensionRangeArray() []protoV1.ExtensionRange {
-	return []protoV1.ExtensionRange{{Start: 10, End: 20}, {Start: 40, End: 80}}
+func (*legacyTestMessage) Reset()         {}
+func (*legacyTestMessage) String() string { return "" }
+func (*legacyTestMessage) ProtoMessage()  {}
+func (*legacyTestMessage) ExtensionRangeArray() []protoV1.ExtensionRange {
+	return []protoV1.ExtensionRange{{Start: 10, End: 20}, {Start: 40, End: 80}, {Start: 10000, End: 20000}}
 }
 
 func TestLegacyUnknown(t *testing.T) {
@@ -422,8 +425,8 @@ func TestLegacyUnknown(t *testing.T) {
 		return out
 	}
 
-	m := new(legacyUnknownMessage)
-	fs := new(MessageType).MessageOf(m).UnknownFields()
+	m := new(legacyTestMessage)
+	fs := MessageOf(m).UnknownFields()
 
 	if got, want := fs.Len(), 0; got != want {
 		t.Errorf("Len() = %d, want %d", got, want)
@@ -618,3 +621,284 @@ func TestLegacyUnknown(t *testing.T) {
 		return i < 2
 	})
 }
+
+func TestLegactExtensions(t *testing.T) {
+	extensions := []pref.ExtensionType{
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: (*bool)(nil),
+			Field:         10000,
+			Name:          "fizz.buzz.optional_bool",
+			Tag:           "varint,10000,opt,name=optional_bool,json=optionalBool,def=1",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: (*int32)(nil),
+			Field:         10001,
+			Name:          "fizz.buzz.optional_int32",
+			Tag:           "varint,10001,opt,name=optional_int32,json=optionalInt32,def=-12345",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: (*uint32)(nil),
+			Field:         10002,
+			Name:          "fizz.buzz.optional_uint32",
+			Tag:           "varint,10002,opt,name=optional_uint32,json=optionalUint32,def=3200",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: (*float32)(nil),
+			Field:         10003,
+			Name:          "fizz.buzz.optional_float",
+			Tag:           "fixed32,10003,opt,name=optional_float,json=optionalFloat,def=3.14159",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: (*string)(nil),
+			Field:         10004,
+			Name:          "fizz.buzz.optional_string",
+			Tag:           "bytes,10004,opt,name=optional_string,json=optionalString,def=hello, \"world!\"\n",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]byte)(nil),
+			Field:         10005,
+			Name:          "fizz.buzz.optional_bytes",
+			Tag:           "bytes,10005,opt,name=optional_bytes,json=optionalBytes,def=dead\\336\\255\\276\\357beef",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: (*proto2_20180125.Message_ChildEnum)(nil),
+			Field:         10006,
+			Name:          "fizz.buzz.optional_enum",
+			Tag:           "varint,10006,opt,name=optional_enum,json=optionalEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil),
+			Field:         10007,
+			Name:          "fizz.buzz.optional_message",
+			Tag:           "bytes,10007,opt,name=optional_message,json=optionalMessage",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		// TODO: Test v2 enum and messages.
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]bool)(nil),
+			Field:         10008,
+			Name:          "fizz.buzz.repeated_bool",
+			Tag:           "varint,10008,rep,name=repeated_bool,json=repeatedBool",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]int32)(nil),
+			Field:         10009,
+			Name:          "fizz.buzz.repeated_int32",
+			Tag:           "varint,10009,rep,name=repeated_int32,json=repeatedInt32",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]uint32)(nil),
+			Field:         10010,
+			Name:          "fizz.buzz.repeated_uint32",
+			Tag:           "varint,10010,rep,name=repeated_uint32,json=repeatedUint32",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]float32)(nil),
+			Field:         10011,
+			Name:          "fizz.buzz.repeated_float",
+			Tag:           "fixed32,10011,rep,name=repeated_float,json=repeatedFloat",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]string)(nil),
+			Field:         10012,
+			Name:          "fizz.buzz.repeated_string",
+			Tag:           "bytes,10012,rep,name=repeated_string,json=repeatedString",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([][]byte)(nil),
+			Field:         10013,
+			Name:          "fizz.buzz.repeated_bytes",
+			Tag:           "bytes,10013,rep,name=repeated_bytes,json=repeatedBytes",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]proto2_20180125.Message_ChildEnum)(nil),
+			Field:         10014,
+			Name:          "fizz.buzz.repeated_enum",
+			Tag:           "varint,10014,rep,name=repeated_enum,json=repeatedEnum,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		legacyExtensionTypeOf(&protoV1.ExtensionDesc{
+			ExtendedType:  (*legacyTestMessage)(nil),
+			ExtensionType: ([]*proto2_20180125.Message_ChildMessage)(nil),
+			Field:         10015,
+			Name:          "fizz.buzz.repeated_message",
+			Tag:           "bytes,10015,rep,name=repeated_message,json=repeatedMessage",
+			Filename:      "fizz/buzz/test.proto",
+		}),
+		// TODO: Test v2 enum and messages.
+	}
+	opts := cmp.Options{cmp.Comparer(func(x, y *proto2_20180125.Message_ChildMessage) bool {
+		return x == y // pointer compare messages for object identity
+	})}
+
+	m := new(legacyTestMessage)
+	fs := MessageOf(m).KnownFields()
+	ts := fs.ExtensionTypes()
+
+	if n := fs.Len(); n != 0 {
+		t.Errorf("KnownFields.Len() = %v, want 0", n)
+	}
+	if n := ts.Len(); n != 0 {
+		t.Errorf("ExtensionFieldTypes.Len() = %v, want 0", n)
+	}
+
+	// Register all the extension types.
+	for _, xt := range extensions {
+		ts.Register(xt)
+	}
+
+	// Check that getting the zero value returns the default value for scalars,
+	// nil for singular messages, and an empty vector for repeated fields.
+	defaultValues := []interface{}{
+		bool(true),
+		int32(-12345),
+		uint32(3200),
+		float32(3.14159),
+		string("hello, \"world!\"\n"),
+		[]byte("dead\xde\xad\xbe\xefbeef"),
+		proto2_20180125.Message_ALPHA,
+		nil,
+		new([]bool),
+		new([]int32),
+		new([]uint32),
+		new([]float32),
+		new([]string),
+		new([][]byte),
+		new([]proto2_20180125.Message_ChildEnum),
+		new([]*proto2_20180125.Message_ChildMessage),
+	}
+	for i, xt := range extensions {
+		var got interface{}
+		v := fs.Get(xt.Number())
+		if xt.Cardinality() != pref.Repeated && xt.Kind() == pref.MessageKind {
+			got = v.Interface()
+		} else {
+			got = xt.InterfaceOf(v) // TODO: Simplify this if InterfaceOf allows nil
+		}
+		want := defaultValues[i]
+		if diff := cmp.Diff(want, got, opts); diff != "" {
+			t.Errorf("KnownFields.Get(%d) mismatch (-want +got):\n%v", xt.Number(), diff)
+		}
+	}
+
+	// All fields should be unpopulated.
+	for _, xt := range extensions {
+		if fs.Has(xt.Number()) {
+			t.Errorf("KnownFields.Has(%d) = true, want false", xt.Number())
+		}
+	}
+
+	// Set some values and append to values to the vectors.
+	m1 := &proto2_20180125.Message_ChildMessage{F1: protoV1.String("m1")}
+	m2 := &proto2_20180125.Message_ChildMessage{F1: protoV1.String("m2")}
+	setValues := []interface{}{
+		bool(false),
+		int32(-54321),
+		uint32(6400),
+		float32(2.71828),
+		string("goodbye, \"world!\"\n"),
+		[]byte("live\xde\xad\xbe\xefchicken"),
+		proto2_20180125.Message_CHARLIE,
+		m1,
+		&[]bool{true},
+		&[]int32{-1000},
+		&[]uint32{1280},
+		&[]float32{1.6180},
+		&[]string{"zero"},
+		&[][]byte{[]byte("zero")},
+		&[]proto2_20180125.Message_ChildEnum{proto2_20180125.Message_BRAVO},
+		&[]*proto2_20180125.Message_ChildMessage{m2},
+	}
+	for i, xt := range extensions {
+		fs.Set(xt.Number(), xt.ValueOf(setValues[i]))
+	}
+	for i, xt := range extensions[len(extensions)/2:] {
+		v := extensions[i].ValueOf(setValues[i])
+		fs.Get(xt.Number()).Vector().Append(v)
+	}
+
+	// Get the values and check for equality.
+	getValues := []interface{}{
+		bool(false),
+		int32(-54321),
+		uint32(6400),
+		float32(2.71828),
+		string("goodbye, \"world!\"\n"),
+		[]byte("live\xde\xad\xbe\xefchicken"),
+		proto2_20180125.Message_ChildEnum(proto2_20180125.Message_CHARLIE),
+		m1,
+		&[]bool{true, false},
+		&[]int32{-1000, -54321},
+		&[]uint32{1280, 6400},
+		&[]float32{1.6180, 2.71828},
+		&[]string{"zero", "goodbye, \"world!\"\n"},
+		&[][]byte{[]byte("zero"), []byte("live\xde\xad\xbe\xefchicken")},
+		&[]proto2_20180125.Message_ChildEnum{proto2_20180125.Message_BRAVO, proto2_20180125.Message_CHARLIE},
+		&[]*proto2_20180125.Message_ChildMessage{m2, m1},
+	}
+	for i, xt := range extensions {
+		got := xt.InterfaceOf(fs.Get(xt.Number()))
+		want := getValues[i]
+		if diff := cmp.Diff(want, got, opts); diff != "" {
+			t.Errorf("KnownFields.Get(%d) mismatch (-want +got):\n%v", xt.Number(), diff)
+		}
+	}
+
+	if n := fs.Len(); n != 16 {
+		t.Errorf("KnownFields.Len() = %v, want 0", n)
+	}
+	if n := ts.Len(); n != 16 {
+		t.Errorf("ExtensionFieldTypes.Len() = %v, want 16", n)
+	}
+
+	// Clear the field for all extension types.
+	for _, xt := range extensions {
+		fs.Clear(xt.Number())
+	}
+	if n := fs.Len(); n != 0 {
+		t.Errorf("KnownFields.Len() = %v, want 0", n)
+	}
+	if n := ts.Len(); n != 16 {
+		t.Errorf("ExtensionFieldTypes.Len() = %v, want 16", n)
+	}
+
+	// De-register all extension types.
+	for _, xt := range extensions {
+		ts.Remove(xt)
+	}
+	if n := fs.Len(); n != 0 {
+		t.Errorf("KnownFields.Len() = %v, want 0", n)
+	}
+	if n := ts.Len(); n != 0 {
+		t.Errorf("ExtensionFieldTypes.Len() = %v, want 0", n)
+	}
+
+}

internal/impl/legacy_unknown.go

@@ -29,7 +29,7 @@ func makeLegacyUnknownFieldsFunc(t reflect.Type) func(p *messageDataType) pref.U
 	if extFunc != nil {
 		return func(p *messageDataType) pref.UnknownFields {
 			return &legacyUnknownBytesAndExtensionMap{
-				unkFunc(p), extFunc(p), p.mi.Desc.ExtensionRanges(),
+				unkFunc(p), extFunc(p), p.mi.Type.ExtensionRanges(),
 			}
 		}
 	}

internal/impl/message.go

@@ -12,24 +12,30 @@ import (
 	"sync"
 
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
-	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )
 
+// MessageOf returns the protoreflect.Message interface over p.
+// If p already implements proto.Message, then it directly calls the
+// ProtoReflect method, otherwise it wraps the legacy v1 message to implement
+// the v2 reflective interface.
+func MessageOf(p interface{}) pref.Message {
+	if m, ok := p.(pref.ProtoMessage); ok {
+		return m.ProtoReflect()
+	}
+	return legacyWrapMessage(reflect.ValueOf(p)).ProtoReflect()
+}
+
 // MessageType provides protobuf related functionality for a given Go type
 // that represents a message. A given instance of MessageType is tied to
 // exactly one Go type, which must be a pointer to a struct type.
 type MessageType struct {
-	// Desc is an optionally provided message descriptor. If nil, the descriptor
-	// is lazily derived from the Go type information of generated messages
-	// for the v1 API.
-	//
+	// Type is the underlying message type and must be populated.
 	// Once set, this field must never be mutated.
-	Desc pref.MessageDescriptor
+	Type pref.MessageType
 
 	once sync.Once // protects all unexported fields
 
-	goType reflect.Type     // pointer to struct
-	pbType pref.MessageType // only valid if goType does not implement proto.Message
+	goType reflect.Type // pointer to struct
 
 	// TODO: Split fields into dense and sparse maps similar to the current
 	// table-driven implementation in v1?
@@ -45,33 +51,12 @@ type MessageType struct {
 // It must be called at the start of every exported method.
 func (mi *MessageType) init(p interface{}) {
 	mi.once.Do(func() {
-		v := reflect.ValueOf(p)
-		t := v.Type()
+		t := reflect.TypeOf(p)
 		if t.Kind() != reflect.Ptr && t.Elem().Kind() != reflect.Struct {
 			panic(fmt.Sprintf("got %v, want *struct kind", t))
 		}
 		mi.goType = t
 
-		// Derive the message descriptor if unspecified.
-		if mi.Desc == nil {
-			mi.Desc = loadMessageDesc(t)
-		}
-
-		// Initialize the Go message type wrapper if the Go type does not
-		// implement the proto.Message interface.
-		//
-		// Otherwise, we assume that the Go type manually implements the
-		// interface and is internally consistent such that:
-		//	goType == reflect.New(goType.Elem()).Interface().(proto.Message).ProtoReflect().Type().GoType()
-		//
-		// Generated code ensures that this property holds.
-		if _, ok := p.(pref.ProtoMessage); !ok {
-			mi.pbType = ptype.GoMessage(mi.Desc, func(pref.MessageType) pref.ProtoMessage {
-				p := reflect.New(t.Elem()).Interface()
-				return (*legacyMessageWrapper)(mi.dataTypeOf(p))
-			})
-		}
-
 		mi.makeKnownFieldsFunc(t.Elem())
 		mi.makeUnknownFieldsFunc(t.Elem())
 		mi.makeExtensionFieldsFunc(t.Elem())
@@ -86,10 +71,9 @@ func (mi *MessageType) init(p interface{}) {
 	}
 }
 
-// makeKnownFieldsFunc generates per-field functions for all operations
-// to be performed on each field. It takes in a reflect.Type representing the
-// Go struct, and a protoreflect.MessageDescriptor to match with the fields
-// in the struct.
+// makeKnownFieldsFunc generates functions for operations that can be performed
+// on each protobuf message field. It takes in a reflect.Type representing the
+// Go struct and matches message fields with struct fields.
 //
 // This code assumes that the struct is well-formed and panics if there are
 // any discrepancies.
@@ -136,8 +120,8 @@ fieldLoop:
 	}
 
 	mi.fields = map[pref.FieldNumber]*fieldInfo{}
-	for i := 0; i < mi.Desc.Fields().Len(); i++ {
-		fd := mi.Desc.Fields().Get(i)
+	for i := 0; i < mi.Type.Fields().Len(); i++ {
+		fd := mi.Type.Fields().Get(i)
 		fs := fields[fd.Number()]
 		var fi fieldInfo
 		switch {
@@ -169,33 +153,25 @@ func (mi *MessageType) makeUnknownFieldsFunc(t reflect.Type) {
 }
 
 func (mi *MessageType) makeExtensionFieldsFunc(t reflect.Type) {
-	// TODO
+	if f := makeLegacyExtensionFieldsFunc(t); f != nil {
+		mi.extensionFields = f
+		return
+	}
 	mi.extensionFields = func(*messageDataType) pref.KnownFields {
 		return emptyExtensionFields{}
 	}
 }
 
-func (mi *MessageType) MessageOf(p interface{}) pref.Message {
-	mi.init(p)
-	if m, ok := p.(pref.ProtoMessage); ok {
-		// We assume p properly implements protoreflect.Message.
-		// See the comment in MessageType.init regarding pbType.
-		return m.ProtoReflect()
-	}
-	return (*legacyMessageWrapper)(mi.dataTypeOf(p))
-}
-
 func (mi *MessageType) KnownFieldsOf(p interface{}) pref.KnownFields {
-	mi.init(p)
 	return (*knownFields)(mi.dataTypeOf(p))
 }
 
 func (mi *MessageType) UnknownFieldsOf(p interface{}) pref.UnknownFields {
-	mi.init(p)
 	return mi.unknownFields(mi.dataTypeOf(p))
 }
 
 func (mi *MessageType) dataTypeOf(p interface{}) *messageDataType {
+	mi.init(p)
 	return &messageDataType{pointerOfIface(&p), mi}
 }
 
@@ -249,20 +225,30 @@ func (fs *knownFields) Set(n pref.FieldNumber, v pref.Value) {
 		fi.set(fs.p, v)
 		return
 	}
-	fs.extensionFields().Set(n, v)
+	if fs.mi.Type.ExtensionRanges().Has(n) {
+		fs.extensionFields().Set(n, v)
+		return
+	}
+	panic(fmt.Sprintf("invalid field: %d", n))
 }
 func (fs *knownFields) Clear(n pref.FieldNumber) {
 	if fi := fs.mi.fields[n]; fi != nil {
 		fi.clear(fs.p)
 		return
 	}
-	fs.extensionFields().Clear(n)
+	if fs.mi.Type.ExtensionRanges().Has(n) {
+		fs.extensionFields().Clear(n)
+		return
+	}
 }
 func (fs *knownFields) Mutable(n pref.FieldNumber) pref.Mutable {
 	if fi := fs.mi.fields[n]; fi != nil {
 		return fi.mutable(fs.p)
 	}
-	return fs.extensionFields().Mutable(n)
+	if fs.mi.Type.ExtensionRanges().Has(n) {
+		return fs.extensionFields().Mutable(n)
+	}
+	panic(fmt.Sprintf("invalid field: %d", n))
 }
 func (fs *knownFields) Range(f func(pref.FieldNumber, pref.Value) bool) {
 	for n, fi := range fs.mi.fields {
@@ -291,14 +277,14 @@ func (emptyUnknownFields) IsSupported() bool                                 { r
 
 type emptyExtensionFields struct{}
 
-func (emptyExtensionFields) Len() int                                        { return 0 }
-func (emptyExtensionFields) Has(pref.FieldNumber) bool                       { return false }
-func (emptyExtensionFields) Get(pref.FieldNumber) pref.Value                 { return pref.Value{} }
-func (emptyExtensionFields) Set(pref.FieldNumber, pref.Value)                { panic("extensions not supported") }
-func (emptyExtensionFields) Clear(pref.FieldNumber)                          { return } // noop
-func (emptyExtensionFields) Mutable(pref.FieldNumber) pref.Mutable           { panic("extensions not supported") }
-func (emptyExtensionFields) Range(f func(pref.FieldNumber, pref.Value) bool) { return }
-func (emptyExtensionFields) ExtensionTypes() pref.ExtensionFieldTypes        { return emptyExtensionTypes{} }
+func (emptyExtensionFields) Len() int                                      { return 0 }
+func (emptyExtensionFields) Has(pref.FieldNumber) bool                     { return false }
+func (emptyExtensionFields) Get(pref.FieldNumber) pref.Value               { return pref.Value{} }
+func (emptyExtensionFields) Set(pref.FieldNumber, pref.Value)              { panic("extensions not supported") }
+func (emptyExtensionFields) Clear(pref.FieldNumber)                        { return } // noop
+func (emptyExtensionFields) Mutable(pref.FieldNumber) pref.Mutable         { panic("extensions not supported") }
+func (emptyExtensionFields) Range(func(pref.FieldNumber, pref.Value) bool) { return }
+func (emptyExtensionFields) ExtensionTypes() pref.ExtensionFieldTypes      { return emptyExtensionTypes{} }
 
 type emptyExtensionTypes struct{}
 

internal/impl/message_field.go

@@ -9,7 +9,7 @@ import (
 	"reflect"
 
 	"github.com/golang/protobuf/v2/internal/flags"
-	"github.com/golang/protobuf/v2/internal/value"
+	pvalue "github.com/golang/protobuf/v2/internal/value"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 )
 
@@ -42,7 +42,7 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, ot refle
 	if !reflect.PtrTo(ot).Implements(ft) {
 		panic(fmt.Sprintf("invalid type: %v does not implement %v", ot, ft))
 	}
-	conv := value.NewLegacyConverter(ot.Field(0).Type, fd.Kind(), wrapLegacyEnum, wrapLegacyMessage)
+	conv := newConverter(ot.Field(0).Type, fd.Kind())
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -106,8 +106,8 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo
 	if ft.Kind() != reflect.Map {
 		panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
 	}
-	keyConv := value.NewLegacyConverter(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind(), wrapLegacyEnum, wrapLegacyMessage)
-	valConv := value.NewLegacyConverter(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind(), wrapLegacyEnum, wrapLegacyMessage)
+	keyConv := newConverter(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind())
+	valConv := newConverter(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind())
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -117,11 +117,11 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo
 		},
 		get: func(p pointer) pref.Value {
 			v := p.apply(fieldOffset).asType(fs.Type).Interface()
-			return pref.ValueOf(value.MapOf(v, keyConv, valConv))
+			return pref.ValueOf(pvalue.MapOf(v, keyConv, valConv))
 		},
 		set: func(p pointer, v pref.Value) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			rv.Set(reflect.ValueOf(v.Map().(value.Unwrapper).Unwrap()))
+			rv.Set(reflect.ValueOf(v.Map().(pvalue.Unwrapper).Unwrap()).Elem())
 		},
 		clear: func(p pointer) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -129,7 +129,7 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo
 		},
 		mutable: func(p pointer) pref.Mutable {
 			v := p.apply(fieldOffset).asType(fs.Type).Interface()
-			return value.MapOf(v, keyConv, valConv)
+			return pvalue.MapOf(v, keyConv, valConv)
 		},
 	}
 }
@@ -139,7 +139,7 @@ func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 	if ft.Kind() != reflect.Slice {
 		panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
 	}
-	conv := value.NewLegacyConverter(ft.Elem(), fd.Kind(), wrapLegacyEnum, wrapLegacyMessage)
+	conv := newConverter(ft.Elem(), fd.Kind())
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -149,11 +149,11 @@ func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 		},
 		get: func(p pointer) pref.Value {
 			v := p.apply(fieldOffset).asType(fs.Type).Interface()
-			return pref.ValueOf(value.VectorOf(v, conv))
+			return pref.ValueOf(pvalue.VectorOf(v, conv))
 		},
 		set: func(p pointer, v pref.Value) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			rv.Set(reflect.ValueOf(v.Vector().(value.Unwrapper).Unwrap()))
+			rv.Set(reflect.ValueOf(v.Vector().(pvalue.Unwrapper).Unwrap()).Elem())
 		},
 		clear: func(p pointer) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -161,7 +161,7 @@ func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 		},
 		mutable: func(p pointer) pref.Mutable {
 			v := p.apply(fieldOffset).asType(fs.Type).Interface()
-			return value.VectorOf(v, conv)
+			return pvalue.VectorOf(v, conv)
 		},
 	}
 }
@@ -179,7 +179,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 			ft = ft.Elem()
 		}
 	}
-	conv := value.NewLegacyConverter(ft, fd.Kind(), wrapLegacyEnum, wrapLegacyMessage)
+	conv := newConverter(ft, fd.Kind())
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -244,7 +244,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 
 func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
 	ft := fs.Type
-	conv := value.NewLegacyConverter(ft, fd.Kind(), wrapLegacyEnum, wrapLegacyMessage)
+	conv := newConverter(ft, fd.Kind())
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -282,3 +282,12 @@ func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldI
 		},
 	}
 }
+
+// newConverter calls value.NewLegacyConverter with the necessary constructor
+// functions for legacy enum and message support.
+func newConverter(t reflect.Type, k pref.Kind) pvalue.Converter {
+	messageType := func(t reflect.Type) pref.MessageType {
+		return legacyLoadMessageType(t).Type
+	}
+	return pvalue.NewLegacyConverter(t, k, legacyLoadEnumType, messageType, legacyWrapMessage)
+}

internal/impl/message_test.go

@@ -13,7 +13,6 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 
-	"github.com/golang/protobuf/proto"
 	protoV1 "github.com/golang/protobuf/proto"
 	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
@@ -46,29 +45,8 @@ type (
 
 	MapStrings map[MyString]MyString
 	MapBytes   map[MyString]MyBytes
-
-	MyEnumV1 pref.EnumNumber
-	MyEnumV2 string
-	myEnumV2 MyEnumV2
-
-	MyMessageV1 struct {
-		// SubMessage *Message
-	}
-	MyMessageV2 map[pref.FieldNumber]pref.Value
-	myMessageV2 MyMessageV2
 )
 
-func (e MyEnumV2) ProtoReflect() pref.Enum { return myEnumV2(e) }
-func (e myEnumV2) Type() pref.EnumType     { return nil } // TODO
-func (e myEnumV2) Number() pref.EnumNumber { return 0 }   // TODO
-
-func (m *MyMessageV2) ProtoReflect() pref.Message        { return (*myMessageV2)(m) }
-func (m *myMessageV2) Type() pref.MessageType            { return nil } // TODO
-func (m *myMessageV2) KnownFields() pref.KnownFields     { return nil } // TODO
-func (m *myMessageV2) UnknownFields() pref.UnknownFields { return nil } // TODO
-func (m *myMessageV2) Interface() pref.ProtoMessage      { return (*MyMessageV2)(m) }
-func (m *myMessageV2) ProtoMutable()                     {}
-
 // List of test operations to perform on messages, vectors, or maps.
 type (
 	messageOp  interface{} // equalMessage | hasFields | getFields | setFields | clearFields | vectorFields | mapFields
@@ -143,8 +121,8 @@ type ScalarProto2 struct {
 	MyBytesA  *MyString  `protobuf:"22"`
 }
 
-func TestScalarProto2(t *testing.T) {
-	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
+var scalarProto2Type = MessageType{Type: ptype.GoMessage(
+	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "ScalarProto2",
 		Fields: []ptype.Field{
@@ -172,9 +150,21 @@ func TestScalarProto2(t *testing.T) {
 			{Name: "f21", Number: 21, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("21"))},
 			{Name: "f22", Number: 22, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("22"))},
 		},
-	})}
+	}),
+	func(pref.MessageType) pref.ProtoMessage {
+		return new(ScalarProto2)
+	},
+)}
+
+func (m *ScalarProto2) Type() pref.MessageType            { return scalarProto2Type.Type }
+func (m *ScalarProto2) KnownFields() pref.KnownFields     { return scalarProto2Type.KnownFieldsOf(m) }
+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()                     {}
 
-	testMessage(t, nil, mi.MessageOf(&ScalarProto2{}), messageOps{
+func TestScalarProto2(t *testing.T) {
+	testMessage(t, nil, &ScalarProto2{}, messageOps{
 		hasFields{
 			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
 			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
@@ -191,15 +181,15 @@ func TestScalarProto2(t *testing.T) {
 			1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true,
 			12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true,
 		},
-		equalMessage(mi.MessageOf(&ScalarProto2{
+		equalMessage(&ScalarProto2{
 			new(bool), new(int32), new(int64), new(uint32), new(uint64), new(float32), new(float64), new(string), []byte{}, []byte{}, new(string),
 			new(MyBool), new(MyInt32), new(MyInt64), new(MyUint32), new(MyUint64), new(MyFloat32), new(MyFloat64), new(MyString), MyBytes{}, MyBytes{}, new(MyString),
-		})),
+		}),
 		clearFields{
 			1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true,
 			12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true,
 		},
-		equalMessage(mi.MessageOf(&ScalarProto2{})),
+		equalMessage(&ScalarProto2{}),
 	})
 }
 
@@ -229,8 +219,8 @@ type ScalarProto3 struct {
 	MyBytesA  MyString  `protobuf:"22"`
 }
 
-func TestScalarProto3(t *testing.T) {
-	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
+var scalarProto3Type = MessageType{Type: ptype.GoMessage(
+	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto3,
 		FullName: "ScalarProto3",
 		Fields: []ptype.Field{
@@ -258,9 +248,21 @@ func TestScalarProto3(t *testing.T) {
 			{Name: "f21", Number: 21, Cardinality: pref.Optional, Kind: pref.BytesKind},
 			{Name: "f22", Number: 22, Cardinality: pref.Optional, Kind: pref.BytesKind},
 		},
-	})}
+	}),
+	func(pref.MessageType) pref.ProtoMessage {
+		return new(ScalarProto3)
+	},
+)}
+
+func (m *ScalarProto3) Type() pref.MessageType            { return scalarProto3Type.Type }
+func (m *ScalarProto3) KnownFields() pref.KnownFields     { return scalarProto3Type.KnownFieldsOf(m) }
+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()                     {}
 
-	testMessage(t, nil, mi.MessageOf(&ScalarProto3{}), messageOps{
+func TestScalarProto3(t *testing.T) {
+	testMessage(t, nil, &ScalarProto3{}, messageOps{
 		hasFields{
 			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
 			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
@@ -277,7 +279,7 @@ func TestScalarProto3(t *testing.T) {
 			1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false,
 			12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false,
 		},
-		equalMessage(mi.MessageOf(&ScalarProto3{})),
+		equalMessage(&ScalarProto3{}),
 		setFields{
 			1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V([]byte("10")), 11: V([]byte("11")),
 			12: V(bool(true)), 13: V(int32(13)), 14: V(int64(14)), 15: V(uint32(15)), 16: V(uint64(16)), 17: V(float32(17)), 18: V(float64(18)), 19: V(string("19")), 20: V(string("20")), 21: V([]byte("21")), 22: V([]byte("22")),
@@ -286,19 +288,19 @@ func TestScalarProto3(t *testing.T) {
 			1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true,
 			12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true,
 		},
-		equalMessage(mi.MessageOf(&ScalarProto3{
+		equalMessage(&ScalarProto3{
 			true, 2, 3, 4, 5, 6, 7, "8", []byte("9"), []byte("10"), "11",
 			true, 13, 14, 15, 16, 17, 18, "19", []byte("20"), []byte("21"), "22",
-		})),
+		}),
 		clearFields{
 			1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true,
 			12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true,
 		},
-		equalMessage(mi.MessageOf(&ScalarProto3{})),
+		equalMessage(&ScalarProto3{}),
 	})
 }
 
-type RepeatedScalars struct {
+type ListScalars struct {
 	Bools    []bool    `protobuf:"1"`
 	Int32s   []int32   `protobuf:"2"`
 	Int64s   []int64   `protobuf:"3"`
@@ -322,10 +324,10 @@ type RepeatedScalars struct {
 	MyBytes4   VectorStrings `protobuf:"19"`
 }
 
-func TestRepeatedScalars(t *testing.T) {
-	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
+var listScalarsType = MessageType{Type: ptype.GoMessage(
+	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
-		FullName: "RepeatedScalars",
+		FullName: "ListScalars",
 		Fields: []ptype.Field{
 			{Name: "f1", Number: 1, Cardinality: pref.Repeated, Kind: pref.BoolKind},
 			{Name: "f2", Number: 2, Cardinality: pref.Repeated, Kind: pref.Int32Kind},
@@ -349,12 +351,24 @@ func TestRepeatedScalars(t *testing.T) {
 			{Name: "f18", Number: 18, Cardinality: pref.Repeated, Kind: pref.BytesKind},
 			{Name: "f19", Number: 19, Cardinality: pref.Repeated, Kind: pref.BytesKind},
 		},
-	})}
-
-	empty := mi.MessageOf(&RepeatedScalars{})
+	}),
+	func(pref.MessageType) pref.ProtoMessage {
+		return new(ListScalars)
+	},
+)}
+
+func (m *ListScalars) Type() pref.MessageType            { return listScalarsType.Type }
+func (m *ListScalars) KnownFields() pref.KnownFields     { return listScalarsType.KnownFieldsOf(m) }
+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{}
 	emptyFS := empty.KnownFields()
 
-	want := mi.MessageOf(&RepeatedScalars{
+	want := &ListScalars{
 		Bools:    []bool{true, false, true},
 		Int32s:   []int32{2, math.MinInt32, math.MaxInt32},
 		Int64s:   []int64{3, math.MinInt64, math.MaxInt64},
@@ -376,10 +390,10 @@ func TestRepeatedScalars(t *testing.T) {
 		MyStrings4: VectorBytes{[]byte("17"), nil, []byte("seventeen")},
 		MyBytes3:   VectorBytes{[]byte("18"), nil, []byte("eighteen")},
 		MyBytes4:   VectorStrings{"19", "", "nineteen"},
-	})
+	}
 	wantFS := want.KnownFields()
 
-	testMessage(t, nil, mi.MessageOf(&RepeatedScalars{}), messageOps{
+	testMessage(t, nil, &ListScalars{}, messageOps{
 		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false},
 		getFields{1: emptyFS.Get(1), 3: emptyFS.Get(3), 5: emptyFS.Get(5), 7: emptyFS.Get(7), 9: emptyFS.Get(9), 11: emptyFS.Get(11), 13: emptyFS.Get(13), 15: emptyFS.Get(15), 17: emptyFS.Get(17), 19: emptyFS.Get(19)},
 		setFields{1: wantFS.Get(1), 3: wantFS.Get(3), 5: wantFS.Get(5), 7: wantFS.Get(7), 9: wantFS.Get(9), 11: wantFS.Get(11), 13: wantFS.Get(13), 15: wantFS.Get(15), 17: wantFS.Get(17), 19: wantFS.Get(19)},
@@ -470,25 +484,26 @@ type MapScalars struct {
 	MyBytes4   MapStrings `protobuf:"25"`
 }
 
-func TestMapScalars(t *testing.T) {
-	mustMakeMapEntry := func(n pref.FieldNumber, keyKind, valKind pref.Kind) ptype.Field {
-		return ptype.Field{
-			Name:        pref.Name(fmt.Sprintf("f%d", n)),
-			Number:      n,
-			Cardinality: pref.Repeated,
-			Kind:        pref.MessageKind,
-			MessageType: mustMakeMessageDesc(ptype.StandaloneMessage{
-				Syntax:   pref.Proto2,
-				FullName: pref.FullName(fmt.Sprintf("MapScalars.F%dEntry", n)),
-				Fields: []ptype.Field{
-					{Name: "key", Number: 1, Cardinality: pref.Optional, Kind: keyKind},
-					{Name: "value", Number: 2, Cardinality: pref.Optional, Kind: valKind},
-				},
-				Options: &descriptorV1.MessageOptions{MapEntry: protoV1.Bool(true)},
-			}),
-		}
+func mustMakeMapEntry(n pref.FieldNumber, keyKind, valKind pref.Kind) ptype.Field {
+	return ptype.Field{
+		Name:        pref.Name(fmt.Sprintf("f%d", n)),
+		Number:      n,
+		Cardinality: pref.Repeated,
+		Kind:        pref.MessageKind,
+		MessageType: mustMakeMessageDesc(ptype.StandaloneMessage{
+			Syntax:   pref.Proto2,
+			FullName: pref.FullName(fmt.Sprintf("MapScalars.F%dEntry", n)),
+			Fields: []ptype.Field{
+				{Name: "key", Number: 1, Cardinality: pref.Optional, Kind: keyKind},
+				{Name: "value", Number: 2, Cardinality: pref.Optional, Kind: valKind},
+			},
+			Options: &descriptorV1.MessageOptions{MapEntry: protoV1.Bool(true)},
+		}),
 	}
-	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
+}
+
+var mapScalarsType = MessageType{Type: ptype.GoMessage(
+	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "MapScalars",
 		Fields: []ptype.Field{
@@ -521,12 +536,24 @@ func TestMapScalars(t *testing.T) {
 			mustMakeMapEntry(24, pref.StringKind, pref.BytesKind),
 			mustMakeMapEntry(25, pref.StringKind, pref.BytesKind),
 		},
-	})}
+	}),
+	func(pref.MessageType) pref.ProtoMessage {
+		return new(MapScalars)
+	},
+)}
+
+func (m *MapScalars) Type() pref.MessageType            { return mapScalarsType.Type }
+func (m *MapScalars) KnownFields() pref.KnownFields     { return mapScalarsType.KnownFieldsOf(m) }
+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()                     {}
 
-	empty := mi.MessageOf(&MapScalars{})
+func TestMapScalars(t *testing.T) {
+	empty := &MapScalars{}
 	emptyFS := empty.KnownFields()
 
-	want := mi.MessageOf(&MapScalars{
+	want := &MapScalars{
 		KeyBools:   map[bool]string{true: "true", false: "false"},
 		KeyInt32s:  map[int32]string{0: "zero", -1: "one", 2: "two"},
 		KeyInt64s:  map[int64]string{0: "zero", -10: "ten", 20: "twenty"},
@@ -555,10 +582,10 @@ func TestMapScalars(t *testing.T) {
 		MyStrings4: MapBytes{"s1": []byte("s1"), "s2": []byte("s2")},
 		MyBytes3:   MapBytes{"s1": []byte("s1"), "s2": []byte("s2")},
 		MyBytes4:   MapStrings{"s1": "s1", "s2": "s2"},
-	})
+	}
 	wantFS := want.KnownFields()
 
-	testMessage(t, nil, mi.MessageOf(&MapScalars{}), messageOps{
+	testMessage(t, nil, &MapScalars{}, messageOps{
 		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 23: false, 24: false, 25: false},
 		getFields{1: emptyFS.Get(1), 3: emptyFS.Get(3), 5: emptyFS.Get(5), 7: emptyFS.Get(7), 9: emptyFS.Get(9), 11: emptyFS.Get(11), 13: emptyFS.Get(13), 15: emptyFS.Get(15), 17: emptyFS.Get(17), 19: emptyFS.Get(19), 21: emptyFS.Get(21), 23: emptyFS.Get(23), 25: emptyFS.Get(25)},
 		setFields{1: wantFS.Get(1), 3: wantFS.Get(3), 5: wantFS.Get(5), 7: wantFS.Get(7), 9: wantFS.Get(9), 11: wantFS.Get(11), 13: wantFS.Get(13), 15: wantFS.Get(15), 17: wantFS.Get(17), 19: wantFS.Get(19), 21: wantFS.Get(21), 23: wantFS.Get(23), 25: wantFS.Get(25)},
@@ -687,7 +714,40 @@ type (
 	}
 )
 
-func (*OneofScalars) XXX_OneofFuncs() (func(proto.Message, *proto.Buffer) error, func(proto.Message, int, int, *proto.Buffer) (bool, error), func(proto.Message) int, []interface{}) {
+var oneofScalarsType = MessageType{Type: ptype.GoMessage(
+	mustMakeMessageDesc(ptype.StandaloneMessage{
+		Syntax:   pref.Proto2,
+		FullName: "ScalarProto2",
+		Fields: []ptype.Field{
+			{Name: "f1", Number: 1, Cardinality: pref.Optional, Kind: pref.BoolKind, Default: V(bool(true)), OneofName: "union"},
+			{Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.Int32Kind, Default: V(int32(2)), OneofName: "union"},
+			{Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.Int64Kind, Default: V(int64(3)), OneofName: "union"},
+			{Name: "f4", Number: 4, Cardinality: pref.Optional, Kind: pref.Uint32Kind, Default: V(uint32(4)), OneofName: "union"},
+			{Name: "f5", Number: 5, Cardinality: pref.Optional, Kind: pref.Uint64Kind, Default: V(uint64(5)), OneofName: "union"},
+			{Name: "f6", Number: 6, Cardinality: pref.Optional, Kind: pref.FloatKind, Default: V(float32(6)), OneofName: "union"},
+			{Name: "f7", Number: 7, Cardinality: pref.Optional, Kind: pref.DoubleKind, Default: V(float64(7)), OneofName: "union"},
+			{Name: "f8", Number: 8, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("8")), OneofName: "union"},
+			{Name: "f9", Number: 9, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("9")), OneofName: "union"},
+			{Name: "f10", Number: 10, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("10")), OneofName: "union"},
+			{Name: "f11", Number: 11, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("11")), OneofName: "union"},
+			{Name: "f12", Number: 12, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("12")), OneofName: "union"},
+			{Name: "f13", Number: 13, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("13")), OneofName: "union"},
+		},
+		Oneofs: []ptype.Oneof{{Name: "union"}},
+	}),
+	func(pref.MessageType) pref.ProtoMessage {
+		return new(OneofScalars)
+	},
+)}
+
+func (m *OneofScalars) Type() pref.MessageType            { return oneofScalarsType.Type }
+func (m *OneofScalars) KnownFields() pref.KnownFields     { return oneofScalarsType.KnownFieldsOf(m) }
+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_OneofFuncs() (func(protoV1.Message, *protoV1.Buffer) error, func(protoV1.Message, int, int, *protoV1.Buffer) (bool, error), func(protoV1.Message) int, []interface{}) {
 	return nil, nil, nil, []interface{}{
 		(*OneofScalars_Bool)(nil),
 		(*OneofScalars_Int32)(nil),
@@ -720,43 +780,22 @@ func (*OneofScalars_BytesA) isOneofScalars_Union()  {}
 func (*OneofScalars_BytesB) isOneofScalars_Union()  {}
 
 func TestOneofs(t *testing.T) {
-	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
-		Syntax:   pref.Proto2,
-		FullName: "ScalarProto2",
-		Fields: []ptype.Field{
-			{Name: "f1", Number: 1, Cardinality: pref.Optional, Kind: pref.BoolKind, Default: V(bool(true)), OneofName: "union"},
-			{Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.Int32Kind, Default: V(int32(2)), OneofName: "union"},
-			{Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.Int64Kind, Default: V(int64(3)), OneofName: "union"},
-			{Name: "f4", Number: 4, Cardinality: pref.Optional, Kind: pref.Uint32Kind, Default: V(uint32(4)), OneofName: "union"},
-			{Name: "f5", Number: 5, Cardinality: pref.Optional, Kind: pref.Uint64Kind, Default: V(uint64(5)), OneofName: "union"},
-			{Name: "f6", Number: 6, Cardinality: pref.Optional, Kind: pref.FloatKind, Default: V(float32(6)), OneofName: "union"},
-			{Name: "f7", Number: 7, Cardinality: pref.Optional, Kind: pref.DoubleKind, Default: V(float64(7)), OneofName: "union"},
-			{Name: "f8", Number: 8, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("8")), OneofName: "union"},
-			{Name: "f9", Number: 9, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("9")), OneofName: "union"},
-			{Name: "f10", Number: 10, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("10")), OneofName: "union"},
-			{Name: "f11", Number: 11, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("11")), OneofName: "union"},
-			{Name: "f12", Number: 12, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("12")), OneofName: "union"},
-			{Name: "f13", Number: 13, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("13")), OneofName: "union"},
-		},
-		Oneofs: []ptype.Oneof{{Name: "union"}},
-	})}
-
-	empty := mi.MessageOf(&OneofScalars{})
-	want1 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Bool{true}})
-	want2 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Int32{20}})
-	want3 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Int64{30}})
-	want4 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Uint32{40}})
-	want5 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Uint64{50}})
-	want6 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Float32{60}})
-	want7 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Float64{70}})
-	want8 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_String{string("80")}})
-	want9 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_StringA{[]byte("90")}})
-	want10 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_StringB{MyString("100")}})
-	want11 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_Bytes{[]byte("110")}})
-	want12 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_BytesA{string("120")}})
-	want13 := mi.MessageOf(&OneofScalars{Union: &OneofScalars_BytesB{MyBytes("130")}})
-
-	testMessage(t, nil, mi.MessageOf(&OneofScalars{}), messageOps{
+	empty := &OneofScalars{}
+	want1 := &OneofScalars{Union: &OneofScalars_Bool{true}}
+	want2 := &OneofScalars{Union: &OneofScalars_Int32{20}}
+	want3 := &OneofScalars{Union: &OneofScalars_Int64{30}}
+	want4 := &OneofScalars{Union: &OneofScalars_Uint32{40}}
+	want5 := &OneofScalars{Union: &OneofScalars_Uint64{50}}
+	want6 := &OneofScalars{Union: &OneofScalars_Float32{60}}
+	want7 := &OneofScalars{Union: &OneofScalars_Float64{70}}
+	want8 := &OneofScalars{Union: &OneofScalars_String{string("80")}}
+	want9 := &OneofScalars{Union: &OneofScalars_StringA{[]byte("90")}}
+	want10 := &OneofScalars{Union: &OneofScalars_StringB{MyString("100")}}
+	want11 := &OneofScalars{Union: &OneofScalars_Bytes{[]byte("110")}}
+	want12 := &OneofScalars{Union: &OneofScalars_BytesA{string("120")}}
+	want13 := &OneofScalars{Union: &OneofScalars_BytesB{MyBytes("130")}}
+
+	testMessage(t, nil, &OneofScalars{}, messageOps{
 		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false},
 		getFields{1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V(string("10")), 11: V([]byte("11")), 12: V([]byte("12")), 13: V([]byte("13"))},
 
@@ -789,13 +828,6 @@ var cmpOpts = cmp.Options{
 	cmp.Transformer("UnwrapValue", func(v pref.Value) interface{} {
 		return v.Interface()
 	}),
-	cmp.Transformer("UnwrapMessage", func(m pref.Message) interface{} {
-		v := m.Interface()
-		if v, ok := v.(interface{ Unwrap() interface{} }); ok {
-			return v.Unwrap()
-		}
-		return v
-	}),
 	cmp.Transformer("UnwrapVector", func(v pref.Vector) interface{} {
 		return v.(interface{ Unwrap() interface{} }).Unwrap()
 	}),

internal/value/convert.go

@@ -53,17 +53,23 @@ var (
 // protoc-gen-go historically generated to be able to automatically wrap some
 // v1 messages generated by other forks of protoc-gen-go.
 func NewConverter(t reflect.Type, k pref.Kind) Converter {
-	return NewLegacyConverter(t, k, nil, nil)
+	return NewLegacyConverter(t, k, nil, nil, nil)
 }
 
+// Legacy enums and messages do not self-report their own protoreflect types.
+// Thus, the caller needs to provide functions for retrieving those when
+// a v1 enum or message is encountered.
+type (
+	enumTypeOf     = func(reflect.Type) pref.EnumType
+	messageTypeOf  = func(reflect.Type) pref.MessageType
+	messageValueOf = func(reflect.Value) pref.ProtoMessage
+)
+
 // NewLegacyConverter is identical to NewConverter,
 // but supports wrapping legacy v1 messages to implement the v2 message API
-// using the provided wrapEnum and wrapMessage functions.
+// using the provided enumTypeOf, messageTypeOf and messageValueOf functions.
 // The wrapped message must implement Unwrapper.
-func NewLegacyConverter(t reflect.Type, k pref.Kind, wrapEnum func(reflect.Value) pref.ProtoEnum, wrapMessage func(reflect.Value) pref.ProtoMessage) Converter {
-	if (wrapEnum == nil) != (wrapMessage == nil) {
-		panic("legacy enum and message wrappers must both be populated or nil")
-	}
+func NewLegacyConverter(t reflect.Type, k pref.Kind, etOf enumTypeOf, mtOf messageTypeOf, mvOf messageValueOf) Converter {
 	switch k {
 	case pref.BoolKind:
 		if t.Kind() == reflect.Bool {
@@ -125,8 +131,8 @@ func NewLegacyConverter(t reflect.Type, k pref.Kind, wrapEnum func(reflect.Value
 		}
 
 		// Handle v1 enums, which we identify as simply a named int32 type.
-		if wrapEnum != nil && t.PkgPath() != "" && t.Kind() == reflect.Int32 {
-			et := wrapEnum(reflect.Zero(t)).ProtoReflect().Type()
+		if etOf != nil && t.PkgPath() != "" && t.Kind() == reflect.Int32 {
+			et := etOf(t)
 			return Converter{
 				PBValueOf: func(v reflect.Value) pref.Value {
 					if v.Type() != t {
@@ -164,14 +170,14 @@ func NewLegacyConverter(t reflect.Type, k pref.Kind, wrapEnum func(reflect.Value
 		}
 
 		// Handle v1 messages, which we need to wrap as a v2 message.
-		if wrapMessage != nil && t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
-			mt := wrapMessage(reflect.New(t.Elem())).ProtoReflect().Type()
+		if mtOf != nil && t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
+			mt := mtOf(t)
 			return Converter{
 				PBValueOf: func(v reflect.Value) pref.Value {
 					if v.Type() != t {
 						panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
 					}
-					return pref.ValueOf(wrapMessage(v).ProtoReflect())
+					return pref.ValueOf(mvOf(v).ProtoReflect())
 				},
 				GoValueOf: func(v pref.Value) reflect.Value {
 					rv := reflect.ValueOf(v.Message().(Unwrapper).Unwrap())

internal/value/map.go

@@ -77,7 +77,7 @@ func (ms mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
 	}
 }
 func (ms mapReflect) Unwrap() interface{} {
-	return ms.v.Interface()
+	return ms.v.Addr().Interface()
 }
 func (ms mapReflect) ProtoMutable() {}
 

internal/value/vector.go

@@ -53,7 +53,7 @@ func (vs vectorReflect) Truncate(i int) {
 	vs.v.Set(vs.v.Slice(0, i))
 }
 func (vs vectorReflect) Unwrap() interface{} {
-	return vs.v.Interface()
+	return vs.v.Addr().Interface()
 }
 func (vs vectorReflect) ProtoMutable() {}
 

reflect/protoreflect/type.go

@@ -446,20 +446,21 @@ type ExtensionType interface {
 	//	t.GoType() == reflect.TypeOf(t.InterfaceOf(t.ValueOf(t.New())))
 	GoType() reflect.Type
 
-	// TODO: How do we reconcile GoType with the existing extension API,
-	// which returns *T for scalars (causing unnecessary aliasing),
-	// and []T for vectors (causing insufficient aliasing)?
+	// TODO: What to do with nil?
+	//	Should ValueOf(nil) return Value{}?
+	//	Should InterfaceOf(Value{}) return nil?
+	//	Similarly, should the Value.{Message,Vector,Map} also return nil?
 
 	// ValueOf wraps the input and returns it as a Value.
-	// ValueOf panics if the input value is not the appropriate type.
+	// ValueOf panics if the input value is invalid or not the appropriate type.
 	//
 	// ValueOf is more extensive than protoreflect.ValueOf for a given field's
 	// value as it has more type information available.
 	ValueOf(interface{}) Value
 
 	// InterfaceOf completely unwraps the Value to the underlying Go type.
-	// InterfaceOf panics if the input does not represent the appropriate
-	// underlying Go type.
+	// InterfaceOf panics if the input is nil or does not represent the
+	// appropriate underlying Go type.
 	//
 	// InterfaceOf is able to unwrap the Value further than Value.Interface
 	// as it has more type information available.

reflect/prototype/go_type.go

@@ -19,22 +19,24 @@ func GoEnum(ed protoreflect.EnumDescriptor, fn func(protoreflect.EnumType, proto
 	if ed.IsPlaceholder() {
 		panic("enum descriptor must not be a placeholder")
 	}
-	t := &goEnum{EnumDescriptor: ed, new: fn}
-	t.typ = reflect.TypeOf(fn(t, 0))
-	return t
+	return &goEnum{EnumDescriptor: ed, new: fn}
 }
 
 type goEnum struct {
 	protoreflect.EnumDescriptor
-	typ reflect.Type
 	new func(protoreflect.EnumType, protoreflect.EnumNumber) protoreflect.ProtoEnum
+
+	once sync.Once
+	typ  reflect.Type
 }
 
 func (t *goEnum) GoType() reflect.Type {
+	t.New(0) // initialize t.typ
 	return t.typ
 }
 func (t *goEnum) New(n protoreflect.EnumNumber) protoreflect.ProtoEnum {
 	e := t.new(t, n)
+	t.once.Do(func() { t.typ = reflect.TypeOf(e) })
 	if t.typ != reflect.TypeOf(e) {
 		panic(fmt.Sprintf("mismatching types for enum: got %T, want %v", e, t.typ))
 	}
@@ -47,22 +49,26 @@ func GoMessage(md protoreflect.MessageDescriptor, fn func(protoreflect.MessageTy
 	if md.IsPlaceholder() {
 		panic("message descriptor must not be a placeholder")
 	}
-	t := &goMessage{MessageDescriptor: md, new: fn}
-	t.typ = reflect.TypeOf(fn(t))
-	return t
+	// NOTE: Avoid calling fn in the constructor since fn itself may depend on
+	// this function returning (for cyclic message dependencies).
+	return &goMessage{MessageDescriptor: md, new: fn}
 }
 
 type goMessage struct {
 	protoreflect.MessageDescriptor
-	typ reflect.Type
 	new func(protoreflect.MessageType) protoreflect.ProtoMessage
+
+	once sync.Once
+	typ  reflect.Type
 }
 
 func (t *goMessage) GoType() reflect.Type {
+	t.New() // initialize t.typ
 	return t.typ
 }
 func (t *goMessage) New() protoreflect.ProtoMessage {
 	m := t.new(t)
+	t.once.Do(func() { t.typ = reflect.TypeOf(m) })
 	if t.typ != reflect.TypeOf(m) {
 		panic(fmt.Sprintf("mismatching types for message: got %T, want %v", m, t.typ))
 	}
@@ -240,11 +246,11 @@ func (t *goExtension) lazyInit() {
 			t.valueOf = func(v interface{}) protoreflect.Value {
 				return protoreflect.ValueOf(value.VectorOf(v, c))
 			}
-			t.interfaceOf = func(v protoreflect.Value) interface{} {
+			t.interfaceOf = func(pv protoreflect.Value) interface{} {
 				// TODO: Can we assume that Vector implementations know how
 				// to unwrap themselves?
 				// Should this be part of the public API in protoreflect?
-				return v.Vector().(value.Unwrapper).Unwrap()
+				return pv.Vector().(value.Unwrapper).Unwrap()
 			}
 		default:
 			panic(fmt.Sprintf("invalid cardinality: %v", t.Cardinality()))