internal/legacy: drop legacy prefix

The legacy prefix made sense when this functionality was part of impl.
Now that it is in its own package called legacy, the legacy prefix is silly.

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

internal/legacy/enum.go

@@ -16,18 +16,18 @@ import (
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )
 
-// legacyWrapEnum wraps v as a protoreflect.ProtoEnum,
+// wrapEnum wraps v as a protoreflect.ProtoEnum,
 // 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())
+func wrapEnum(v reflect.Value) pref.ProtoEnum {
+	et := loadEnumType(v.Type())
 	return et.New(pref.EnumNumber(v.Int()))
 }
 
 var enumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
 
-// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
+// loadEnumType dynamically loads a protoreflect.EnumType for t,
 // where t must be an int32 kind and not implement the v2 API already.
-func legacyLoadEnumType(t reflect.Type) pref.EnumType {
+func loadEnumType(t reflect.Type) pref.EnumType {
 	// Fast-path: check if a EnumType is cached for this concrete type.
 	if et, ok := enumTypeCache.Load(t); ok {
 		return et.(pref.EnumType)
@@ -35,12 +35,12 @@ func legacyLoadEnumType(t reflect.Type) pref.EnumType {
 
 	// Slow-path: derive enum descriptor and initialize EnumType.
 	var m sync.Map // map[protoreflect.EnumNumber]proto.Enum
-	ed := legacyLoadEnumDesc(t)
+	ed := loadEnumDesc(t)
 	et := ptype.GoEnum(ed, func(et pref.EnumType, n pref.EnumNumber) pref.ProtoEnum {
 		if e, ok := m.Load(n); ok {
 			return e.(pref.ProtoEnum)
 		}
-		e := &legacyEnumWrapper{num: n, pbTyp: et, goTyp: t}
+		e := &enumWrapper{num: n, pbTyp: et, goTyp: t}
 		m.Store(n, e)
 		return e
 	})
@@ -48,40 +48,40 @@ func legacyLoadEnumType(t reflect.Type) pref.EnumType {
 	return et.(pref.EnumType)
 }
 
-type legacyEnumWrapper struct {
+type enumWrapper struct {
 	num   pref.EnumNumber
 	pbTyp pref.EnumType
 	goTyp reflect.Type
 }
 
-func (e *legacyEnumWrapper) Number() pref.EnumNumber {
+func (e *enumWrapper) Number() pref.EnumNumber {
 	return e.num
 }
-func (e *legacyEnumWrapper) Type() pref.EnumType {
+func (e *enumWrapper) Type() pref.EnumType {
 	return e.pbTyp
 }
-func (e *legacyEnumWrapper) ProtoReflect() pref.Enum {
+func (e *enumWrapper) ProtoReflect() pref.Enum {
 	return e
 }
-func (e *legacyEnumWrapper) ProtoUnwrap() interface{} {
+func (e *enumWrapper) ProtoUnwrap() interface{} {
 	v := reflect.New(e.goTyp).Elem()
 	v.SetInt(int64(e.num))
 	return v.Interface()
 }
 
 var (
-	_ pref.Enum        = (*legacyEnumWrapper)(nil)
-	_ pref.ProtoEnum   = (*legacyEnumWrapper)(nil)
-	_ pvalue.Unwrapper = (*legacyEnumWrapper)(nil)
+	_ pref.Enum        = (*enumWrapper)(nil)
+	_ pref.ProtoEnum   = (*enumWrapper)(nil)
+	_ pvalue.Unwrapper = (*enumWrapper)(nil)
 )
 
 var enumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
 
 var enumNumberType = reflect.TypeOf(pref.EnumNumber(0))
 
-// legacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
+// loadEnumDesc returns an EnumDescriptor derived from the Go type,
 // which must be an int32 kind and not implement the v2 API already.
-func legacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
+func loadEnumDesc(t reflect.Type) pref.EnumDescriptor {
 	// Fast-path: check if an EnumDescriptor is cached for this concrete type.
 	if v, ok := enumDescCache.Load(t); ok {
 		return v.(pref.EnumDescriptor)
@@ -101,9 +101,9 @@ func legacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
 	if _, ok := ev.(pref.ProtoEnum); ok {
 		panic(fmt.Sprintf("%v already implements proto.Enum", t))
 	}
-	if ed, ok := ev.(legacyEnum); ok {
+	if ed, ok := ev.(enumV1); ok {
 		b, idxs := ed.EnumDescriptor()
-		fd := legacyLoadFileDesc(b)
+		fd := loadFileDesc(b)
 
 		// Derive syntax.
 		switch fd.GetSyntax() {
@@ -138,7 +138,7 @@ func legacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
 			})
 		}
 	} else {
-		// If the type does not implement legacyEnum, then there is no reliable
+		// If the type does not implement enumV1, then there is no reliable
 		// way to derive the original protobuf type information.
 		// We are unable to use the global enum registry since it is
 		// unfortunately keyed by the full name, which we do not know.

internal/legacy/export.go

@@ -18,31 +18,31 @@ import (
 type Export struct{}
 
 func (Export) EnumOf(e interface{}) pvalue.LegacyEnum {
-	return legacyWrapEnum(reflect.ValueOf(e)).ProtoReflect().(pvalue.LegacyEnum)
+	return wrapEnum(reflect.ValueOf(e)).ProtoReflect().(pvalue.LegacyEnum)
 }
 
 func (Export) EnumTypeOf(e interface{}) pref.EnumType {
-	return legacyLoadEnumType(reflect.TypeOf(e))
+	return loadEnumType(reflect.TypeOf(e))
 }
 
 func (Export) MessageOf(m interface{}) pvalue.LegacyMessage {
-	return legacyWrapMessage(reflect.ValueOf(m)).ProtoReflect().(pvalue.LegacyMessage)
+	return wrapMessage(reflect.ValueOf(m)).ProtoReflect().(pvalue.LegacyMessage)
 }
 
 func (Export) MessageTypeOf(m interface{}) pref.MessageType {
-	return legacyLoadMessageType(reflect.TypeOf(m)).Type
+	return loadMessageType(reflect.TypeOf(m)).Type
 }
 
 func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
-	return legacyExtensionTypeOf(d, reflect.TypeOf(t))
+	return extensionTypeOf(d, reflect.TypeOf(t))
 }
 
 func (Export) ExtensionDescFromType(t pref.ExtensionType) *protoV1.ExtensionDesc {
-	return legacyExtensionDescFromType(t)
+	return extensionDescFromType(t)
 }
 
 func (Export) ExtensionTypeFromDesc(d *protoV1.ExtensionDesc) pref.ExtensionType {
-	return legacyExtensionTypeFromDesc(d)
+	return extensionTypeFromDesc(d)
 }
 
 func init() {

internal/legacy/extension.go

@@ -43,9 +43,9 @@ var (
 	extensionDescCache sync.Map // map[protoreflect.ExtensionType]*protoapi.ExtensionDesc
 )
 
-// legacyExtensionDescFromType converts a v2 protoreflect.ExtensionType to a
+// extensionDescFromType converts a v2 protoreflect.ExtensionType to a
 // v1 protoapi.ExtensionDesc. The returned ExtensionDesc must not be mutated.
-func legacyExtensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
+func extensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
 	// Fast-path: check the cache for whether this ExtensionType has already
 	// been converted to a legacy descriptor.
 	if d, ok := extensionDescCache.Load(t); ok {
@@ -100,9 +100,9 @@ func legacyExtensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
 		if fd := parentFileDescriptor(et); fd != nil {
 			protoPkg = string(fd.Package())
 		}
-		if ed, ok := ev.(legacyEnum); ok && protoPkg == "" {
+		if ed, ok := ev.(enumV1); ok && protoPkg == "" {
 			b, _ := ed.EnumDescriptor()
-			protoPkg = legacyLoadFileDesc(b).GetPackage()
+			protoPkg = loadFileDesc(b).GetPackage()
 		}
 
 		if protoPkg != "" {
@@ -130,14 +130,14 @@ func legacyExtensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
 	return d
 }
 
-// legacyExtensionTypeFromDesc converts a v1 protoapi.ExtensionDesc to a
+// extensionTypeFromDesc converts a v1 protoapi.ExtensionDesc to a
 // v2 protoreflect.ExtensionType. The returned descriptor type takes ownership
 // of the input extension desc. The input must not be mutated so long as the
 // returned type is still in use.
-func legacyExtensionTypeFromDesc(d *papi.ExtensionDesc) pref.ExtensionType {
+func extensionTypeFromDesc(d *papi.ExtensionDesc) pref.ExtensionType {
 	// Fast-path: check whether an extension type is already nested within.
 	if d.Type != nil {
-		// Cache descriptor for future legacyExtensionDescFromType operation.
+		// Cache descriptor for future extensionDescFromType operation.
 		// This assumes that there is only one legacy protoapi.ExtensionDesc
 		// that wraps any given specific protoreflect.ExtensionType.
 		extensionDescCache.LoadOrStore(d.Type, d)
@@ -184,18 +184,18 @@ func legacyExtensionTypeFromDesc(d *papi.ExtensionDesc) pref.ExtensionType {
 	return xt
 }
 
-// legacyExtensionTypeOf returns a protoreflect.ExtensionType where the GoType
+// extensionTypeOf 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 {
+func extensionTypeOf(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}
+	xt2 := &extensionType{ExtensionType: xt}
 	if xd.Cardinality() != pref.Repeated {
 		xt2.typ = t
 		xt2.new = func() interface{} {
@@ -236,7 +236,7 @@ func legacyExtensionTypeOf(xd pref.ExtensionDescriptor, t reflect.Type) pref.Ext
 	return xt2
 }
 
-type legacyExtensionType struct {
+type extensionType struct {
 	pref.ExtensionType
 	typ         reflect.Type
 	new         func() interface{}
@@ -244,9 +244,9 @@ type legacyExtensionType struct {
 	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) }
+func (x *extensionType) GoType() reflect.Type                 { return x.typ }
+func (x *extensionType) New() interface{}                     { return x.new() }
+func (x *extensionType) ValueOf(v interface{}) pref.Value     { return x.valueOf(v) }
+func (x *extensionType) InterfaceOf(v pref.Value) interface{} { return x.interfaceOf(v) }
 
 // TODO: Provide custom stringer with the new GoType.

internal/legacy/file.go

@@ -27,23 +27,23 @@ import (
 // compressed using GZIP. The []int is the path from the top-level file
 // to the specific message or enum declaration.
 type (
-	legacyEnum interface {
+	enumV1 interface {
 		EnumDescriptor() ([]byte, []int)
 	}
-	legacyMessage interface {
+	messageV1 interface {
 		Descriptor() ([]byte, []int)
 	}
 )
 
 var fileDescCache sync.Map // map[*byte]*descriptorV1.FileDescriptorProto
 
-// legacyLoadFileDesc unmarshals b as a compressed FileDescriptorProto message.
+// loadFileDesc unmarshals b as a compressed FileDescriptorProto message.
 //
 // This assumes that b is immutable and that b does not refer to part of a
 // concatenated series of GZIP files (which would require shenanigans that
 // rely on the concatenation properties of both protobufs and GZIP).
 // File descriptors generated by protoc-gen-go do not rely on that property.
-func legacyLoadFileDesc(b []byte) *descriptorV1.FileDescriptorProto {
+func loadFileDesc(b []byte) *descriptorV1.FileDescriptorProto {
 	// Fast-path: check whether we already have a cached file descriptor.
 	if v, ok := fileDescCache.Load(&b[0]); ok {
 		return v.(*descriptorV1.FileDescriptorProto)

internal/legacy/file_test.go

@@ -28,7 +28,7 @@ import (
 )
 
 func mustLoadFileDesc(b []byte, _ []int) pref.FileDescriptor {
-	fd, err := ptype.NewFileFromDescriptorProto(legacyLoadFileDesc(b), nil)
+	fd, err := ptype.NewFileFromDescriptorProto(loadFileDesc(b), nil)
 	if err != nil {
 		panic(err)
 	}
@@ -40,343 +40,343 @@ func TestDescriptor(t *testing.T) {
 
 	fileDescP2_20160225 := mustLoadFileDesc(new(proto2_20160225.Message).Descriptor())
 	tests = append(tests, []struct{ got, want pref.Descriptor }{{
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
 		want: fileDescP2_20160225.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
 		want: fileDescP2_20160225.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
 		want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
 		want: fileDescP2_20160225.Messages().ByName("Message"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
 		want: fileDescP3_20160225.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
 		want: fileDescP3_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
 		want: fileDescP3_20160225.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
 		want: fileDescP3_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
 		want: fileDescP2_20160519.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
 		want: fileDescP2_20160519.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
 		want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
 		want: fileDescP2_20160519.Messages().ByName("Message"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
 		want: fileDescP3_20160519.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
 		want: fileDescP3_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
 		want: fileDescP3_20160519.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
 		want: fileDescP3_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
 		want: fileDescP2_20180125.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
 		want: fileDescP2_20180125.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
 		want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
 		want: fileDescP2_20180125.Messages().ByName("Message"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
 		want: fileDescP3_20180125.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
 		want: fileDescP3_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
 		want: fileDescP3_20180125.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
 		want: fileDescP3_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
 		want: fileDescP2_20180430.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
 		want: fileDescP2_20180430.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
 		want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
 		want: fileDescP2_20180430.Messages().ByName("Message"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
 		want: fileDescP3_20180430.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
 		want: fileDescP3_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
 		want: fileDescP3_20180430.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
 		want: fileDescP3_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
 		want: fileDescP2_20180814.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
 		want: fileDescP2_20180814.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
 		want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
 		want: fileDescP2_20180814.Messages().ByName("Message"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
 		want: fileDescP3_20180814.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
 		want: fileDescP3_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
 		want: fileDescP3_20180814.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
 		want: fileDescP3_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20181126.SiblingEnum(0))),
 		want: fileDescP2_20181126.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto2_20181126.Message_ChildEnum(0))),
 		want: fileDescP2_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20181126.SiblingMessage))),
 		want: fileDescP2_20181126.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ChildMessage))),
 		want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message))),
 		want: fileDescP2_20181126.Messages().ByName("Message"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_NamedGroup))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadMessageDesc(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))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20181126.SiblingEnum(0))),
 		want: fileDescP3_20181126.Enums().ByName("SiblingEnum"),
 	}, {
-		got:  legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.Message_ChildEnum(0))),
+		got:  loadEnumDesc(reflect.TypeOf(proto3_20181126.Message_ChildEnum(0))),
 		want: fileDescP3_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.SiblingMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20181126.SiblingMessage))),
 		want: fileDescP3_20181126.Messages().ByName("SiblingMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message_ChildMessage))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message_ChildMessage))),
 		want: fileDescP3_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
 	}, {
-		got:  legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message))),
+		got:  loadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message))),
 		want: fileDescP3_20181126.Messages().ByName("Message"),
 	}}...)
 

internal/legacy/message.go

@@ -19,25 +19,25 @@ import (
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )
 
-// legacyWrapMessage wraps v as a protoreflect.ProtoMessage,
+// wrapMessage wraps v as a protoreflect.ProtoMessage,
 // where v must be a *struct kind and not implement the v2 API already.
-func legacyWrapMessage(v reflect.Value) pref.ProtoMessage {
-	mt := legacyLoadMessageType(v.Type())
+func wrapMessage(v reflect.Value) pref.ProtoMessage {
+	mt := loadMessageType(v.Type())
 	return mt.MessageOf(v.Interface()).Interface()
 }
 
 var messageTypeCache sync.Map // map[reflect.Type]*MessageType
 
-// legacyLoadMessageType dynamically loads a *MessageType for t,
+// loadMessageType 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) *pimpl.MessageType {
+func loadMessageType(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.(*pimpl.MessageType)
 	}
 
 	// Slow-path: derive message descriptor and initialize MessageType.
-	md := legacyLoadMessageDesc(t)
+	md := loadMessageDesc(t)
 	mt := new(pimpl.MessageType)
 	mt.Type = ptype.GoMessage(md, func(pref.MessageType) pref.ProtoMessage {
 		p := reflect.New(t.Elem()).Interface()
@@ -49,9 +49,9 @@ func legacyLoadMessageType(t reflect.Type) *pimpl.MessageType {
 
 var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
 
-// legacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
+// loadMessageDesc returns an MessageDescriptor derived from the Go type,
 // which must be a *struct kind and not implement the v2 API already.
-func legacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
+func loadMessageDesc(t reflect.Type) pref.MessageDescriptor {
 	return messageDescSet{}.Load(t)
 }
 
@@ -108,9 +108,9 @@ func (ms *messageDescSet) processMessage(t reflect.Type) pref.MessageDescriptor
 	if _, ok := mv.(pref.ProtoMessage); ok {
 		panic(fmt.Sprintf("%v already implements proto.Message", t))
 	}
-	if md, ok := mv.(legacyMessage); ok {
+	if md, ok := mv.(messageV1); ok {
 		b, idxs := md.Descriptor()
-		fd := legacyLoadFileDesc(b)
+		fd := loadFileDesc(b)
 
 		// Derive syntax.
 		switch fd.GetSyntax() {
@@ -128,7 +128,7 @@ func (ms *messageDescSet) processMessage(t reflect.Type) pref.MessageDescriptor
 			m.FullName = m.FullName.Append(pref.Name(md.GetName()))
 		}
 	} else {
-		// If the type does not implement legacyMessage, then the only way to
+		// If the type does not implement messageV1, then the only way to
 		// obtain the full name is through the registry. However, this is
 		// unreliable as some generated messages register with a fork of
 		// golang/protobuf, so the registry may not have this information.
@@ -221,7 +221,7 @@ func (ms *messageDescSet) parseField(tag, tagKey, tagVal string, goType reflect.
 		if ev, ok := reflect.Zero(t).Interface().(pref.ProtoEnum); ok {
 			f.EnumType = ev.ProtoReflect().Type()
 		} else {
-			f.EnumType = legacyLoadEnumDesc(t)
+			f.EnumType = loadEnumDesc(t)
 		}
 	}
 	if f.MessageType == nil && (f.Kind == pref.MessageKind || f.Kind == pref.GroupKind) {