internal/proto: implement v1 registration with v2 registration

This CL implements v1 registration in terms of v2 registration,
unifying the two global states.

Change-Id: I1c28e5f3392dcfa7cd7b2933f2c0974456a182a9
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/168350
Reviewed-by: Herbie Ong <herbie@google.com>

go.mod

@@ -1,3 +1,3 @@
 module github.com/golang/protobuf
 
-require github.com/golang/protobuf/v2 v2.0.0-20190312230405-4989810018b7
+require github.com/golang/protobuf/v2 v2.0.0-20190320041633-559d47f1da45

go.sum

@@ -1,5 +1,5 @@
 github.com/golang/protobuf v1.2.1-0.20190311233832-968e039ade03/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf/v2 v2.0.0-20190312230405-4989810018b7 h1:aQENkYDAn/68ZfghmurTBhR18Q7/XWx1JpMaqFtP1GM=
-github.com/golang/protobuf/v2 v2.0.0-20190312230405-4989810018b7/go.mod h1:euNorOscCho6jibQUfcx8TAp5HZXU5/+1xMsdtkc8lo=
-github.com/google/go-cmp v0.2.1-0.20190228024137-c81281657ad9 h1:GDk30QdVXDf6i734280OeWAO9UCCjXLeWkLLyHQGUkI=
-github.com/google/go-cmp v0.2.1-0.20190228024137-c81281657ad9/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/golang/protobuf/v2 v2.0.0-20190320041633-559d47f1da45 h1:UpSQcE2BQjlwjgUj1o+22OMRLUpeeTZNH1fuZN5lEv4=
+github.com/golang/protobuf/v2 v2.0.0-20190320041633-559d47f1da45/go.mod h1:memx26heJzlbv0kkl0yZyY1iCWPnh53PDfstsy8HCEg=
+github.com/google/go-cmp v0.2.1-0.20190312032427-6f77996f0c42 h1:q3pnF5JFBNRz8sRD+IRj7Y6DMyYGTNqnZ9axTbSfoNI=
+github.com/google/go-cmp v0.2.1-0.20190312032427-6f77996f0c42/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=

internal/proto/common.go

@@ -14,4 +14,7 @@ import (
 	_ "github.com/golang/protobuf/v2/runtime/protolegacy"
 )
 
-type Message = protoapi.Message
+type (
+	Message       = protoapi.Message
+	ExtensionDesc = protoapi.ExtensionDesc
+)

internal/proto/properties.go

@@ -301,7 +301,7 @@ func newProperties(t reflect.Type) *StructProperties {
 	if !foundField {
 		// Check with protobuf reflection to make sure this isn't
 		// an empty protobuf message.
-		mt := protoimpl.X.MessageOf(reflect.New(t).Interface()).Type()
+		mt := protoimpl.X.MessageTypeOf(reflect.New(t).Interface())
 		if mt.Fields().Len() > 0 {
 			panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
 		}

internal/proto/registry.go

@@ -0,0 +1,373 @@
+// Copyright 2019 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 proto
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync"
+
+	protoV2 "github.com/golang/protobuf/v2/proto"
+	"github.com/golang/protobuf/v2/reflect/protodesc"
+	"github.com/golang/protobuf/v2/reflect/protoreflect"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+	"github.com/golang/protobuf/v2/reflect/protoregistry"
+	"github.com/golang/protobuf/v2/runtime/protoimpl"
+	"github.com/golang/protobuf/v2/runtime/protolegacy"
+
+	descriptorpb "github.com/golang/protobuf/v2/types/descriptor"
+)
+
+// filePath is the path to the proto source file.
+type filePath = string // e.g., "google/protobuf/descriptor.proto"
+
+// fileDescGZIP is the compressed contents of the encoded FileDescriptorProto.
+type fileDescGZIP = []byte
+
+var fileCache sync.Map // map[filePath]fileDescGZIP
+
+// RegisterFile is called from generated code and registers the compressed
+// FileDescriptorProto with the file path for a proto source file.
+//
+// Deprecated: Use protoregistry.GlobalFiles.Register instead.
+func RegisterFile(s filePath, d fileDescGZIP) {
+	// Decompress the descriptor.
+	zr, err := gzip.NewReader(bytes.NewReader(d))
+	if err != nil {
+		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
+	}
+	b, err := ioutil.ReadAll(zr)
+	if err != nil {
+		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
+	}
+
+	// Parse the raw descriptor proto.
+	var pb descriptorpb.FileDescriptorProto
+	if err := protoV2.Unmarshal(b, &pb); err != nil {
+		panic(fmt.Sprintf("proto: unmarshal failure: %v", err))
+	}
+
+	// Convert the raw descriptor to a structured file descriptor.
+	fd, err := protodesc.NewFile(&pb, nil)
+	if err != nil {
+		// TODO: Ignore errors due to placeholders.
+		panic(fmt.Sprintf("proto: descriptor parsing failure: %v", err))
+	}
+
+	// Register the descriptor in the v2 registry and cache the result locally.
+	if err := protoregistry.GlobalFiles.Register(fd); err != nil {
+		printWarning(err)
+		return
+	}
+	fileCache.Store(s, b)
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto given the file path
+// for a proto source file. It returns nil if not found.
+//
+// Deprecated: Use protoregistry.GlobalFiles.RangeFilesByPath instead.
+func FileDescriptor(s filePath) (d fileDescGZIP) {
+	if d, ok := fileCache.Load(s); ok {
+		return d.(fileDescGZIP)
+	}
+
+	// Find the descriptor in the v2 registry.
+	var n int
+	protoregistry.GlobalFiles.RangeFilesByPath(s, func(fd protoreflect.FileDescriptor) bool {
+		n++
+
+		// Convert the structured file descriptor to the raw descriptor proto.
+		pb := protodesc.ToFileDescriptorProto(fd)
+		b, err := protoV2.Marshal(pb)
+		if err != nil {
+			panic(fmt.Sprintf("proto: marshal failure: %v", err))
+		}
+		bb := new(bytes.Buffer)
+		zw := gzip.NewWriter(bb)
+		if _, err := zw.Write(b); err != nil {
+			panic(fmt.Sprintf("proto: compression failure: %v", err))
+		}
+		if err := zw.Close(); err != nil {
+			panic(fmt.Sprintf("proto: compression failure: %v", err))
+		}
+		d = bb.Bytes()
+		return true
+	})
+	if n > 1 {
+		return d // best-effort; may be non-deterministic
+	}
+
+	// Locally cache the raw descriptor form for the file.
+	if len(d) > 0 {
+		fileCache.Store(s, d)
+	}
+	return d
+}
+
+// enumName is the name of an enum. For historical reasons, the enum name is
+// neither the full Go name nor the full protobuf name of the enum.
+// The name is the dot-separated combination of just the proto package that the
+// enum is declared within followed by the Go type name of the generated enum.
+type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum"
+
+// enumsByName maps enum values by name to their numeric counterpart.
+type enumsByName = map[string]int32
+
+// enumsByNumber maps enum values by number to their name counterpart.
+type enumsByNumber = map[int32]string
+
+var enumCache sync.Map // map[enumName]enumsByName
+
+// RegisterEnum is called from the generated code and registers the mapping of
+// enum value names to enum numbers for the enum identified by s.
+//
+// Deprecated: Use protoregistry.GlobalTypes.Register instead.
+func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) {
+	if _, ok := enumCache.Load(s); ok {
+		panic("proto: duplicate enum registered: " + s)
+	}
+	enumCache.Store(s, m)
+
+	// This does not forward registration to the v2 registry since this API
+	// lacks sufficient information to construct a complete v2 enum descriptor.
+}
+
+// EnumValueMap returns the mapping from enum value names to enum numbers for
+// the enum of the given name. It returns nil if not found.
+//
+// Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead.
+func EnumValueMap(s enumName) (m enumsByName) {
+	v, ok := enumCache.Load(s)
+	if ok {
+		return v.(enumsByName)
+	}
+
+	// Construct the mapping from a v2 enum descriptor.
+	var protoPkg protoreflect.FullName
+	if i := strings.LastIndexByte(s, '.'); i >= 0 {
+		protoPkg = protoreflect.FullName(s[:i])
+	}
+	protoregistry.GlobalFiles.RangeFilesByPackage(protoreflect.FullName(protoPkg), func(fd protoreflect.FileDescriptor) bool {
+		return walkEnums(fd, func(ed protoreflect.EnumDescriptor) bool {
+			if s == hybridEnumName(ed) {
+				m = make(enumsByName)
+				evs := ed.Values()
+				for i := evs.Len() - 1; i >= 0; i-- {
+					ev := evs.Get(i)
+					m[string(ev.Name())] = int32(ev.Number())
+				}
+				return false
+			}
+			return true
+		})
+	})
+
+	if m != nil {
+		enumCache.Store(s, m)
+	}
+	return m
+}
+
+// walkEnums recursively walks all enums declared in d.
+func walkEnums(d interface {
+	Enums() protoreflect.EnumDescriptors
+	Messages() protoreflect.MessageDescriptors
+}, f func(protoreflect.EnumDescriptor) bool) bool {
+	cont := true
+	eds := d.Enums()
+	for i := eds.Len() - 1; cont && i >= 0; i-- {
+		cont = cont && f(eds.Get(i))
+	}
+	mds := d.Messages()
+	for i := mds.Len() - 1; cont && i >= 0; i-- {
+		cont = cont && walkEnums(mds.Get(i), f)
+	}
+	return cont
+}
+
+// hybridEnumName returns the legacy enum identifier.
+func hybridEnumName(ed pref.EnumDescriptor) enumName {
+	var protoPkg string
+	for parent, _ := ed.Parent(); parent != nil; parent, _ = parent.Parent() {
+		if fd, ok := parent.(pref.FileDescriptor); ok {
+			protoPkg = string(fd.Package())
+			break
+		}
+	}
+	if protoPkg == "" {
+		return camelCase(string(ed.FullName()))
+	}
+	return protoPkg + "." + camelCase(strings.TrimPrefix(string(ed.FullName()), protoPkg+"."))
+}
+
+// camelCase is a copy of the v2 protogen.camelCase function.
+func camelCase(s string) string {
+	isASCIILower := func(c byte) bool {
+		return 'a' <= c && c <= 'z'
+	}
+	isASCIIDigit := func(c byte) bool {
+		return '0' <= c && c <= '9'
+	}
+
+	var b []byte
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		switch {
+		case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
+			continue
+		case c == '.':
+			b = append(b, '_')
+		case c == '_' && (i == 0 || s[i-1] == '.'):
+			b = append(b, 'X')
+		case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
+			continue
+		case isASCIIDigit(c):
+			b = append(b, c)
+		default:
+			if isASCIILower(c) {
+				c -= 'a' - 'A'
+			}
+			b = append(b, c)
+			for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
+				b = append(b, s[i+1])
+			}
+		}
+	}
+	return string(b)
+}
+
+// messageName is the full name of protobuf message.
+type messageName = string
+
+var messageTypeCache sync.Map // map[messageName]reflect.Type
+
+// RegisterType is called from generated code and register the message Go type
+// for a message of the given name.
+//
+// Deprecated: Use protoregistry.GlobalTypes.Register instead.
+func RegisterType(m Message, s messageName) {
+	mt := protoimpl.X.MessageTypeOf(m)
+	if s != messageName(mt.FullName()) {
+		panic(fmt.Sprintf("proto: inconsistent message name: got %v, want %v", s, mt.FullName()))
+	}
+	if err := protoregistry.GlobalTypes.Register(mt); err != nil {
+		printWarning(err)
+		return
+	}
+	messageTypeCache.Store(s, reflect.TypeOf(m))
+}
+
+// RegisterMapType is called from generated code and registers the Go map type
+// for a protobuf message representing a map entry.
+//
+// Deprecated: Do not use.
+func RegisterMapType(m interface{}, s messageName) {
+	t := reflect.TypeOf(m)
+	if t.Kind() != reflect.Map {
+		panic(fmt.Sprintf("invalid map kind: %v", t))
+	}
+	if _, ok := messageTypeCache.Load(s); ok {
+		printWarning(fmt.Errorf("proto: duplicate proto message registered: %s", s))
+		return
+	}
+	messageTypeCache.Store(s, t)
+}
+
+// MessageType returns the message type for a named message.
+// It returns nil if not found.
+//
+// Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead.
+func MessageType(s messageName) reflect.Type {
+	if t, ok := messageTypeCache.Load(s); ok {
+		return t.(reflect.Type)
+	}
+
+	// Derive the message type from the v2 registry.
+	var t reflect.Type
+	mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s))
+	if mt != nil {
+		t = mt.GoType()
+	}
+	// TODO: Support retrieving Go map types for map entry messages?
+
+	if t != nil {
+		messageTypeCache.Store(s, t)
+	}
+	return t
+}
+
+// MessageName returns the full protobuf name for the given message type.
+//
+// Deprecated: Use protoreflect.MessageDescriptor.FullName instead.
+func MessageName(m Message) messageName {
+	if m, ok := m.(interface {
+		XXX_MessageName() messageName
+	}); ok {
+		return m.XXX_MessageName()
+	}
+	return messageName(protoimpl.X.MessageTypeOf(m).FullName())
+}
+
+// RegisterExtension is called from the generated code and registers
+// the extension descriptor.
+//
+// Deprecated: Use protoregistry.GlobalTypes.Register instead.
+func RegisterExtension(d *ExtensionDesc) {
+	xt := protolegacy.X.ExtensionTypeFromDesc(d)
+	if err := protoregistry.GlobalTypes.Register(xt); err != nil {
+		panic(err)
+	}
+}
+
+type extensionsByNumber = map[int32]*ExtensionDesc
+
+var extensionCache sync.Map // map[messageName]extensionsByNumber
+
+// RegisteredExtensions returns a map of the registered extensions for the
+// provided protobuf message, indexed by the extension field number.
+//
+// Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead.
+func RegisteredExtensions(m Message) extensionsByNumber {
+	s := MessageName(m)
+	if xs, ok := extensionCache.Load(s); ok {
+		return xs.(extensionsByNumber)
+	}
+
+	var xs extensionsByNumber
+	protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool {
+		if xs == nil {
+			xs = make(extensionsByNumber)
+		}
+		xs[int32(xt.Number())] = protolegacy.X.ExtensionDescFromType(xt)
+		return true
+	})
+
+	if xs == nil {
+		return nil
+	}
+	if xs, ok := extensionCache.LoadOrStore(s, xs); ok {
+		return xs.(extensionsByNumber)
+	}
+	return xs
+}
+
+// printWarning prints a warning to os.Stderr regarding a registration conflict.
+func printWarning(err error) {
+	// TODO: Provide a link in the warning to a page that explains
+	// what the user should do instead?
+	b := make([]byte, 0, 1<<12)
+	b = append(b, "==================\n"...)
+	b = append(b, "WARNING: "+err.Error()+"\n"...)
+	b = append(b, "A future release of proto will panic on registration conflicts.\n\n"...)
+	b = b[:len(b)+runtime.Stack(b[len(b):cap(b)], false)]
+	b = append(b, "==================\n"...)
+	os.Stderr.Write(b)
+}

jsonpb/jsonpb_test.go

@@ -1024,7 +1024,7 @@ func TestUnmarshalAnyJSONPBUnmarshaler(t *testing.T) {
 }
 
 const (
-	dynamicMessageName = "google.protobuf.jsonpb.testing.dynamicMessage"
+	dynamicMessageName = "github_com.golang.protobuf.jsonpb.dynamicMessage"
 )
 
 func init() {

proto/discard.go

@@ -18,8 +18,6 @@ type generatedDiscarder interface {
 	XXX_DiscardUnknown()
 }
 
-var discardUnknownAlt func(Message) // populated by hooks.go
-
 // DiscardUnknown recursively discards all unknown fields from this message
 // and all embedded messages.
 //
@@ -33,7 +31,7 @@ var discardUnknownAlt func(Message) // populated by hooks.go
 // discarded from messages that have been accessed via GetExtension.
 func DiscardUnknown(m Message) {
 	if discardUnknownAlt != nil {
-		discardUnknownAlt(m)
+		discardUnknownAlt(m) // populated by hooks_enabled.go
 		return
 	}
 

proto/equal.go

@@ -245,7 +245,7 @@ func equalExtensions(base reflect.Type, em1, em2 protoapi.ExtensionFields) bool
 		// we need to unmarshal them first.
 		var desc *ExtensionDesc
 		mz := reflect.Zero(reflect.PtrTo(base)).Interface().(Message)
-		if m := protoapi.RegisteredExtensions(mz); m != nil {
+		if m := RegisteredExtensions(mz); m != nil {
 			desc = m[int32(extNum)]
 		}
 		if desc == nil {

proto/hooks.go

@@ -1,14 +0,0 @@
-// Copyright 2019 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.
-
-// +build proto_reimpl
-
-package proto
-
-import "github.com/golang/protobuf/internal/proto"
-
-func init() {
-	setDefaultsAlt = proto.SetDefaults
-	discardUnknownAlt = proto.DiscardUnknown
-}

proto/hooks_disabled.go

@@ -0,0 +1,76 @@
+// Copyright 2019 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.
+
+// +build !proto_reimpl
+
+package proto
+
+import (
+	"reflect"
+
+	descriptorpb "github.com/golang/protobuf/v2/types/descriptor"
+)
+
+var (
+	// Hooks for lib.go.
+	setDefaultsAlt func(Message)
+
+	// Hooks for discard.go.
+	discardUnknownAlt func(Message)
+
+	// Hooks for registry.go.
+	registerEnumAlt         func(string, map[int32]string, map[string]int32)
+	enumValueMapAlt         func(string) map[string]int32
+	registerTypeAlt         func(Message, string)
+	registerMapTypeAlt      func(interface{}, string)
+	messageNameAlt          func(Message) string
+	messageTypeAlt          func(string) reflect.Type
+	registerFileAlt         func(string, []byte)
+	fileDescriptorAlt       func(string) []byte
+	registerExtensionAlt    func(*ExtensionDesc)
+	registeredExtensionsAlt func(Message) map[int32]*ExtensionDesc
+)
+
+// The v2 descriptor no longer registers with v1.
+// If we're only relying on the v1 registry, we need to manually register the
+// types in descriptor.
+func init() {
+	// TODO: This should be eventually deleted once the v1 repository is fully
+	// switched over to wrap the v2 repository.
+	rawDesc, _ := (*descriptorpb.DescriptorProto)(nil).Descriptor()
+	RegisterFile("google/protobuf/descriptor.proto", rawDesc)
+	RegisterEnum("google.protobuf.FieldDescriptorProto_Type", descriptorpb.FieldDescriptorProto_Type_name, descriptorpb.FieldDescriptorProto_Type_value)
+	RegisterEnum("google.protobuf.FieldDescriptorProto_Label", descriptorpb.FieldDescriptorProto_Label_name, descriptorpb.FieldDescriptorProto_Label_value)
+	RegisterEnum("google.protobuf.FileOptions_OptimizeMode", descriptorpb.FileOptions_OptimizeMode_name, descriptorpb.FileOptions_OptimizeMode_value)
+	RegisterEnum("google.protobuf.FieldOptions_CType", descriptorpb.FieldOptions_CType_name, descriptorpb.FieldOptions_CType_value)
+	RegisterEnum("google.protobuf.FieldOptions_JSType", descriptorpb.FieldOptions_JSType_name, descriptorpb.FieldOptions_JSType_value)
+	RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", descriptorpb.MethodOptions_IdempotencyLevel_name, descriptorpb.MethodOptions_IdempotencyLevel_value)
+	RegisterType((*descriptorpb.FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet")
+	RegisterType((*descriptorpb.FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto")
+	RegisterType((*descriptorpb.DescriptorProto)(nil), "google.protobuf.DescriptorProto")
+	RegisterType((*descriptorpb.ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
+	RegisterType((*descriptorpb.FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
+	RegisterType((*descriptorpb.OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
+	RegisterType((*descriptorpb.EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
+	RegisterType((*descriptorpb.EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto")
+	RegisterType((*descriptorpb.ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto")
+	RegisterType((*descriptorpb.MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto")
+	RegisterType((*descriptorpb.FileOptions)(nil), "google.protobuf.FileOptions")
+	RegisterType((*descriptorpb.MessageOptions)(nil), "google.protobuf.MessageOptions")
+	RegisterType((*descriptorpb.FieldOptions)(nil), "google.protobuf.FieldOptions")
+	RegisterType((*descriptorpb.OneofOptions)(nil), "google.protobuf.OneofOptions")
+	RegisterType((*descriptorpb.EnumOptions)(nil), "google.protobuf.EnumOptions")
+	RegisterType((*descriptorpb.EnumValueOptions)(nil), "google.protobuf.EnumValueOptions")
+	RegisterType((*descriptorpb.ServiceOptions)(nil), "google.protobuf.ServiceOptions")
+	RegisterType((*descriptorpb.MethodOptions)(nil), "google.protobuf.MethodOptions")
+	RegisterType((*descriptorpb.UninterpretedOption)(nil), "google.protobuf.UninterpretedOption")
+	RegisterType((*descriptorpb.SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo")
+	RegisterType((*descriptorpb.GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo")
+	RegisterType((*descriptorpb.DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
+	RegisterType((*descriptorpb.DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
+	RegisterType((*descriptorpb.EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange")
+	RegisterType((*descriptorpb.UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart")
+	RegisterType((*descriptorpb.SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location")
+	RegisterType((*descriptorpb.GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation")
+}

proto/hooks_enabled.go

@@ -0,0 +1,31 @@
+// Copyright 2019 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.
+
+// +build proto_reimpl
+
+package proto
+
+import (
+	"github.com/golang/protobuf/internal/proto"
+)
+
+var (
+	// Hooks for lib.go.
+	setDefaultsAlt = proto.SetDefaults
+
+	// Hooks for discard.go.
+	discardUnknownAlt = proto.DiscardUnknown
+
+	// Hooks for registry.go.
+	registerEnumAlt         = proto.RegisterEnum
+	enumValueMapAlt         = proto.EnumValueMap
+	registerTypeAlt         = proto.RegisterType
+	registerMapTypeAlt      = proto.RegisterMapType
+	messageNameAlt          = proto.MessageName
+	messageTypeAlt          = proto.MessageType
+	registerFileAlt         = proto.RegisterFile
+	fileDescriptorAlt       = proto.FileDescriptor
+	registerExtensionAlt    = proto.RegisterExtension
+	registeredExtensionsAlt = proto.RegisteredExtensions
+)

proto/lib.go

@@ -261,14 +261,12 @@ out:
 	p.index = index
 }
 
-var setDefaultsAlt func(Message) // populated by hooks.go
-
 // SetDefaults sets unset protocol buffer fields to their default values.
 // It only modifies fields that are both unset and have defined defaults.
 // It recursively sets default values in any non-nil sub-messages.
 func SetDefaults(pb Message) {
 	if setDefaultsAlt != nil {
-		setDefaultsAlt(pb)
+		setDefaultsAlt(pb) // populated by hooks_enabled.go
 		return
 	}
 	setDefaults(reflect.ValueOf(pb), true, false)

proto/registry.go

@@ -1,72 +1,166 @@
-// Copyright 2016 The Go Authors. All rights reserved.
+// 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 proto
 
 import (
+	"fmt"
+	"log"
 	"reflect"
-
-	"github.com/golang/protobuf/protoapi"
+	"strconv"
 )
 
-// TODO: Registration should be written in terms of v2 registries.
+var enumValueMaps = make(map[string]map[string]int32)
 
 // RegisterEnum is called from the generated code to install the enum descriptor
 // maps into the global table to aid parsing text format protocol buffers.
 func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
-	protoapi.RegisterEnum(typeName, unusedNameMap, valueMap)
+	if registerEnumAlt != nil {
+		registerEnumAlt(typeName, unusedNameMap, valueMap) // populated by hooks_enabled.go
+		return
+	}
+	if _, ok := enumValueMaps[typeName]; ok {
+		panic("proto: duplicate enum registered: " + typeName)
+	}
+	enumValueMaps[typeName] = valueMap
 }
 
 // EnumValueMap returns the mapping from names to integers of the
 // enum type enumType, or a nil if not found.
 func EnumValueMap(enumType string) map[string]int32 {
-	return protoapi.EnumValueMap(enumType)
+	if enumValueMapAlt != nil {
+		return enumValueMapAlt(enumType) // populated by hooks_enabled.go
+	}
+	return enumValueMaps[enumType]
 }
 
+// A registry of all linked message types.
+// The string is a fully-qualified proto name ("pkg.Message").
+var (
+	protoTypedNils = make(map[string]Message)      // a map from proto names to typed nil pointers
+	protoMapTypes  = make(map[string]reflect.Type) // a map from proto names to map types
+	revProtoTypes  = make(map[reflect.Type]string)
+)
+
 // RegisterType is called from generated code and maps from the fully qualified
 // proto name to the type (pointer to struct) of the protocol buffer.
 func RegisterType(x Message, name string) {
-	protoapi.RegisterType(x, name)
+	if registerTypeAlt != nil {
+		registerTypeAlt(x, name) // populated by hooks_enabled.go
+		return
+	}
+	if _, ok := protoTypedNils[name]; ok {
+		// TODO: Some day, make this a panic.
+		log.Printf("proto: duplicate proto type registered: %s", name)
+		return
+	}
+	t := reflect.TypeOf(x)
+	if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
+		// Generated code always calls RegisterType with nil x.
+		// This check is just for extra safety.
+		protoTypedNils[name] = x
+	} else {
+		protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
+	}
+	revProtoTypes[t] = name
 }
 
 // RegisterMapType is called from generated code and maps from the fully qualified
 // proto name to the native map type of the proto map definition.
 func RegisterMapType(x interface{}, name string) {
-	protoapi.RegisterMapType(x, name)
+	if registerMapTypeAlt != nil {
+		registerMapTypeAlt(x, name) // populated by hooks_enabled.go
+		return
+	}
+	if reflect.TypeOf(x).Kind() != reflect.Map {
+		panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
+	}
+	if _, ok := protoMapTypes[name]; ok {
+		log.Printf("proto: duplicate proto type registered: %s", name)
+		return
+	}
+	t := reflect.TypeOf(x)
+	protoMapTypes[name] = t
+
+	// Avoid registering into revProtoTypes since map types are not unique.
+	// revProtoTypes[t] = name
 }
 
 // MessageName returns the fully-qualified proto name for the given message type.
 func MessageName(x Message) string {
-	return protoapi.MessageName(x)
+	if messageNameAlt != nil {
+		return messageNameAlt(x) // populated by hooks_enabled.go
+	}
+	type xname interface {
+		XXX_MessageName() string
+	}
+	if m, ok := x.(xname); ok {
+		return m.XXX_MessageName()
+	}
+	return revProtoTypes[reflect.TypeOf(x)]
 }
 
 // MessageType returns the message type (pointer to struct) for a named message.
 // The type is not guaranteed to implement proto.Message if the name refers to a
 // map entry.
 func MessageType(name string) reflect.Type {
-	return protoapi.MessageType(name)
+	if messageTypeAlt != nil {
+		return messageTypeAlt(name) // populated by hooks_enabled.go
+	}
+	if t, ok := protoTypedNils[name]; ok {
+		return reflect.TypeOf(t)
+	}
+	return protoMapTypes[name]
 }
 
+// A registry of all linked proto files.
+var protoFiles = make(map[string][]byte) // file name => fileDescriptor
+
 // RegisterFile is called from generated code and maps from the
 // full file name of a .proto file to its compressed FileDescriptorProto.
 func RegisterFile(filename string, fileDescriptor []byte) {
-	protoapi.RegisterFile(filename, fileDescriptor)
+	if registerFileAlt != nil {
+		registerFileAlt(filename, fileDescriptor) // populated by hooks_enabled.go
+		return
+	}
+	protoFiles[filename] = fileDescriptor
 }
 
 // FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
 func FileDescriptor(filename string) []byte {
-	return protoapi.FileDescriptor(filename)
+	if fileDescriptorAlt != nil {
+		return fileDescriptorAlt(filename) // populated by hooks_enabled.go
+	}
+	return protoFiles[filename]
 }
 
+var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
+
 // RegisterExtension is called from the generated code.
 func RegisterExtension(desc *ExtensionDesc) {
-	protoapi.RegisterExtension(desc)
+	if registerExtensionAlt != nil {
+		registerExtensionAlt(desc) // populated by hooks_enabled.go
+		return
+	}
+	st := reflect.TypeOf(desc.ExtendedType).Elem()
+	m := extensionMaps[st]
+	if m == nil {
+		m = make(map[int32]*ExtensionDesc)
+		extensionMaps[st] = m
+	}
+	if _, ok := m[desc.Field]; ok {
+		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+	}
+	m[desc.Field] = desc
 }
 
 // RegisteredExtensions returns a map of the registered extensions of a
 // protocol buffer struct, indexed by the extension number.
 // The argument pb should be a nil pointer to the struct type.
 func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
-	return protoapi.RegisteredExtensions(pb)
+	if registeredExtensionsAlt != nil {
+		return registeredExtensionsAlt(pb) // populated by hooks_enabled.go
+	}
+	return extensionMaps[reflect.TypeOf(pb).Elem()]
 }

proto/registry_test.go

@@ -0,0 +1,28 @@
+// Copyright 2019 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 proto_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+
+	descriptorpb "github.com/golang/protobuf/v2/types/descriptor"
+)
+
+func TestRegistry(t *testing.T) {
+	if got := proto.FileDescriptor("google/protobuf/descriptor.proto"); len(got) == 0 {
+		t.Errorf(`FileDescriptor("google/protobuf/descriptor.proto") = empty, want non-empty`)
+	}
+	if got := proto.EnumValueMap("google.protobuf.FieldDescriptorProto_Label"); len(got) == 0 {
+		t.Errorf(`EnumValueMap("google.protobuf.FieldDescriptorProto_Label") = empty, want non-empty`)
+	}
+	wantType := reflect.TypeOf(new(descriptorpb.EnumDescriptorProto_EnumReservedRange))
+	gotType := proto.MessageType("google.protobuf.EnumDescriptorProto.EnumReservedRange")
+	if gotType != wantType {
+		t.Errorf(`MessageType("google.protobuf.EnumDescriptorProto.EnumReservedRange") = %v, want %v`, gotType, wantType)
+	}
+}

proto/table_marshal.go

@@ -259,7 +259,7 @@ func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte
 			if err == errInvalidUTF8 {
 				if errLater == nil {
 					mz := reflect.Zero(reflect.PtrTo(u.typ)).Interface().(Message)
-					fullName := protoapi.MessageName(mz) + "." + f.name
+					fullName := MessageName(mz) + "." + f.name
 					errLater = &invalidUTF8Error{fullName}
 				}
 				continue

proto/table_unmarshal.go

@@ -164,7 +164,7 @@ func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
 				if err == errInvalidUTF8 {
 					if errLater == nil {
 						mz := reflect.Zero(reflect.PtrTo(u.typ)).Interface().(Message)
-						fullName := protoapi.MessageName(mz) + "." + f.name
+						fullName := MessageName(mz) + "." + f.name
 						errLater = &invalidUTF8Error{fullName}
 					}
 					continue

proto/text.go

@@ -653,7 +653,7 @@ func (s fieldNumSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 // writeExtensions writes all the extensions in pv.
 // pv is assumed to be a pointer to a protocol message struct that is extendable.
 func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
-	emap := protoapi.RegisteredExtensions(pv.Interface().(Message))
+	emap := RegisteredExtensions(pv.Interface().(Message))
 	ep, _ := extendable(pv.Interface())
 
 	// Order the extensions by ID.

proto/text_parser.go

@@ -16,8 +16,6 @@ import (
 	"strings"
 	"sync"
 	"unicode/utf8"
-
-	"github.com/golang/protobuf/protoapi"
 )
 
 // Error string emitted when deserializing Any and fields are already set
@@ -823,7 +821,7 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) error {
 		if len(props.Enum) == 0 {
 			break
 		}
-		m := protoapi.EnumValueMap(props.Enum)
+		m := EnumValueMap(props.Enum)
 		if m == nil {
 			break
 		}

protoapi/registry.go

@@ -1,132 +0,0 @@
-// 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 protoapi
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"strconv"
-)
-
-// TODO: This entire file should not exist and will eventually be deleted.
-// This is added for bootstrapping purposes so that a descriptor proto can be
-// generated that supports v2 reflection, but still registers into the
-// v1 registries for the time being.
-
-var enumValueMaps = make(map[string]map[string]int32)
-
-// RegisterEnum is called from the generated code to install the enum descriptor
-// maps into the global table to aid parsing text format protocol buffers.
-func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
-	if _, ok := enumValueMaps[typeName]; ok {
-		panic("proto: duplicate enum registered: " + typeName)
-	}
-	enumValueMaps[typeName] = valueMap
-}
-
-// EnumValueMap returns the mapping from names to integers of the
-// enum type enumType, or a nil if not found.
-func EnumValueMap(enumType string) map[string]int32 {
-	return enumValueMaps[enumType]
-}
-
-// A registry of all linked message types.
-// The string is a fully-qualified proto name ("pkg.Message").
-var (
-	protoTypedNils = make(map[string]Message)      // a map from proto names to typed nil pointers
-	protoMapTypes  = make(map[string]reflect.Type) // a map from proto names to map types
-	revProtoTypes  = make(map[reflect.Type]string)
-)
-
-// RegisterType is called from generated code and maps from the fully qualified
-// proto name to the type (pointer to struct) of the protocol buffer.
-func RegisterType(x Message, name string) {
-	if _, ok := protoTypedNils[name]; ok {
-		// TODO: Some day, make this a panic.
-		log.Printf("proto: duplicate proto type registered: %s", name)
-		return
-	}
-	t := reflect.TypeOf(x)
-	if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
-		// Generated code always calls RegisterType with nil x.
-		// This check is just for extra safety.
-		protoTypedNils[name] = x
-	} else {
-		protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
-	}
-	revProtoTypes[t] = name
-}
-
-// RegisterMapType is called from generated code and maps from the fully qualified
-// proto name to the native map type of the proto map definition.
-func RegisterMapType(x interface{}, name string) {
-	if reflect.TypeOf(x).Kind() != reflect.Map {
-		panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
-	}
-	if _, ok := protoMapTypes[name]; ok {
-		log.Printf("proto: duplicate proto type registered: %s", name)
-		return
-	}
-	t := reflect.TypeOf(x)
-	protoMapTypes[name] = t
-	revProtoTypes[t] = name
-}
-
-// MessageName returns the fully-qualified proto name for the given message type.
-func MessageName(x Message) string {
-	type xname interface {
-		XXX_MessageName() string
-	}
-	if m, ok := x.(xname); ok {
-		return m.XXX_MessageName()
-	}
-	return revProtoTypes[reflect.TypeOf(x)]
-}
-
-// MessageType returns the message type (pointer to struct) for a named message.
-// The type is not guaranteed to implement proto.Message if the name refers to a
-// map entry.
-func MessageType(name string) reflect.Type {
-	if t, ok := protoTypedNils[name]; ok {
-		return reflect.TypeOf(t)
-	}
-	return protoMapTypes[name]
-}
-
-// A registry of all linked proto files.
-var protoFiles = make(map[string][]byte) // file name => fileDescriptor
-
-// RegisterFile is called from generated code and maps from the
-// full file name of a .proto file to its compressed FileDescriptorProto.
-func RegisterFile(filename string, fileDescriptor []byte) {
-	protoFiles[filename] = fileDescriptor
-}
-
-// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
-func FileDescriptor(filename string) []byte { return protoFiles[filename] }
-
-var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
-
-// RegisterExtension is called from the generated code.
-func RegisterExtension(desc *ExtensionDesc) {
-	st := reflect.TypeOf(desc.ExtendedType).Elem()
-	m := extensionMaps[st]
-	if m == nil {
-		m = make(map[int32]*ExtensionDesc)
-		extensionMaps[st] = m
-	}
-	if _, ok := m[desc.Field]; ok {
-		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
-	}
-	m[desc.Field] = desc
-}
-
-// RegisteredExtensions returns a map of the registered extensions of a
-// protocol buffer struct, indexed by the extension number.
-// The argument pb should be a nil pointer to the struct type.
-func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
-	return extensionMaps[reflect.TypeOf(pb).Elem()]
-}

protoc-gen-go/descriptor/descriptor.pb.go

@@ -5,18 +5,11 @@ package descriptor
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	descriptor "github.com/golang/protobuf/v2/types/descriptor"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/descriptor.proto
 
 type FieldDescriptorProto_Type = descriptor.FieldDescriptorProto_Type
@@ -156,10 +149,6 @@ type UninterpretedOption_NamePart = descriptor.UninterpretedOption_NamePart
 type SourceCodeInfo_Location = descriptor.SourceCodeInfo_Location
 type GeneratedCodeInfo_Annotation = descriptor.GeneratedCodeInfo_Annotation
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto", xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawdesc = []byte{
 	// 180 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x44, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -176,7 +165,7 @@ var xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_prot
 	0x6f, 0x74, 0x6f, 0x32,
 }
 
-var xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -195,6 +184,7 @@ func xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_pro
 		GoTypes:           xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto", xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs = nil
 }

protoc-gen-go/plugin/plugin.pb.go

@@ -5,18 +5,11 @@ package plugin_go
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	plugin "github.com/golang/protobuf/v2/types/plugin"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/compiler/plugin.proto
 
 type Version = plugin.Version
@@ -24,10 +17,6 @@ type CodeGeneratorRequest = plugin.CodeGeneratorRequest
 type CodeGeneratorResponse = plugin.CodeGeneratorResponse
 type CodeGeneratorResponse_File = plugin.CodeGeneratorResponse_File
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto", xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdesc = []byte{
 	// 172 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x3c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -43,7 +32,7 @@ var xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdes
 	0x67, 0x6f, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
 }
 
-var xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -62,6 +51,7 @@ func xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_init(
 		GoTypes:           xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto", xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs = nil
 }

ptypes/any/any.pb.go

@@ -5,26 +5,15 @@ package any
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	known "github.com/golang/protobuf/v2/types/known"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/any.proto
 
 type Any = known.Any
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/ptypes/any/any.proto", xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc = []byte{
 	// 131 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -38,7 +27,7 @@ var xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc = []byte{
 	0x74, 0x6f, 0x33,
 }
 
-var xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -57,6 +46,7 @@ func xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_init() {
 		GoTypes:           xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/any/any.proto", xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = nil
 }

ptypes/duration/duration.pb.go

@@ -5,26 +5,15 @@ package duration
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	known "github.com/golang/protobuf/v2/types/known"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/duration.proto
 
 type Duration = known.Duration
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/ptypes/duration/duration.proto", xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc = []byte{
 	// 156 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -39,7 +28,7 @@ var xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc =
 	0x6f, 0x6e, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
-var xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -58,6 +47,7 @@ func xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_init() {
 		GoTypes:           xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/duration/duration.proto", xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = nil
 }

ptypes/empty/empty.pb.go

@@ -5,26 +5,15 @@ package empty
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	known "github.com/golang/protobuf/v2/types/known"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/empty.proto
 
 type Empty = known.Empty
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/ptypes/empty/empty.proto", xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc = []byte{
 	// 141 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -38,7 +27,7 @@ var xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc = []byt
 	0x70, 0x74, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
-var xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -57,6 +46,7 @@ func xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_init() {
 		GoTypes:           xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/empty/empty.proto", xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = nil
 }

ptypes/struct/struct.pb.go

@@ -5,18 +5,11 @@ package structpb
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	known "github.com/golang/protobuf/v2/types/known"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/struct.proto
 
 type NullValue = known.NullValue
@@ -36,10 +29,6 @@ type Value_StructValue = known.Value_StructValue
 type Value_ListValue = known.Value_ListValue
 type ListValue = known.ListValue
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/ptypes/struct/struct.proto", xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc = []byte{
 	// 148 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -54,7 +43,7 @@ var xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc = []b
 	0x6f, 0x74, 0x6f, 0x33,
 }
 
-var xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -73,6 +62,7 @@ func xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_init() {
 		GoTypes:           xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/struct/struct.proto", xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_ptypes_struct_struct_proto_depIdxs = nil
 }

ptypes/timestamp/timestamp.pb.go

@@ -5,26 +5,15 @@ package timestamp
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	known "github.com/golang/protobuf/v2/types/known"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/timestamp.proto
 
 type Timestamp = known.Timestamp
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/ptypes/timestamp/timestamp.proto", xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc = []byte{
 	// 161 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -40,7 +29,7 @@ var xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc
 	0x33,
 }
 
-var xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -59,6 +48,7 @@ func xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init()
 		GoTypes:           xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/timestamp/timestamp.proto", xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil
 }

ptypes/wrappers/wrappers.pb.go

@@ -5,18 +5,11 @@ package wrappers
 
 import (
 	proto "github.com/golang/protobuf/proto"
-	protoapi "github.com/golang/protobuf/protoapi"
 	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
 	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
 	known "github.com/golang/protobuf/v2/types/known"
 )
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
 // Symbols defined in public import of google/protobuf/wrappers.proto
 
 type DoubleValue = known.DoubleValue
@@ -29,10 +22,6 @@ type BoolValue = known.BoolValue
 type StringValue = known.StringValue
 type BytesValue = known.BytesValue
 
-func init() {
-	proto.RegisterFile("github.com/golang/protobuf/ptypes/wrappers/wrappers.proto", xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc_gzipped)
-}
-
 var xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc = []byte{
 	// 156 bytes of the wire-encoded FileDescriptorProto
 	0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
@@ -47,7 +36,7 @@ var xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc =
 	0x72, 0x73, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
-var xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc_gzipped = protoapi.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc)
+var xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc_gzipped = protoimpl.X.CompressGZIP(xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc)
 
 const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
 
@@ -66,6 +55,7 @@ func xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() {
 		GoTypes:           xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes,
 		DependencyIndexes: xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs,
 	}.Init()
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/wrappers/wrappers.proto", xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawdesc_gzipped)
 	xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = nil
 	xxx_File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = nil
 }