diff --git a/encoding/textpb/encode_test.go b/encoding/textpb/encode_test.go
index 28beaf4..ffb2c5a 100644
--- a/encoding/textpb/encode_test.go
+++ b/encoding/textpb/encode_test.go
@@ -10,8 +10,6 @@
 	"testing"
 
 	"github.com/golang/protobuf/v2/encoding/textpb"
-	"github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb2"
-	"github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb3"
 	"github.com/golang/protobuf/v2/internal/detrand"
 	"github.com/golang/protobuf/v2/internal/impl"
 	"github.com/golang/protobuf/v2/internal/scalar"
@@ -19,12 +17,18 @@
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 
+	// The legacy package must be imported prior to use of any legacy messages.
+	// TODO: Remove this when protoV1 registers these hooks for you.
+	_ "github.com/golang/protobuf/v2/internal/legacy"
+
 	anypb "github.com/golang/protobuf/ptypes/any"
 	durpb "github.com/golang/protobuf/ptypes/duration"
 	emptypb "github.com/golang/protobuf/ptypes/empty"
 	stpb "github.com/golang/protobuf/ptypes/struct"
 	tspb "github.com/golang/protobuf/ptypes/timestamp"
 	wpb "github.com/golang/protobuf/ptypes/wrappers"
+	"github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb2"
+	"github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb3"
 )
 
 func init() {
@@ -33,7 +37,7 @@
 }
 
 func M(m interface{}) proto.Message {
-	return impl.MessageOf(m).Interface()
+	return impl.Export{}.MessageOf(m).Interface()
 }
 
 // splitLines is a cmpopts.Option for comparing strings with line breaks.
diff --git a/internal/impl/export.go b/internal/impl/export.go
new file mode 100644
index 0000000..7e2d392
--- /dev/null
+++ b/internal/impl/export.go
@@ -0,0 +1,76 @@
+// 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 (
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+	ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+// Export is a zero-length named type that exists only to export a set of
+// functions that we do not want to appear in godoc.
+type Export struct{}
+
+// EnumOf returns the protoreflect.Enum interface over e.
+// If e already implements proto.Enum, then it directly calls the
+// ProtoReflect method, otherwise it wraps the v1 enum to implement
+// the v2 reflective interface.
+func (Export) EnumOf(e interface{}) pref.Enum {
+	if ev, ok := e.(pref.ProtoEnum); ok {
+		return ev.ProtoReflect()
+	}
+	return legacyWrapper.EnumOf(e)
+}
+
+// EnumTypeOf returns the protoreflect.EnumType for e.
+// If e already implements proto.Enum, then it obtains the type by directly
+// calling the ProtoReflect.Type method, otherwise it derives an enum type
+// from the v1 named int32 type.
+func (Export) EnumTypeOf(e interface{}) pref.EnumType {
+	if ev, ok := e.(pref.ProtoEnum); ok {
+		return ev.ProtoReflect().Type()
+	}
+	return legacyWrapper.EnumTypeOf(e)
+}
+
+// MessageOf returns the protoreflect.Message interface over m.
+// If m already implements proto.Message, then it directly calls the
+// ProtoReflect method, otherwise it wraps the v1 message to implement
+// the v2 reflective interface.
+func (Export) MessageOf(m interface{}) pref.Message {
+	if mv, ok := m.(pref.ProtoMessage); ok {
+		return mv.ProtoReflect()
+	}
+	return legacyWrapper.MessageOf(m)
+}
+
+// MessageTypeOf returns the protoreflect.MessageType for m.
+// If m already implements proto.Message, then it obtains the type by directly
+// calling the ProtoReflect.Type method, otherwise it derives a message type
+// from the v1 message struct.
+func (Export) MessageTypeOf(m interface{}) pref.MessageType {
+	if mv, ok := m.(pref.ProtoMessage); ok {
+		return mv.ProtoReflect().Type()
+	}
+	return legacyWrapper.MessageTypeOf(m)
+}
+
+// ExtensionTypeOf returns a protoreflect.ExtensionType where the type of the
+// field is t. The type t must be provided if the field is an enum or message.
+// If t already implements proto.Enum or proto.Message, then this returns
+// an extension type by directly calling prototype.GoExtension.
+// Otherwise, it derives an extension type by wrapping the enum or message
+// using EnumOf or MessageOf.
+func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
+	switch t := t.(type) {
+	case nil:
+		return ptype.GoExtension(d, nil, nil)
+	case pref.ProtoEnum:
+		return ptype.GoExtension(d, t.ProtoReflect().Type(), nil)
+	case pref.ProtoMessage:
+		return ptype.GoExtension(d, nil, t.ProtoReflect().Type())
+	}
+	return legacyWrapper.ExtensionTypeOf(d, t)
+}
diff --git a/internal/impl/legacy_extension.go b/internal/impl/legacy_extension.go
index d87892f..df92f02 100644
--- a/internal/impl/legacy_extension.go
+++ b/internal/impl/legacy_extension.go
@@ -5,14 +5,10 @@
 package impl
 
 import (
-	"fmt"
 	"reflect"
 
 	papi "github.com/golang/protobuf/protoapi"
-	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 {
@@ -71,7 +67,7 @@
 	if x.Value == nil {
 		return false
 	}
-	t := legacyExtensionTypeOf(x.Desc)
+	t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
 	if t.Cardinality() == pref.Repeated {
 		return t.ValueOf(x.Value).List().Len() > 0
 	}
@@ -83,7 +79,7 @@
 	if x.Desc == nil {
 		return pref.Value{}
 	}
-	t := legacyExtensionTypeOf(x.Desc)
+	t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
 	if x.Value == nil {
 		// NOTE: x.Value is never nil for Lists since they are always populated
 		// during ExtensionFieldTypes.Register.
@@ -100,7 +96,7 @@
 	if x.Desc == nil {
 		panic("no extension descriptor registered")
 	}
-	t := legacyExtensionTypeOf(x.Desc)
+	t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
 	x.Value = t.InterfaceOf(v)
 	p.x.Set(n, x)
 }
@@ -110,7 +106,7 @@
 	if x.Desc == nil {
 		return
 	}
-	t := legacyExtensionTypeOf(x.Desc)
+	t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
 	if t.Cardinality() == pref.Repeated {
 		t.ValueOf(x.Value).List().Truncate(0)
 		return
@@ -124,7 +120,7 @@
 	if x.Desc == nil {
 		panic("no extension descriptor registered")
 	}
-	t := legacyExtensionTypeOf(x.Desc)
+	t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
 	if x.Value == nil {
 		v := t.ValueOf(t.New())
 		x.Value = t.InterfaceOf(v)
@@ -169,7 +165,7 @@
 	if x.Desc != nil {
 		panic("extension descriptor already registered")
 	}
-	x.Desc = legacyExtensionDescOf(t, p.mi.goType)
+	x.Desc = legacyWrapper.ExtensionDescFromType(t)
 	if t.Cardinality() == pref.Repeated {
 		// If the field is repeated, initialize the entry with an empty list
 		// so that future Get operations can return a mutable and concrete list.
@@ -204,7 +200,7 @@
 func (p legacyExtensionTypes) ByNumber(n pref.FieldNumber) pref.ExtensionType {
 	x := p.x.Get(n)
 	if x.Desc != nil {
-		return legacyExtensionTypeOf(x.Desc)
+		return legacyWrapper.ExtensionTypeFromDesc(x.Desc)
 	}
 	return nil
 }
@@ -212,7 +208,7 @@
 func (p legacyExtensionTypes) ByName(s pref.FullName) (t pref.ExtensionType) {
 	p.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
 		if x.Desc != nil && x.Desc.Name == string(s) {
-			t = legacyExtensionTypeOf(x.Desc)
+			t = legacyWrapper.ExtensionTypeFromDesc(x.Desc)
 			return false
 		}
 		return true
@@ -223,169 +219,10 @@
 func (p legacyExtensionTypes) Range(f func(pref.ExtensionType) bool) {
 	p.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
 		if x.Desc != nil {
-			if !f(legacyExtensionTypeOf(x.Desc)) {
+			if !f(legacyWrapper.ExtensionTypeFromDesc(x.Desc)) {
 				return false
 			}
 		}
 		return true
 	})
 }
-
-func legacyExtensionDescOf(t pref.ExtensionType, parent reflect.Type) *papi.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 &papi.ExtensionDesc{
-		ExtendedType:  reflect.Zero(parent).Interface().(papi.Message),
-		ExtensionType: reflect.Zero(extType).Interface(),
-		Field:         int32(t.Number()),
-		Name:          string(t.FullName()),
-		Tag:           ptag.Marshal(t, enumName),
-	}
-}
-
-func legacyExtensionTypeOf(d *papi.ExtensionDesc) pref.ExtensionType {
-	if d.Type != nil {
-		return d.Type
-	}
-
-	// 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).ProtoUnwrap()
-		}
-		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).ProtoUnwrap()
-		}
-	} 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.ListOf(v, conv))
-		}
-		xt2.interfaceOf = func(pv pref.Value) interface{} {
-			v := pv.List().(pvalue.Unwrapper).ProtoUnwrap()
-			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        *papi.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)
-}
diff --git a/internal/impl/legacy_hook.go b/internal/impl/legacy_hook.go
new file mode 100644
index 0000000..86fe95e
--- /dev/null
+++ b/internal/impl/legacy_hook.go
@@ -0,0 +1,17 @@
+// 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 pvalue "github.com/golang/protobuf/v2/internal/value"
+
+// TODO: Add a default LegacyWrapper that panics with a more helpful message?
+var legacyWrapper pvalue.LegacyWrapper
+
+// RegisterLegacyWrapper registers a set of constructor functions that are
+// called when a legacy enum or message is encountered that does not natively
+// support the protobuf reflection APIs.
+func RegisterLegacyWrapper(w pvalue.LegacyWrapper) {
+	legacyWrapper = w
+}
diff --git a/internal/impl/legacy_test.go b/internal/impl/legacy_test.go
index f1fe38f..631879b 100644
--- a/internal/impl/legacy_test.go
+++ b/internal/impl/legacy_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package impl
+package impl_test
 
 import (
 	"bytes"
@@ -12,437 +12,21 @@
 
 	papi "github.com/golang/protobuf/protoapi"
 	pack "github.com/golang/protobuf/v2/internal/encoding/pack"
+	pimpl "github.com/golang/protobuf/v2/internal/impl"
 	pragma "github.com/golang/protobuf/v2/internal/pragma"
 	scalar "github.com/golang/protobuf/v2/internal/scalar"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 	cmp "github.com/google/go-cmp/cmp"
+	cmpopts "github.com/google/go-cmp/cmp/cmpopts"
 
-	proto2_20160225 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v0.0.0-20160225-2fc053c5"
-	proto2_20160519 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v0.0.0-20160519-a4ab9ec5"
+	// The legacy package must be imported prior to use of any legacy messages.
+	// TODO: Remove this when protoV1 registers these hooks for you.
+	plegacy "github.com/golang/protobuf/v2/internal/legacy"
+
 	proto2_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
-	proto2_20180430 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.1.0-20180430-b4deda09"
-	proto2_20180814 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.2.0-20180814-aa810b61"
-	proto2_20181126 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.2.1-20181126-8d0c54c1"
-	proto3_20160225 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v0.0.0-20160225-2fc053c5"
-	proto3_20160519 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v0.0.0-20160519-a4ab9ec5"
-	proto3_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.0.0-20180125-92554152"
-	proto3_20180430 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.1.0-20180430-b4deda09"
-	proto3_20180814 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.2.0-20180814-aa810b61"
-	proto3_20181126 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.2.1-20181126-8d0c54c1"
 )
 
-func mustLoadFileDesc(b []byte, _ []int) pref.FileDescriptor {
-	fd, err := ptype.NewFileFromDescriptorProto(legacyLoadFileDesc(b), nil)
-	if err != nil {
-		panic(err)
-	}
-	return fd
-}
-
-func TestLegacyDescriptor(t *testing.T) {
-	var tests []struct{ got, want pref.Descriptor }
-
-	fileDescP2_20160225 := mustLoadFileDesc(new(proto2_20160225.Message).Descriptor())
-	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
-		want: fileDescP2_20160225.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
-		want: fileDescP2_20160225.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
-		want: fileDescP2_20160225.Messages().ByName("Message"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("NamedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OptionalGroup))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RequiredGroup))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RepeatedGroup))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OneofGroup))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OneofGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionOptionalGroup))),
-		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
-		want: fileDescP3_20160225.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
-		want: fileDescP3_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
-		want: fileDescP3_20160225.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
-		want: fileDescP3_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
-		want: fileDescP2_20160519.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
-		want: fileDescP2_20160519.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
-		want: fileDescP2_20160519.Messages().ByName("Message"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("NamedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OptionalGroup))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RequiredGroup))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RepeatedGroup))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OneofGroup))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OneofGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionOptionalGroup))),
-		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
-		want: fileDescP3_20160519.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
-		want: fileDescP3_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
-		want: fileDescP3_20160519.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
-		want: fileDescP3_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
-		want: fileDescP2_20180125.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
-		want: fileDescP2_20180125.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
-		want: fileDescP2_20180125.Messages().ByName("Message"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("NamedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OptionalGroup))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RequiredGroup))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RepeatedGroup))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OneofGroup))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OneofGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionOptionalGroup))),
-		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
-		want: fileDescP3_20180125.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
-		want: fileDescP3_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
-		want: fileDescP3_20180125.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
-		want: fileDescP3_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
-		want: fileDescP2_20180430.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
-		want: fileDescP2_20180430.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
-		want: fileDescP2_20180430.Messages().ByName("Message"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("NamedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OptionalGroup))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RequiredGroup))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RepeatedGroup))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OneofGroup))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OneofGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionOptionalGroup))),
-		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
-		want: fileDescP3_20180430.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
-		want: fileDescP3_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
-		want: fileDescP3_20180430.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
-		want: fileDescP3_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
-		want: fileDescP2_20180814.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
-		want: fileDescP2_20180814.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
-		want: fileDescP2_20180814.Messages().ByName("Message"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("NamedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OptionalGroup))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RequiredGroup))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RepeatedGroup))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OneofGroup))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OneofGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionOptionalGroup))),
-		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
-	}, {
-		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
-		want: fileDescP3_20180814.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
-		want: fileDescP3_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
-		want: fileDescP3_20180814.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
-		want: fileDescP3_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
-		want: fileDescP3_20180814.Messages().ByName("Message"),
-	}}...)
-
-	fileDescP2_20181126 := mustLoadFileDesc(new(proto2_20181126.Message).Descriptor())
-	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.SiblingEnum(0))),
-		want: fileDescP2_20181126.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.Message_ChildEnum(0))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.SiblingMessage))),
-		want: fileDescP2_20181126.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ChildMessage))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message))),
-		want: fileDescP2_20181126.Messages().ByName("Message"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_NamedGroup))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("NamedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OptionalGroup))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RequiredGroup))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RepeatedGroup))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OneofGroup))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("OneofGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionOptionalGroup))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionRepeatedGroup))),
-		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
-	}}...)
-
-	fileDescP3_20181126 := mustLoadFileDesc(new(proto3_20181126.Message).Descriptor())
-	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.SiblingEnum(0))),
-		want: fileDescP3_20181126.Enums().ByName("SiblingEnum"),
-	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.Message_ChildEnum(0))),
-		want: fileDescP3_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.SiblingMessage))),
-		want: fileDescP3_20181126.Messages().ByName("SiblingMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message_ChildMessage))),
-		want: fileDescP3_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
-	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message))),
-		want: fileDescP3_20181126.Messages().ByName("Message"),
-	}}...)
-
-	type list interface {
-		Len() int
-		pragma.DoNotImplement
-	}
-	opts := cmp.Options{
-		cmp.Transformer("", func(x list) []interface{} {
-			out := make([]interface{}, x.Len())
-			v := reflect.ValueOf(x)
-			for i := 0; i < x.Len(); i++ {
-				m := v.MethodByName("Get")
-				out[i] = m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
-			}
-			return out
-		}),
-		cmp.Transformer("", func(x pref.Descriptor) map[string]interface{} {
-			out := make(map[string]interface{})
-			v := reflect.ValueOf(x)
-			for i := 0; i < v.NumMethod(); i++ {
-				name := v.Type().Method(i).Name
-				if m := v.Method(i); m.Type().NumIn() == 0 && m.Type().NumOut() == 1 {
-					switch name {
-					case "Index":
-						// Ignore index since legacy descriptors have no parent.
-					case "Options":
-						// Ignore descriptor options since protos are not cmperable.
-					case "Enums", "Messages", "Extensions":
-						// Ignore nested message and enum declarations since
-						// legacy descriptors are all created standalone.
-					case "OneofType", "ExtendedType", "EnumType", "MessageType":
-						// Avoid descending into a dependency to avoid a cycle.
-						// Just record the full name if available.
-						//
-						// TODO: Cycle support in cmp would be useful here.
-						v := m.Call(nil)[0]
-						if !v.IsNil() {
-							out[name] = v.Interface().(pref.Descriptor).FullName()
-						}
-					default:
-						out[name] = m.Call(nil)[0].Interface()
-					}
-				}
-			}
-			return out
-		}),
-		cmp.Transformer("", func(v pref.Value) interface{} {
-			return v.Interface()
-		}),
-	}
-
-	for _, tt := range tests {
-		t.Run(string(tt.want.FullName()), func(t *testing.T) {
-			if diff := cmp.Diff(&tt.want, &tt.got, opts); diff != "" {
-				t.Errorf("descriptor mismatch (-want, +got):\n%s", diff)
-			}
-		})
-	}
-}
-
 type legacyTestMessage struct {
 	XXX_unrecognized []byte
 	papi.XXX_InternalExtensions
@@ -486,7 +70,7 @@
 	}
 
 	m := new(legacyTestMessage)
-	fs := MessageOf(m).UnknownFields()
+	fs := pimpl.Export{}.MessageOf(m).UnknownFields()
 
 	if got, want := fs.Len(), 0; got != want {
 		t.Errorf("Len() = %d, want %d", got, want)
@@ -682,175 +266,310 @@
 	})
 }
 
-func TestLegactExtensions(t *testing.T) {
-	extensions := []pref.ExtensionType{
-		legacyExtensionTypeOf(&papi.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(&papi.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(&papi.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(&papi.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(&papi.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(&papi.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(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: (*proto2_20180125.Message_ChildEnum)(nil),
-			Field:         10006,
-			Name:          "fizz.buzz.optional_enum_v1",
-			Tag:           "varint,10006,opt,name=optional_enum_v1,json=optionalEnumV1,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil),
-			Field:         10007,
-			Name:          "fizz.buzz.optional_message_v1",
-			Tag:           "bytes,10007,opt,name=optional_message_v1,json=optionalMessageV1",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: (*EnumProto2)(nil),
-			Field:         10008,
-			Name:          "fizz.buzz.optional_enum_v2",
-			Tag:           "varint,10008,opt,name=optional_enum_v2,json=optionalEnumV2,enum=EnumProto2,def=57005",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: (*EnumMessages)(nil),
-			Field:         10009,
-			Name:          "fizz.buzz.optional_message_v2",
-			Tag:           "bytes,10009,opt,name=optional_message_v2,json=optionalMessageV2",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]bool)(nil),
-			Field:         10010,
-			Name:          "fizz.buzz.repeated_bool",
-			Tag:           "varint,10010,rep,name=repeated_bool,json=repeatedBool",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]int32)(nil),
-			Field:         10011,
-			Name:          "fizz.buzz.repeated_int32",
-			Tag:           "varint,10011,rep,name=repeated_int32,json=repeatedInt32",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]uint32)(nil),
-			Field:         10012,
-			Name:          "fizz.buzz.repeated_uint32",
-			Tag:           "varint,10012,rep,name=repeated_uint32,json=repeatedUint32",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]float32)(nil),
-			Field:         10013,
-			Name:          "fizz.buzz.repeated_float",
-			Tag:           "fixed32,10013,rep,name=repeated_float,json=repeatedFloat",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]string)(nil),
-			Field:         10014,
-			Name:          "fizz.buzz.repeated_string",
-			Tag:           "bytes,10014,rep,name=repeated_string,json=repeatedString",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([][]byte)(nil),
-			Field:         10015,
-			Name:          "fizz.buzz.repeated_bytes",
-			Tag:           "bytes,10015,rep,name=repeated_bytes,json=repeatedBytes",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]proto2_20180125.Message_ChildEnum)(nil),
-			Field:         10016,
-			Name:          "fizz.buzz.repeated_enum_v1",
-			Tag:           "varint,10016,rep,name=repeated_enum_v1,json=repeatedEnumV1,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]*proto2_20180125.Message_ChildMessage)(nil),
-			Field:         10017,
-			Name:          "fizz.buzz.repeated_message_v1",
-			Tag:           "bytes,10017,rep,name=repeated_message_v1,json=repeatedMessageV1",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]EnumProto2)(nil),
-			Field:         10018,
-			Name:          "fizz.buzz.repeated_enum_v2",
-			Tag:           "varint,10018,rep,name=repeated_enum_v2,json=repeatedEnumV2,enum=EnumProto2",
-			Filename:      "fizz/buzz/test.proto",
-		}),
-		legacyExtensionTypeOf(&papi.ExtensionDesc{
-			ExtendedType:  (*legacyTestMessage)(nil),
-			ExtensionType: ([]*EnumMessages)(nil),
-			Field:         10019,
-			Name:          "fizz.buzz.repeated_message_v2",
-			Tag:           "bytes,10019,rep,name=repeated_message_v2,json=repeatedMessageV2",
-			Filename:      "fizz/buzz/test.proto",
-		}),
+func mustMakeExtensionType(x *ptype.StandaloneExtension, v interface{}) pref.ExtensionType {
+	xd, err := ptype.NewExtension(x)
+	if err != nil {
+		panic(xd)
 	}
+	return pimpl.Export{}.ExtensionTypeOf(xd, v)
+}
+
+var (
+	parentType    = pimpl.Export{}.MessageTypeOf((*legacyTestMessage)(nil))
+	enumV1Type    = pimpl.Export{}.EnumTypeOf(proto2_20180125.Message_ChildEnum(0))
+	messageV1Type = pimpl.Export{}.MessageTypeOf((*proto2_20180125.Message_ChildMessage)(nil))
+	enumV2Type    = enumProto2Type
+	messageV2Type = enumMessagesType.Type
+
+	extensionTypes = []pref.ExtensionType{
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_bool",
+			Number:       10000,
+			Cardinality:  pref.Optional,
+			Kind:         pref.BoolKind,
+			Default:      pref.ValueOf(true),
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_int32",
+			Number:       10001,
+			Cardinality:  pref.Optional,
+			Kind:         pref.Int32Kind,
+			Default:      pref.ValueOf(int32(-12345)),
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_uint32",
+			Number:       10002,
+			Cardinality:  pref.Optional,
+			Kind:         pref.Uint32Kind,
+			Default:      pref.ValueOf(uint32(3200)),
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_float",
+			Number:       10003,
+			Cardinality:  pref.Optional,
+			Kind:         pref.FloatKind,
+			Default:      pref.ValueOf(float32(3.14159)),
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_string",
+			Number:       10004,
+			Cardinality:  pref.Optional,
+			Kind:         pref.StringKind,
+			Default:      pref.ValueOf(string("hello, \"world!\"\n")),
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_bytes",
+			Number:       10005,
+			Cardinality:  pref.Optional,
+			Kind:         pref.BytesKind,
+			Default:      pref.ValueOf([]byte("dead\xde\xad\xbe\xefbeef")),
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_enum_v1",
+			Number:       10006,
+			Cardinality:  pref.Optional,
+			Kind:         pref.EnumKind,
+			Default:      pref.ValueOf(pref.EnumNumber(0)),
+			EnumType:     enumV1Type,
+			ExtendedType: parentType,
+		}, proto2_20180125.Message_ChildEnum(0)),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_message_v1",
+			Number:       10007,
+			Cardinality:  pref.Optional,
+			Kind:         pref.MessageKind,
+			MessageType:  messageV1Type,
+			ExtendedType: parentType,
+		}, (*proto2_20180125.Message_ChildMessage)(nil)),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_enum_v2",
+			Number:       10008,
+			Cardinality:  pref.Optional,
+			Kind:         pref.EnumKind,
+			Default:      pref.ValueOf(pref.EnumNumber(57005)),
+			EnumType:     enumV2Type,
+			ExtendedType: parentType,
+		}, EnumProto2(0)),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.optional_message_v2",
+			Number:       10009,
+			Cardinality:  pref.Optional,
+			Kind:         pref.MessageKind,
+			MessageType:  messageV2Type,
+			ExtendedType: parentType,
+		}, (*EnumMessages)(nil)),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_bool",
+			Number:       10010,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.BoolKind,
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_int32",
+			Number:       10011,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.Int32Kind,
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_uint32",
+			Number:       10012,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.Uint32Kind,
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_float",
+			Number:       10013,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.FloatKind,
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_string",
+			Number:       10014,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.StringKind,
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_bytes",
+			Number:       10015,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.BytesKind,
+			ExtendedType: parentType,
+		}, nil),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_enum_v1",
+			Number:       10016,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.EnumKind,
+			EnumType:     enumV1Type,
+			ExtendedType: parentType,
+		}, proto2_20180125.Message_ChildEnum(0)),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_message_v1",
+			Number:       10017,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.MessageKind,
+			MessageType:  messageV1Type,
+			ExtendedType: parentType,
+		}, (*proto2_20180125.Message_ChildMessage)(nil)),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_enum_v2",
+			Number:       10018,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.EnumKind,
+			EnumType:     enumV2Type,
+			ExtendedType: parentType,
+		}, EnumProto2(0)),
+		mustMakeExtensionType(&ptype.StandaloneExtension{
+			FullName:     "fizz.buzz.repeated_message_v2",
+			Number:       10019,
+			Cardinality:  pref.Repeated,
+			Kind:         pref.MessageKind,
+			MessageType:  messageV2Type,
+			ExtendedType: parentType,
+		}, (*EnumMessages)(nil)),
+	}
+
+	extensionDescs = []*papi.ExtensionDesc{{
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         10000,
+		Name:          "fizz.buzz.optional_bool",
+		Tag:           "varint,10000,opt,name=optional_bool,def=1",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*int32)(nil),
+		Field:         10001,
+		Name:          "fizz.buzz.optional_int32",
+		Tag:           "varint,10001,opt,name=optional_int32,def=-12345",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*uint32)(nil),
+		Field:         10002,
+		Name:          "fizz.buzz.optional_uint32",
+		Tag:           "varint,10002,opt,name=optional_uint32,def=3200",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*float32)(nil),
+		Field:         10003,
+		Name:          "fizz.buzz.optional_float",
+		Tag:           "fixed32,10003,opt,name=optional_float,def=3.14159",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*string)(nil),
+		Field:         10004,
+		Name:          "fizz.buzz.optional_string",
+		Tag:           "bytes,10004,opt,name=optional_string,def=hello, \"world!\"\n",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]byte)(nil),
+		Field:         10005,
+		Name:          "fizz.buzz.optional_bytes",
+		Tag:           "bytes,10005,opt,name=optional_bytes,def=dead\\336\\255\\276\\357beef",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*proto2_20180125.Message_ChildEnum)(nil),
+		Field:         10006,
+		Name:          "fizz.buzz.optional_enum_v1",
+		Tag:           "varint,10006,opt,name=optional_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil),
+		Field:         10007,
+		Name:          "fizz.buzz.optional_message_v1",
+		Tag:           "bytes,10007,opt,name=optional_message_v1",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*EnumProto2)(nil),
+		Field:         10008,
+		Name:          "fizz.buzz.optional_enum_v2",
+		Tag:           "varint,10008,opt,name=optional_enum_v2,enum=EnumProto2,def=57005",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: (*EnumMessages)(nil),
+		Field:         10009,
+		Name:          "fizz.buzz.optional_message_v2",
+		Tag:           "bytes,10009,opt,name=optional_message_v2",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]bool)(nil),
+		Field:         10010,
+		Name:          "fizz.buzz.repeated_bool",
+		Tag:           "varint,10010,rep,name=repeated_bool",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]int32)(nil),
+		Field:         10011,
+		Name:          "fizz.buzz.repeated_int32",
+		Tag:           "varint,10011,rep,name=repeated_int32",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]uint32)(nil),
+		Field:         10012,
+		Name:          "fizz.buzz.repeated_uint32",
+		Tag:           "varint,10012,rep,name=repeated_uint32",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]float32)(nil),
+		Field:         10013,
+		Name:          "fizz.buzz.repeated_float",
+		Tag:           "fixed32,10013,rep,name=repeated_float",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]string)(nil),
+		Field:         10014,
+		Name:          "fizz.buzz.repeated_string",
+		Tag:           "bytes,10014,rep,name=repeated_string",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([][]byte)(nil),
+		Field:         10015,
+		Name:          "fizz.buzz.repeated_bytes",
+		Tag:           "bytes,10015,rep,name=repeated_bytes",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]proto2_20180125.Message_ChildEnum)(nil),
+		Field:         10016,
+		Name:          "fizz.buzz.repeated_enum_v1",
+		Tag:           "varint,10016,rep,name=repeated_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]*proto2_20180125.Message_ChildMessage)(nil),
+		Field:         10017,
+		Name:          "fizz.buzz.repeated_message_v1",
+		Tag:           "bytes,10017,rep,name=repeated_message_v1",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]EnumProto2)(nil),
+		Field:         10018,
+		Name:          "fizz.buzz.repeated_enum_v2",
+		Tag:           "varint,10018,rep,name=repeated_enum_v2,enum=EnumProto2",
+	}, {
+		ExtendedType:  (*legacyTestMessage)(nil),
+		ExtensionType: ([]*EnumMessages)(nil),
+		Field:         10019,
+		Name:          "fizz.buzz.repeated_message_v2",
+		Tag:           "bytes,10019,rep,name=repeated_message_v2",
+	}}
+)
+
+func TestLegacyExtensions(t *testing.T) {
 	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()
+	fs := pimpl.Export{}.MessageOf(m).KnownFields()
 	ts := fs.ExtensionTypes()
 
 	if n := fs.Len(); n != 0 {
@@ -861,7 +580,7 @@
 	}
 
 	// Register all the extension types.
-	for _, xt := range extensions {
+	for _, xt := range extensionTypes {
 		ts.Register(xt)
 	}
 
@@ -889,7 +608,7 @@
 		new([]EnumProto2),
 		new([]*EnumMessages),
 	}
-	for i, xt := range extensions {
+	for i, xt := range extensionTypes {
 		var got interface{}
 		if v := fs.Get(xt.Number()); v.IsValid() {
 			got = xt.InterfaceOf(v)
@@ -901,7 +620,7 @@
 	}
 
 	// All fields should be unpopulated.
-	for _, xt := range extensions {
+	for _, xt := range extensionTypes {
 		if fs.Has(xt.Number()) {
 			t.Errorf("KnownFields.Has(%d) = true, want false", xt.Number())
 		}
@@ -934,11 +653,11 @@
 		&[]EnumProto2{0xdead},
 		&[]*EnumMessages{m2b},
 	}
-	for i, xt := range extensions {
+	for i, xt := range extensionTypes {
 		fs.Set(xt.Number(), xt.ValueOf(setValues[i]))
 	}
-	for i, xt := range extensions[len(extensions)/2:] {
-		v := extensions[i].ValueOf(setValues[i])
+	for i, xt := range extensionTypes[len(extensionTypes)/2:] {
+		v := extensionTypes[i].ValueOf(setValues[i])
 		fs.Get(xt.Number()).List().Append(v)
 	}
 
@@ -965,7 +684,7 @@
 		&[]EnumProto2{0xdead, 0xbeef},
 		&[]*EnumMessages{m2b, m2a},
 	}
-	for i, xt := range extensions {
+	for i, xt := range extensionTypes {
 		got := xt.InterfaceOf(fs.Get(xt.Number()))
 		want := getValues[i]
 		if diff := cmp.Diff(want, got, opts); diff != "" {
@@ -981,10 +700,10 @@
 	}
 
 	// Clear the field for all extension types.
-	for _, xt := range extensions[:len(extensions)/2] {
+	for _, xt := range extensionTypes[:len(extensionTypes)/2] {
 		fs.Clear(xt.Number())
 	}
-	for i, xt := range extensions[len(extensions)/2:] {
+	for i, xt := range extensionTypes[len(extensionTypes)/2:] {
 		if i%2 == 0 {
 			fs.Clear(xt.Number())
 		} else {
@@ -999,7 +718,7 @@
 	}
 
 	// De-register all extension types.
-	for _, xt := range extensions {
+	for _, xt := range extensionTypes {
 		ts.Remove(xt)
 	}
 	if n := fs.Len(); n != 0 {
@@ -1008,5 +727,78 @@
 	if n := ts.Len(); n != 0 {
 		t.Errorf("ExtensionFieldTypes.Len() = %v, want 0", n)
 	}
+}
 
+func TestExtensionConvert(t *testing.T) {
+	for i := range extensionTypes {
+		i := i
+		t.Run("", func(t *testing.T) {
+			t.Parallel()
+
+			wantType := extensionTypes[i]
+			wantDesc := extensionDescs[i]
+			gotType := plegacy.Export{}.ExtensionTypeFromDesc(wantDesc)
+			gotDesc := plegacy.Export{}.ExtensionDescFromType(wantType)
+
+			// TODO: We need a test package to compare descriptors.
+			type list interface {
+				Len() int
+				pragma.DoNotImplement
+			}
+			opts := cmp.Options{
+				cmp.Comparer(func(x, y reflect.Type) bool {
+					return x == y
+				}),
+				cmp.Transformer("", func(x list) []interface{} {
+					out := make([]interface{}, x.Len())
+					v := reflect.ValueOf(x)
+					for i := 0; i < x.Len(); i++ {
+						m := v.MethodByName("Get")
+						out[i] = m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
+					}
+					return out
+				}),
+				cmp.Transformer("", func(x pref.Descriptor) map[string]interface{} {
+					out := make(map[string]interface{})
+					v := reflect.ValueOf(x)
+					for i := 0; i < v.NumMethod(); i++ {
+						name := v.Type().Method(i).Name
+						if m := v.Method(i); m.Type().NumIn() == 0 && m.Type().NumOut() == 1 {
+							switch name {
+							case "New":
+								// Ignore New since it a constructor.
+							case "Options":
+								// Ignore descriptor options since protos are not cmperable.
+							case "EnumType", "MessageType", "ExtendedType":
+								// Avoid descending into a dependency to avoid a cycle.
+								// Just record the full name if available.
+								//
+								// TODO: Cycle support in cmp would be useful here.
+								v := m.Call(nil)[0]
+								if !v.IsNil() {
+									out[name] = v.Interface().(pref.Descriptor).FullName()
+								}
+							default:
+								out[name] = m.Call(nil)[0].Interface()
+							}
+						}
+					}
+					return out
+				}),
+				cmp.Transformer("", func(v pref.Value) interface{} {
+					return v.Interface()
+				}),
+			}
+			if diff := cmp.Diff(&wantType, &gotType, opts); diff != "" {
+				t.Errorf("ExtensionType mismatch (-want, +got):\n%v", diff)
+			}
+
+			opts = cmp.Options{
+				cmpopts.IgnoreFields(papi.ExtensionDesc{}, "Type"),
+			}
+			if diff := cmp.Diff(wantDesc, gotDesc, opts); diff != "" {
+				t.Errorf("ExtensionDesc mismatch (-want, +got):\n%v", diff)
+			}
+		})
+	}
 }
diff --git a/internal/impl/message.go b/internal/impl/message.go
index c0b1029..089c6e7 100644
--- a/internal/impl/message.go
+++ b/internal/impl/message.go
@@ -11,20 +11,10 @@
 	"strings"
 	"sync"
 
+	pvalue "github.com/golang/protobuf/v2/internal/value"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 )
 
-// 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.
@@ -165,6 +155,10 @@
 	}
 }
 
+func (mi *MessageType) MessageOf(p interface{}) pref.Message {
+	return (*messageWrapper)(mi.dataTypeOf(p))
+}
+
 func (mi *MessageType) KnownFieldsOf(p interface{}) pref.KnownFields {
 	return (*knownFields)(mi.dataTypeOf(p))
 }
@@ -201,6 +195,33 @@
 	mi *MessageType
 }
 
+type messageWrapper messageDataType
+
+func (m *messageWrapper) Type() pref.MessageType {
+	return m.mi.Type
+}
+func (m *messageWrapper) KnownFields() pref.KnownFields {
+	return (*knownFields)(m)
+}
+func (m *messageWrapper) UnknownFields() pref.UnknownFields {
+	return m.mi.unknownFields((*messageDataType)(m))
+}
+func (m *messageWrapper) Interface() pref.ProtoMessage {
+	if m, ok := m.ProtoUnwrap().(pref.ProtoMessage); ok {
+		return m
+	}
+	return m
+}
+func (m *messageWrapper) ProtoReflect() pref.Message {
+	return m
+}
+func (m *messageWrapper) ProtoUnwrap() interface{} {
+	return m.p.asType(m.mi.goType.Elem()).Interface()
+}
+func (m *messageWrapper) ProtoMutable() {}
+
+var _ pvalue.Unwrapper = (*messageWrapper)(nil)
+
 type knownFields messageDataType
 
 func (fs *knownFields) Len() (cnt int) {
diff --git a/internal/impl/message_field.go b/internal/impl/message_field.go
index e92a7ca..681c918 100644
--- a/internal/impl/message_field.go
+++ b/internal/impl/message_field.go
@@ -42,7 +42,7 @@
 	if !reflect.PtrTo(ot).Implements(ft) {
 		panic(fmt.Sprintf("invalid type: %v does not implement %v", ot, ft))
 	}
-	conv := newConverter(ot.Field(0).Type, fd.Kind())
+	conv := pvalue.NewLegacyConverter(ot.Field(0).Type, fd.Kind(), legacyWrapper)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -104,8 +104,8 @@
 	if ft.Kind() != reflect.Map {
 		panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
 	}
-	keyConv := newConverter(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind())
-	valConv := newConverter(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind())
+	keyConv := pvalue.NewLegacyConverter(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind(), legacyWrapper)
+	valConv := pvalue.NewLegacyConverter(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind(), legacyWrapper)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -137,7 +137,7 @@
 	if ft.Kind() != reflect.Slice {
 		panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
 	}
-	conv := newConverter(ft.Elem(), fd.Kind())
+	conv := pvalue.NewLegacyConverter(ft.Elem(), fd.Kind(), legacyWrapper)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -177,7 +177,7 @@
 			ft = ft.Elem()
 		}
 	}
-	conv := newConverter(ft, fd.Kind())
+	conv := pvalue.NewLegacyConverter(ft, fd.Kind(), legacyWrapper)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -242,7 +242,7 @@
 
 func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
 	ft := fs.Type
-	conv := newConverter(ft, fd.Kind())
+	conv := pvalue.NewLegacyConverter(ft, fd.Kind(), legacyWrapper)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -279,12 +279,3 @@
 		},
 	}
 }
-
-// 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)
-}
diff --git a/internal/impl/message_test.go b/internal/impl/message_test.go
index eeb4e7a..d388494 100644
--- a/internal/impl/message_test.go
+++ b/internal/impl/message_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package impl
+package impl_test
 
 import (
 	"fmt"
@@ -12,14 +12,19 @@
 
 	protoV1 "github.com/golang/protobuf/proto"
 	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	pimpl "github.com/golang/protobuf/v2/internal/impl"
 	scalar "github.com/golang/protobuf/v2/internal/scalar"
+	pvalue "github.com/golang/protobuf/v2/internal/value"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 	cmp "github.com/google/go-cmp/cmp"
 	cmpopts "github.com/google/go-cmp/cmp/cmpopts"
 
+	// The legacy package must be imported prior to use of any legacy messages.
+	// TODO: Remove this when protoV1 registers these hooks for you.
+	_ "github.com/golang/protobuf/v2/internal/legacy"
+
 	proto2_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
-	pvalue "github.com/golang/protobuf/v2/internal/value"
 )
 
 // List of test operations to perform on messages, lists, or maps.
@@ -184,7 +189,7 @@
 	MapBytes   map[MyString]MyBytes
 )
 
-var scalarProto2Type = MessageType{Type: ptype.GoMessage(
+var scalarProto2Type = pimpl.MessageType{Type: ptype.GoMessage(
 	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "ScalarProto2",
@@ -279,7 +284,7 @@
 	MyBytesA  MyString  `protobuf:"22"`
 }
 
-var scalarProto3Type = MessageType{Type: ptype.GoMessage(
+var scalarProto3Type = pimpl.MessageType{Type: ptype.GoMessage(
 	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto3,
 		FullName: "ScalarProto3",
@@ -387,7 +392,7 @@
 	MyBytes4   ListStrings `protobuf:"19"`
 }
 
-var listScalarsType = MessageType{Type: ptype.GoMessage(
+var listScalarsType = pimpl.MessageType{Type: ptype.GoMessage(
 	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "ListScalars",
@@ -565,7 +570,7 @@
 	}
 }
 
-var mapScalarsType = MessageType{Type: ptype.GoMessage(
+var mapScalarsType = pimpl.MessageType{Type: ptype.GoMessage(
 	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "MapScalars",
@@ -732,7 +737,7 @@
 	Union isOneofScalars_Union `protobuf_oneof:"union"`
 }
 
-var oneofScalarsType = MessageType{Type: ptype.GoMessage(
+var oneofScalarsType = pimpl.MessageType{Type: ptype.GoMessage(
 	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "OneofScalars",
@@ -933,14 +938,14 @@
 	Union         isEnumMessages_Union     `protobuf_oneof:"union"`
 }
 
-var enumMessagesType = MessageType{Type: ptype.GoMessage(
+var enumMessagesType = pimpl.MessageType{Type: ptype.GoMessage(
 	mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "EnumMessages",
 		Fields: []ptype.Field{
 			{Name: "f1", Number: 1, Cardinality: pref.Optional, Kind: pref.EnumKind, Default: V("BEEF"), EnumType: enumProto2Type},
 			{Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.EnumKind, Default: V("BRAVO"), EnumType: enumProto3Type},
-			{Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: MessageOf(new(proto2_20180125.Message)).Type()},
+			{Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: pimpl.Export{}.MessageOf(new(proto2_20180125.Message)).Type()},
 			{Name: "f4", Number: 4, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: ptype.PlaceholderMessage("EnumMessages")},
 			{Name: "f5", Number: 5, Cardinality: pref.Repeated, Kind: pref.EnumKind, EnumType: enumProto2Type},
 			{Name: "f6", Number: 6, Cardinality: pref.Repeated, Kind: pref.MessageKind, MessageType: scalarProto2Type.Type},
@@ -1018,7 +1023,7 @@
 func (*EnumMessages_OneofM3) isEnumMessages_Union() {}
 
 func TestEnumMessages(t *testing.T) {
-	wantL := MessageOf(&proto2_20180125.Message{OptionalFloat: scalar.Float32(math.E)})
+	wantL := pimpl.Export{}.MessageOf(&proto2_20180125.Message{OptionalFloat: scalar.Float32(math.E)})
 	wantM := &EnumMessages{EnumP2: EnumProto2(1234).Enum()}
 	wantM2a := &ScalarProto2{Float32: scalar.Float32(math.Pi)}
 	wantM2b := &ScalarProto2{Float32: scalar.Float32(math.Phi)}
diff --git a/internal/impl/legacy_enum.go b/internal/legacy/enum.go
similarity index 97%
rename from internal/impl/legacy_enum.go
rename to internal/legacy/enum.go
index 497b842..86cc7f2 100644
--- a/internal/impl/legacy_enum.go
+++ b/internal/legacy/enum.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package impl
+package legacy
 
 import (
 	"fmt"
@@ -17,7 +17,7 @@
 )
 
 // legacyWrapEnum wraps v as a protoreflect.ProtoEnum,
-// where v must be a *struct kind and not implement the v2 API already.
+// where v must be a int32 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()))
diff --git a/internal/legacy/export.go b/internal/legacy/export.go
new file mode 100644
index 0000000..c8059a0
--- /dev/null
+++ b/internal/legacy/export.go
@@ -0,0 +1,50 @@
+// 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 legacy
+
+import (
+	"reflect"
+
+	protoV1 "github.com/golang/protobuf/proto"
+	pimpl "github.com/golang/protobuf/v2/internal/impl"
+	pvalue "github.com/golang/protobuf/v2/internal/value"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+// Export is a zero-length named type that exists only to export a set of
+// functions that we do not want to appear in godoc.
+type Export struct{}
+
+func (Export) EnumOf(e interface{}) pvalue.LegacyEnum {
+	return legacyWrapEnum(reflect.ValueOf(e)).ProtoReflect().(pvalue.LegacyEnum)
+}
+
+func (Export) EnumTypeOf(e interface{}) pref.EnumType {
+	return legacyLoadEnumType(reflect.TypeOf(e))
+}
+
+func (Export) MessageOf(m interface{}) pvalue.LegacyMessage {
+	return legacyWrapMessage(reflect.ValueOf(m)).ProtoReflect().(pvalue.LegacyMessage)
+}
+
+func (Export) MessageTypeOf(m interface{}) pref.MessageType {
+	return legacyLoadMessageType(reflect.TypeOf(m)).Type
+}
+
+func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
+	return legacyExtensionTypeOf(d, reflect.TypeOf(t))
+}
+
+func (Export) ExtensionDescFromType(t pref.ExtensionType) *protoV1.ExtensionDesc {
+	return legacyExtensionDescFromType(t)
+}
+
+func (Export) ExtensionTypeFromDesc(d *protoV1.ExtensionDesc) pref.ExtensionType {
+	return legacyExtensionTypeFromDesc(d)
+}
+
+func init() {
+	pimpl.RegisterLegacyWrapper(Export{})
+}
diff --git a/internal/legacy/extension.go b/internal/legacy/extension.go
new file mode 100644
index 0000000..700bc43
--- /dev/null
+++ b/internal/legacy/extension.go
@@ -0,0 +1,206 @@
+// 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 legacy
+
+import (
+	"fmt"
+	"reflect"
+
+	papi "github.com/golang/protobuf/protoapi"
+	ptag "github.com/golang/protobuf/v2/internal/encoding/tag"
+	pimpl "github.com/golang/protobuf/v2/internal/impl"
+	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 legacyExtensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
+	if t, ok := t.(dualExtensionType); ok {
+		return t.desc
+	}
+
+	// Determine the parent type if possible.
+	var parent papi.Message
+	if mt, ok := t.ExtendedType().(pref.MessageType); ok {
+		// Create a new parent message and unwrap it if possible.
+		mv := mt.New()
+		t := reflect.TypeOf(mv)
+		if mv, ok := mv.(pvalue.Unwrapper); ok {
+			t = reflect.TypeOf(mv.ProtoUnwrap())
+		}
+
+		// Check whether the message implements the legacy v1 Message interface.
+		mz := reflect.Zero(t).Interface()
+		if mz, ok := mz.(papi.Message); ok {
+			parent = mz
+		}
+	}
+
+	// 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 {
+		// Derive Go type name.
+		// For legacy enums, unwrap the wrapper to get the underlying Go type.
+		et := t.EnumType().(pref.EnumType)
+		var ev interface{} = et.New(0)
+		if u, ok := ev.(pvalue.Unwrapper); ok {
+			ev = u.ProtoUnwrap()
+		}
+		enumName = reflect.TypeOf(ev).Name()
+
+		// Derive the proto package name.
+		// For legacy enums, obtain the proto package from the raw descriptor.
+		var protoPkg string
+		if fd := parentFileDescriptor(et); fd != nil {
+			protoPkg = string(fd.Package())
+		}
+		if ed, ok := ev.(legacyEnum); ok && protoPkg == "" {
+			b, _ := ed.EnumDescriptor()
+			protoPkg = legacyLoadFileDesc(b).GetPackage()
+		}
+
+		if protoPkg != "" {
+			enumName = protoPkg + "." + enumName
+		}
+	}
+
+	// Derive the proto file that the extension was declared within.
+	var filename string
+	if fd := parentFileDescriptor(t); fd != nil {
+		filename = fd.Path()
+	}
+
+	// Construct and return a v1 ExtensionDesc.
+	return &papi.ExtensionDesc{
+		Type:          t,
+		ExtendedType:  parent,
+		ExtensionType: reflect.Zero(extType).Interface(),
+		Field:         int32(t.Number()),
+		Name:          string(t.FullName()),
+		Tag:           ptag.Marshal(t, enumName),
+		Filename:      filename,
+	}
+}
+
+func legacyExtensionTypeFromDesc(d *papi.ExtensionDesc) pref.ExtensionType {
+	if d.Type != nil {
+		return dualExtensionType{d.Type, d}
+	}
+
+	// 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 := pvalue.NewLegacyConverter(t, f.Kind, Export{})
+	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: Export{}.MessageTypeOf(d.ExtendedType),
+	})
+	if err != nil {
+		panic(err)
+	}
+	xt := pimpl.Export{}.ExtensionTypeOf(xd, reflect.Zero(t).Interface())
+	return dualExtensionType{xt, d}
+}
+
+type dualExtensionType struct {
+	pref.ExtensionType
+	desc *papi.ExtensionDesc
+}
+
+// TODO: Provide custom stringer for dualExtensionType.
+
+// legacyExtensionTypeOf returns a protoreflect.ExtensionType where the GoType
+// is the underlying v1 Go type instead of the wrapper types used to present
+// v1 Go types as if they satisfied the v2 API.
+//
+// This function is only valid if xd.Kind is an enum or message.
+func legacyExtensionTypeOf(xd pref.ExtensionDescriptor, t reflect.Type) pref.ExtensionType {
+	// Step 1: Create an ExtensionType where GoType is the wrapper type.
+	conv := pvalue.NewLegacyConverter(t, xd.Kind(), Export{})
+	xt := ptype.GoExtension(xd, conv.EnumType, conv.MessageType)
+
+	// Step 2: Wrap ExtensionType such that GoType presents the legacy Go type.
+	xt2 := &legacyExtensionType{ExtensionType: xt}
+	if xd.Cardinality() != pref.Repeated {
+		xt2.typ = t
+		xt2.new = func() interface{} {
+			return xt.New().(pvalue.Unwrapper).ProtoUnwrap()
+		}
+		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(Export{}.EnumOf(v))
+			} else {
+				return xt.ValueOf(Export{}.MessageOf(v))
+			}
+		}
+		xt2.interfaceOf = func(v pref.Value) interface{} {
+			return xt.InterfaceOf(v).(pvalue.Unwrapper).ProtoUnwrap()
+		}
+	} else {
+		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.ListOf(v, conv))
+		}
+		xt2.interfaceOf = func(pv pref.Value) interface{} {
+			v := pv.List().(pvalue.Unwrapper).ProtoUnwrap()
+			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
+	typ         reflect.Type
+	new         func() interface{}
+	valueOf     func(interface{}) pref.Value
+	interfaceOf func(pref.Value) interface{}
+}
+
+func (x *legacyExtensionType) GoType() reflect.Type                 { return x.typ }
+func (x *legacyExtensionType) New() interface{}                     { return x.new() }
+func (x *legacyExtensionType) ValueOf(v interface{}) pref.Value     { return x.valueOf(v) }
+func (x *legacyExtensionType) InterfaceOf(v pref.Value) interface{} { return x.interfaceOf(v) }
+
+// TODO: Provide custom stringer with the new GoType.
diff --git a/internal/impl/legacy_file.go b/internal/legacy/file.go
similarity index 84%
rename from internal/impl/legacy_file.go
rename to internal/legacy/file.go
index 8aaa936..48b4d1c 100644
--- a/internal/impl/legacy_file.go
+++ b/internal/legacy/file.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package impl
+package legacy
 
 import (
 	"bytes"
@@ -15,6 +15,7 @@
 	// the new API.
 	protoV1 "github.com/golang/protobuf/proto"
 	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 )
 
 // Every enum and message type generated by protoc-gen-go since commit 2fc053c5
@@ -66,3 +67,14 @@
 	fileDescCache.Store(&b[0], m)
 	return m
 }
+
+// parentFileDescriptor returns the parent protoreflect.FileDescriptor for the
+// provide descriptor. It returns nil if there is no parent.
+func parentFileDescriptor(d pref.Descriptor) pref.FileDescriptor {
+	for ok := true; ok; d, ok = d.Parent() {
+		if fd, _ := d.(pref.FileDescriptor); fd != nil {
+			return fd
+		}
+	}
+	return nil
+}
diff --git a/internal/legacy/file_test.go b/internal/legacy/file_test.go
new file mode 100644
index 0000000..6d994ac
--- /dev/null
+++ b/internal/legacy/file_test.go
@@ -0,0 +1,440 @@
+// 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 legacy
+
+import (
+	"reflect"
+	"testing"
+
+	pragma "github.com/golang/protobuf/v2/internal/pragma"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+	ptype "github.com/golang/protobuf/v2/reflect/prototype"
+	cmp "github.com/google/go-cmp/cmp"
+
+	proto2_20160225 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v0.0.0-20160225-2fc053c5"
+	proto2_20160519 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v0.0.0-20160519-a4ab9ec5"
+	proto2_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
+	proto2_20180430 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.1.0-20180430-b4deda09"
+	proto2_20180814 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.2.0-20180814-aa810b61"
+	proto2_20181126 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.2.1-20181126-8d0c54c1"
+	proto3_20160225 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v0.0.0-20160225-2fc053c5"
+	proto3_20160519 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v0.0.0-20160519-a4ab9ec5"
+	proto3_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.0.0-20180125-92554152"
+	proto3_20180430 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.1.0-20180430-b4deda09"
+	proto3_20180814 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.2.0-20180814-aa810b61"
+	proto3_20181126 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.2.1-20181126-8d0c54c1"
+)
+
+func mustLoadFileDesc(b []byte, _ []int) pref.FileDescriptor {
+	fd, err := ptype.NewFileFromDescriptorProto(legacyLoadFileDesc(b), nil)
+	if err != nil {
+		panic(err)
+	}
+	return fd
+}
+
+func TestDescriptor(t *testing.T) {
+	var tests []struct{ got, want pref.Descriptor }
+
+	fileDescP2_20160225 := mustLoadFileDesc(new(proto2_20160225.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
+		want: fileDescP2_20160225.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
+		want: fileDescP2_20160225.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
+		want: fileDescP2_20160225.Messages().ByName("Message"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OptionalGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RequiredGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RepeatedGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OneofGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
+		want: fileDescP3_20160225.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
+		want: fileDescP3_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
+		want: fileDescP3_20160225.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
+		want: fileDescP3_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
+		want: fileDescP2_20160519.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
+		want: fileDescP2_20160519.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
+		want: fileDescP2_20160519.Messages().ByName("Message"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OptionalGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RequiredGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RepeatedGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OneofGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
+		want: fileDescP3_20160519.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
+		want: fileDescP3_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
+		want: fileDescP3_20160519.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
+		want: fileDescP3_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
+		want: fileDescP2_20180125.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
+		want: fileDescP2_20180125.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
+		want: fileDescP2_20180125.Messages().ByName("Message"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OptionalGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RequiredGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RepeatedGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OneofGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
+		want: fileDescP3_20180125.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
+		want: fileDescP3_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
+		want: fileDescP3_20180125.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
+		want: fileDescP3_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
+		want: fileDescP2_20180430.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
+		want: fileDescP2_20180430.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
+		want: fileDescP2_20180430.Messages().ByName("Message"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OptionalGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RequiredGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RepeatedGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OneofGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
+		want: fileDescP3_20180430.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
+		want: fileDescP3_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
+		want: fileDescP3_20180430.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
+		want: fileDescP3_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
+		want: fileDescP2_20180814.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
+		want: fileDescP2_20180814.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
+		want: fileDescP2_20180814.Messages().ByName("Message"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OptionalGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RequiredGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RepeatedGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OneofGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		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:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
+		want: fileDescP3_20180814.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
+		want: fileDescP3_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
+		want: fileDescP3_20180814.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
+		want: fileDescP3_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
+		want: fileDescP3_20180814.Messages().ByName("Message"),
+	}}...)
+
+	fileDescP2_20181126 := mustLoadFileDesc(new(proto2_20181126.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.SiblingEnum(0))),
+		want: fileDescP2_20181126.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.Message_ChildEnum(0))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.SiblingMessage))),
+		want: fileDescP2_20181126.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ChildMessage))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message))),
+		want: fileDescP2_20181126.Messages().ByName("Message"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_NamedGroup))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("NamedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OptionalGroup))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RequiredGroup))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RepeatedGroup))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OneofGroup))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("OneofGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionOptionalGroup))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionRepeatedGroup))),
+		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
+	}}...)
+
+	fileDescP3_20181126 := mustLoadFileDesc(new(proto3_20181126.Message).Descriptor())
+	tests = append(tests, []struct{ got, want pref.Descriptor }{{
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.SiblingEnum(0))),
+		want: fileDescP3_20181126.Enums().ByName("SiblingEnum"),
+	}, {
+		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.Message_ChildEnum(0))),
+		want: fileDescP3_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.SiblingMessage))),
+		want: fileDescP3_20181126.Messages().ByName("SiblingMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message_ChildMessage))),
+		want: fileDescP3_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+	}, {
+		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message))),
+		want: fileDescP3_20181126.Messages().ByName("Message"),
+	}}...)
+
+	// TODO: We need a test package to compare descriptors.
+	type list interface {
+		Len() int
+		pragma.DoNotImplement
+	}
+	opts := cmp.Options{
+		cmp.Transformer("", func(x list) []interface{} {
+			out := make([]interface{}, x.Len())
+			v := reflect.ValueOf(x)
+			for i := 0; i < x.Len(); i++ {
+				m := v.MethodByName("Get")
+				out[i] = m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
+			}
+			return out
+		}),
+		cmp.Transformer("", func(x pref.Descriptor) map[string]interface{} {
+			out := make(map[string]interface{})
+			v := reflect.ValueOf(x)
+			for i := 0; i < v.NumMethod(); i++ {
+				name := v.Type().Method(i).Name
+				if m := v.Method(i); m.Type().NumIn() == 0 && m.Type().NumOut() == 1 {
+					switch name {
+					case "Index":
+						// Ignore index since legacy descriptors have no parent.
+					case "Options":
+						// Ignore descriptor options since protos are not cmperable.
+					case "Enums", "Messages", "Extensions":
+						// Ignore nested message and enum declarations since
+						// legacy descriptors are all created standalone.
+					case "OneofType", "ExtendedType", "EnumType", "MessageType":
+						// Avoid descending into a dependency to avoid a cycle.
+						// Just record the full name if available.
+						//
+						// TODO: Cycle support in cmp would be useful here.
+						v := m.Call(nil)[0]
+						if !v.IsNil() {
+							out[name] = v.Interface().(pref.Descriptor).FullName()
+						}
+					default:
+						out[name] = m.Call(nil)[0].Interface()
+					}
+				}
+			}
+			return out
+		}),
+		cmp.Transformer("", func(v pref.Value) interface{} {
+			return v.Interface()
+		}),
+	}
+
+	for _, tt := range tests {
+		t.Run(string(tt.want.FullName()), func(t *testing.T) {
+			if diff := cmp.Diff(&tt.want, &tt.got, opts); diff != "" {
+				t.Errorf("descriptor mismatch (-want, +got):\n%s", diff)
+			}
+		})
+	}
+}
diff --git a/internal/impl/legacy_message.go b/internal/legacy/message.go
similarity index 89%
rename from internal/impl/legacy_message.go
rename to internal/legacy/message.go
index 6b53e2b..a81bb2e 100644
--- a/internal/impl/legacy_message.go
+++ b/internal/legacy/message.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package impl
+package legacy
 
 import (
 	"fmt"
@@ -13,8 +13,8 @@
 
 	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
 	ptag "github.com/golang/protobuf/v2/internal/encoding/tag"
+	pimpl "github.com/golang/protobuf/v2/internal/impl"
 	scalar "github.com/golang/protobuf/v2/internal/scalar"
-	pvalue "github.com/golang/protobuf/v2/internal/value"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )
@@ -23,58 +23,30 @@
 // 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()))
+	return mt.MessageOf(v.Interface()).Interface()
 }
 
 var messageTypeCache sync.Map // map[reflect.Type]*MessageType
 
 // 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 {
+func legacyLoadMessageType(t reflect.Type) *pimpl.MessageType {
 	// Fast-path: check if a MessageType is cached for this concrete type.
 	if mt, ok := messageTypeCache.Load(t); ok {
-		return mt.(*MessageType)
+		return mt.(*pimpl.MessageType)
 	}
 
 	// Slow-path: derive message descriptor and initialize MessageType.
 	md := legacyLoadMessageDesc(t)
-	mt := new(MessageType)
+	mt := new(pimpl.MessageType)
 	mt.Type = ptype.GoMessage(md, func(pref.MessageType) pref.ProtoMessage {
 		p := reflect.New(t.Elem()).Interface()
-		return (*legacyMessageWrapper)(mt.dataTypeOf(p))
+		return mt.MessageOf(p).Interface()
 	})
 	messageTypeCache.Store(t, mt)
 	return mt
 }
 
-type legacyMessageWrapper messageDataType
-
-func (m *legacyMessageWrapper) Type() pref.MessageType {
-	return m.mi.Type
-}
-func (m *legacyMessageWrapper) KnownFields() pref.KnownFields {
-	return (*knownFields)(m)
-}
-func (m *legacyMessageWrapper) UnknownFields() pref.UnknownFields {
-	return m.mi.unknownFields((*messageDataType)(m))
-}
-func (m *legacyMessageWrapper) Interface() pref.ProtoMessage {
-	return m
-}
-func (m *legacyMessageWrapper) ProtoReflect() pref.Message {
-	return m
-}
-func (m *legacyMessageWrapper) ProtoUnwrap() interface{} {
-	return m.p.asType(m.mi.goType.Elem()).Interface()
-}
-func (m *legacyMessageWrapper) ProtoMutable() {}
-
-var (
-	_ pref.Message      = (*legacyMessageWrapper)(nil)
-	_ pref.ProtoMessage = (*legacyMessageWrapper)(nil)
-	_ pvalue.Unwrapper  = (*legacyMessageWrapper)(nil)
-)
-
 var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
 
 // legacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
diff --git a/internal/value/convert.go b/internal/value/convert.go
index cc9d94d..5f4109a 100644
--- a/internal/value/convert.go
+++ b/internal/value/convert.go
@@ -47,23 +47,41 @@
 // 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, nil)
+	return NewLegacyConverter(t, k, 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.
+// LegacyWrapper is a set of wrapper methods that wraps legacy v1 Go types
+// to implement the v2 reflection APIs.
 type (
-	enumTypeOf     = func(reflect.Type) pref.EnumType
-	messageTypeOf  = func(reflect.Type) pref.MessageType
-	messageValueOf = func(reflect.Value) pref.ProtoMessage
+	LegacyWrapper interface {
+		EnumOf(interface{}) LegacyEnum
+		EnumTypeOf(interface{}) pref.EnumType
+
+		MessageOf(interface{}) LegacyMessage
+		MessageTypeOf(interface{}) pref.MessageType
+
+		ExtensionTypeOf(pref.ExtensionDescriptor, interface{}) pref.ExtensionType
+
+		// TODO: Remove these eventually. See the TODOs in protoapi.
+		ExtensionDescFromType(pref.ExtensionType) *papi.ExtensionDesc
+		ExtensionTypeFromDesc(*papi.ExtensionDesc) pref.ExtensionType
+	}
+
+	LegacyEnum = interface {
+		pref.Enum
+		ProtoUnwrap() interface{}
+	}
+
+	LegacyMessage = interface {
+		pref.Message
+		ProtoUnwrap() interface{}
+	}
 )
 
 // NewLegacyConverter is identical to NewConverter,
 // but supports wrapping legacy v1 messages to implement the v2 message API
-// using the provided enumTypeOf, messageTypeOf and messageValueOf functions.
-// The wrapped message must implement Unwrapper.
-func NewLegacyConverter(t reflect.Type, k pref.Kind, etOf enumTypeOf, mtOf messageTypeOf, mvOf messageValueOf) Converter {
+// using the provided LegacyWrapper.
+func NewLegacyConverter(t reflect.Type, k pref.Kind, w LegacyWrapper) Converter {
 	switch k {
 	case pref.BoolKind:
 		if t.Kind() == reflect.Bool {
@@ -125,8 +143,8 @@
 		}
 
 		// Handle v1 enums, which we identify as simply a named int32 type.
-		if etOf != nil && t.PkgPath() != "" && t.Kind() == reflect.Int32 {
-			et := etOf(t)
+		if w != nil && t.PkgPath() != "" && t.Kind() == reflect.Int32 {
+			et := w.EnumTypeOf(reflect.Zero(t).Interface())
 			return Converter{
 				PBValueOf: func(v reflect.Value) pref.Value {
 					if v.Type() != t {
@@ -164,14 +182,14 @@
 		}
 
 		// Handle v1 messages, which we need to wrap as a v2 message.
-		if mtOf != nil && t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
-			mt := mtOf(t)
+		if w != nil && t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
+			mt := w.MessageTypeOf(reflect.Zero(t).Interface())
 			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(mvOf(v).ProtoReflect())
+					return pref.ValueOf(w.MessageOf(v.Interface()))
 				},
 				GoValueOf: func(v pref.Value) reflect.Value {
 					rv := reflect.ValueOf(v.Message().(Unwrapper).ProtoUnwrap())