Create & Init Project...

app/tool/gengo/cmd/deepcopy-gen/.gitignore

@@ -0,0 +1 @@
+deepcopy-gen

app/tool/gengo/cmd/deepcopy-gen/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "deepcopy-gen",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    importpath = "go-common/app/tool/gengo/cmd/deepcopy-gen",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/tool/gengo/args:go_default_library",
+        "//app/tool/gengo/cmd/deepcopy-gen/generators:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/tool/gengo/cmd/deepcopy-gen/examples/api/v1:all-srcs",
+        "//app/tool/gengo/cmd/deepcopy-gen/examples/model:all-srcs",
+        "//app/tool/gengo/cmd/deepcopy-gen/examples/tests:all-srcs",
+        "//app/tool/gengo/cmd/deepcopy-gen/generators:all-srcs",
+        "//app/tool/gengo/cmd/deepcopy-gen/sets:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/tool/gengo/cmd/deepcopy-gen/Makefile

@@ -0,0 +1,4 @@
+example:
+	go install
+	deepcopy-gen -logtostderr -v=6 -input-dirs ./examples/api/v1/,./examples/model/ -output-file-base copy
+	go test -v ./examples/tests

app/tool/gengo/cmd/deepcopy-gen/examples/api/v1/BUILD

@@ -0,0 +1,62 @@
+load(
+    "@io_bazel_rules_go//proto:def.bzl",
+    "go_proto_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+proto_library(
+    name = "v1_proto",
+    srcs = ["api.proto"],
+    tags = ["automanaged"],
+    deps = ["@gogo_special_proto//github.com/gogo/protobuf/gogoproto"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "copy.go",
+        "doc.go",
+    ],
+    embed = [":v1_go_proto"],
+    importpath = "go-common/app/tool/gengo/cmd/deepcopy-gen/examples/api/v1",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/tool/gengo/cmd/deepcopy-gen/examples/model:go_default_library",
+        "//library/time:go_default_library",
+        "@com_github_gogo_protobuf//gogoproto:go_default_library",
+        "@com_github_golang_protobuf//proto:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_proto_library(
+    name = "v1_go_proto",
+    compilers = ["@io_bazel_rules_go//proto:gogofast_proto"],
+    importpath = "go-common/app/tool/gengo/cmd/deepcopy-gen/examples/api/v1",
+    proto = ":v1_proto",
+    tags = ["automanaged"],
+    deps = [
+        "//library/time:go_default_library",
+        "@com_github_gogo_protobuf//gogoproto:go_default_library",
+    ],
+)

app/tool/gengo/cmd/deepcopy-gen/examples/api/v1/api.pb.go

@@ -0,0 +1,961 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: api.proto
+
+/*
+	Package v1 is a generated protocol buffer package.
+
+	It is generated from these files:
+		api.proto
+
+	It has these top-level messages:
+		BaseInfoReply
+		NamesReply
+		MidsReply
+*/
+package v1
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "github.com/gogo/protobuf/gogoproto"
+
+import go_common_library_time "go-common/library/time"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// 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.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// +bili:deepcopy-gen:structs=go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model.MemberBase
+type BaseInfoReply struct {
+	Mid      int64                       `protobuf:"varint,1,opt,name=mid,proto3" json:"mid"`
+	Name     string                      `protobuf:"bytes,2,opt,name=name,proto3" json:"name"`
+	Sex      int64                       `protobuf:"varint,3,opt,name=sex,proto3" json:"sex"`
+	Face     string                      `protobuf:"bytes,4,opt,name=face,proto3" json:"face"`
+	Sign     string                      `protobuf:"bytes,5,opt,name=sign,proto3" json:"sign"`
+	Rank     int64                       `protobuf:"varint,6,opt,name=rank,proto3" json:"rank"`
+	Birthday go_common_library_time.Time `protobuf:"varint,7,opt,name=birthday,proto3,casttype=go-common/library/time.Time" json:"birthday"`
+}
+
+func (m *BaseInfoReply) Reset()                    { *m = BaseInfoReply{} }
+func (m *BaseInfoReply) String() string            { return proto.CompactTextString(m) }
+func (*BaseInfoReply) ProtoMessage()               {}
+func (*BaseInfoReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{0} }
+
+func (m *BaseInfoReply) GetMid() int64 {
+	if m != nil {
+		return m.Mid
+	}
+	return 0
+}
+
+func (m *BaseInfoReply) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *BaseInfoReply) GetSex() int64 {
+	if m != nil {
+		return m.Sex
+	}
+	return 0
+}
+
+func (m *BaseInfoReply) GetFace() string {
+	if m != nil {
+		return m.Face
+	}
+	return ""
+}
+
+func (m *BaseInfoReply) GetSign() string {
+	if m != nil {
+		return m.Sign
+	}
+	return ""
+}
+
+func (m *BaseInfoReply) GetRank() int64 {
+	if m != nil {
+		return m.Rank
+	}
+	return 0
+}
+
+func (m *BaseInfoReply) GetBirthday() go_common_library_time.Time {
+	if m != nil {
+		return m.Birthday
+	}
+	return 0
+}
+
+// +bili:deepcopy-gen:structs=go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model.Names
+type NamesReply struct {
+	Names map[int64]string `protobuf:"bytes,1,rep,name=names" json:"names,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+}
+
+func (m *NamesReply) Reset()                    { *m = NamesReply{} }
+func (m *NamesReply) String() string            { return proto.CompactTextString(m) }
+func (*NamesReply) ProtoMessage()               {}
+func (*NamesReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} }
+
+func (m *NamesReply) GetNames() map[int64]string {
+	if m != nil {
+		return m.Names
+	}
+	return nil
+}
+
+// +bili:deepcopy-gen:structs=go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model.Mids
+type MidsReply struct {
+	Mids []int64 `protobuf:"varint,1,rep,packed,name=mids" json:"mids,omitempty"`
+}
+
+func (m *MidsReply) Reset()                    { *m = MidsReply{} }
+func (m *MidsReply) String() string            { return proto.CompactTextString(m) }
+func (*MidsReply) ProtoMessage()               {}
+func (*MidsReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2} }
+
+func (m *MidsReply) GetMids() []int64 {
+	if m != nil {
+		return m.Mids
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*BaseInfoReply)(nil), "account.service.member.v1.BaseInfoReply")
+	proto.RegisterType((*NamesReply)(nil), "account.service.member.v1.NamesReply")
+	proto.RegisterType((*MidsReply)(nil), "account.service.member.v1.MidsReply")
+}
+func (m *BaseInfoReply) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BaseInfoReply) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Mid != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
+	}
+	if len(m.Name) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if m.Sex != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(m.Sex))
+	}
+	if len(m.Face) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(len(m.Face)))
+		i += copy(dAtA[i:], m.Face)
+	}
+	if len(m.Sign) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(len(m.Sign)))
+		i += copy(dAtA[i:], m.Sign)
+	}
+	if m.Rank != 0 {
+		dAtA[i] = 0x30
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(m.Rank))
+	}
+	if m.Birthday != 0 {
+		dAtA[i] = 0x38
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(m.Birthday))
+	}
+	return i, nil
+}
+
+func (m *NamesReply) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *NamesReply) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Names) > 0 {
+		for k, _ := range m.Names {
+			dAtA[i] = 0xa
+			i++
+			v := m.Names[k]
+			mapSize := 1 + sovApi(uint64(k)) + 1 + len(v) + sovApi(uint64(len(v)))
+			i = encodeVarintApi(dAtA, i, uint64(mapSize))
+			dAtA[i] = 0x8
+			i++
+			i = encodeVarintApi(dAtA, i, uint64(k))
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintApi(dAtA, i, uint64(len(v)))
+			i += copy(dAtA[i:], v)
+		}
+	}
+	return i, nil
+}
+
+func (m *MidsReply) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MidsReply) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Mids) > 0 {
+		dAtA2 := make([]byte, len(m.Mids)*10)
+		var j1 int
+		for _, num1 := range m.Mids {
+			num := uint64(num1)
+			for num >= 1<<7 {
+				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j1++
+			}
+			dAtA2[j1] = uint8(num)
+			j1++
+		}
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintApi(dAtA, i, uint64(j1))
+		i += copy(dAtA[i:], dAtA2[:j1])
+	}
+	return i, nil
+}
+
+func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *BaseInfoReply) Size() (n int) {
+	var l int
+	_ = l
+	if m.Mid != 0 {
+		n += 1 + sovApi(uint64(m.Mid))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovApi(uint64(l))
+	}
+	if m.Sex != 0 {
+		n += 1 + sovApi(uint64(m.Sex))
+	}
+	l = len(m.Face)
+	if l > 0 {
+		n += 1 + l + sovApi(uint64(l))
+	}
+	l = len(m.Sign)
+	if l > 0 {
+		n += 1 + l + sovApi(uint64(l))
+	}
+	if m.Rank != 0 {
+		n += 1 + sovApi(uint64(m.Rank))
+	}
+	if m.Birthday != 0 {
+		n += 1 + sovApi(uint64(m.Birthday))
+	}
+	return n
+}
+
+func (m *NamesReply) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.Names) > 0 {
+		for k, v := range m.Names {
+			_ = k
+			_ = v
+			mapEntrySize := 1 + sovApi(uint64(k)) + 1 + len(v) + sovApi(uint64(len(v)))
+			n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize))
+		}
+	}
+	return n
+}
+
+func (m *MidsReply) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.Mids) > 0 {
+		l = 0
+		for _, e := range m.Mids {
+			l += sovApi(uint64(e))
+		}
+		n += 1 + sovApi(uint64(l)) + l
+	}
+	return n
+}
+
+func sovApi(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozApi(x uint64) (n int) {
+	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *BaseInfoReply) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowApi
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: BaseInfoReply: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BaseInfoReply: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
+			}
+			m.Mid = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Mid |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthApi
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sex", wireType)
+			}
+			m.Sex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Sex |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Face", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthApi
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Face = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sign", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthApi
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Sign = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rank", wireType)
+			}
+			m.Rank = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Rank |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Birthday", wireType)
+			}
+			m.Birthday = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Birthday |= (go_common_library_time.Time(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipApi(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthApi
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *NamesReply) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowApi
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: NamesReply: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: NamesReply: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthApi
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Names == nil {
+				m.Names = make(map[int64]string)
+			}
+			var mapkey int64
+			var mapvalue string
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowApi
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					wire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapkey |= (int64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+				} else if fieldNum == 2 {
+					var stringLenmapvalue uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
+						return ErrInvalidLengthApi
+					}
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipApi(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if skippy < 0 {
+						return ErrInvalidLengthApi
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
+				}
+			}
+			m.Names[mapkey] = mapvalue
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipApi(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthApi
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MidsReply) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowApi
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MidsReply: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MidsReply: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType == 0 {
+				var v int64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowApi
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= (int64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.Mids = append(m.Mids, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowApi
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= (int(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return ErrInvalidLengthApi
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				for iNdEx < postIndex {
+					var v int64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowApi
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= (int64(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.Mids = append(m.Mids, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field Mids", wireType)
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipApi(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthApi
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipApi(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowApi
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthApi
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowApi
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipApi(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowApi   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("api.proto", fileDescriptorApi) }
+
+var fileDescriptorApi = []byte{
+	// 383 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xbb, 0x6e, 0xdb, 0x30,
+	0x18, 0x85, 0x4b, 0xc9, 0x57, 0x16, 0x05, 0x0a, 0xc1, 0x03, 0xed, 0x16, 0x92, 0xe1, 0xc9, 0x40,
+	0x61, 0xaa, 0x6e, 0x17, 0xa3, 0xa3, 0x80, 0xb6, 0xc8, 0x90, 0x0c, 0x44, 0xa6, 0x6c, 0x94, 0x44,
+	0xcb, 0x84, 0x4d, 0xd1, 0xa0, 0x2e, 0xb0, 0x5e, 0x20, 0x63, 0xe6, 0x3c, 0x52, 0xc6, 0x3c, 0x81,
+	0x10, 0x38, 0x9b, 0x1f, 0x21, 0x53, 0x40, 0xca, 0xb0, 0xa6, 0x2c, 0x07, 0xff, 0xc7, 0xc3, 0xf3,
+	0x83, 0x3a, 0x82, 0x43, 0xba, 0xe7, 0x78, 0xaf, 0x64, 0x2e, 0x9d, 0x31, 0x8d, 0x22, 0x59, 0xa4,
+	0x39, 0xce, 0x98, 0x2a, 0x79, 0xc4, 0xb0, 0x60, 0x22, 0x64, 0x0a, 0x97, 0xcb, 0xc9, 0x22, 0xe1,
+	0xf9, 0xa6, 0x08, 0x71, 0x24, 0x85, 0x9f, 0xc8, 0x44, 0xfa, 0x26, 0x11, 0x16, 0x6b, 0x43, 0x06,
+	0xcc, 0xd4, 0x6c, 0x9a, 0xdd, 0x5b, 0xf0, 0x4b, 0x40, 0x33, 0x76, 0x95, 0xae, 0x25, 0x61, 0xfb,
+	0x5d, 0xe5, 0x8c, 0xa1, 0x2d, 0x78, 0x8c, 0xc0, 0x14, 0xcc, 0xed, 0xa0, 0x7f, 0xaa, 0x3d, 0x8d,
+	0x44, 0x8b, 0xf3, 0x1d, 0x76, 0x52, 0x2a, 0x18, 0xb2, 0xa6, 0x60, 0x3e, 0x0c, 0x06, 0xa7, 0xda,
+	0x33, 0x4c, 0x8c, 0xea, 0x60, 0xc6, 0x0e, 0xc8, 0x6e, 0x83, 0x19, 0x3b, 0x10, 0x2d, 0x3a, 0xb8,
+	0xa6, 0x11, 0x43, 0x9d, 0x36, 0xa8, 0x99, 0x18, 0xd5, 0x6e, 0xc6, 0x93, 0x14, 0x75, 0x5b, 0x57,
+	0x33, 0x31, 0xaa, 0x5d, 0x45, 0xd3, 0x2d, 0xea, 0x99, 0xbd, 0xc6, 0xd5, 0x4c, 0x8c, 0x3a, 0xff,
+	0xe1, 0x20, 0xe4, 0x2a, 0xdf, 0xc4, 0xb4, 0x42, 0x7d, 0x73, 0xe3, 0xc7, 0xa9, 0xf6, 0x2e, 0x67,
+	0x6f, 0xb5, 0xf7, 0x2d, 0x91, 0x8b, 0x48, 0x0a, 0x21, 0x53, 0x7f, 0xc7, 0x43, 0x45, 0x55, 0xe5,
+	0xe7, 0x5c, 0x30, 0x7c, 0xcb, 0x05, 0x23, 0x97, 0x8b, 0xb3, 0x07, 0x00, 0xe1, 0x0d, 0x15, 0x2c,
+	0x6b, 0x5a, 0xf8, 0x07, 0xbb, 0xfa, 0xa3, 0x32, 0x04, 0xa6, 0xf6, 0xfc, 0xf3, 0xaf, 0x9f, 0xf8,
+	0xc3, 0xc6, 0x71, 0x9b, 0x6a, 0xc6, 0xbf, 0x69, 0xae, 0x2a, 0xd2, 0xc4, 0x27, 0xab, 0xf3, 0x56,
+	0x73, 0xe8, 0x7c, 0x85, 0xf6, 0x96, 0x55, 0x4d, 0xb7, 0x44, 0x8f, 0xce, 0x08, 0x76, 0x4b, 0xba,
+	0x2b, 0xce, 0x9d, 0x92, 0x06, 0xfe, 0x58, 0x2b, 0x30, 0xf3, 0xe0, 0xf0, 0x9a, 0xc7, 0xe7, 0xe7,
+	0x38, 0xb0, 0x23, 0x78, 0xdc, 0xbc, 0xc6, 0x26, 0x66, 0x0e, 0x46, 0x4f, 0x47, 0x17, 0x3c, 0x1f,
+	0x5d, 0xf0, 0x72, 0x74, 0xc1, 0xe3, 0xab, 0xfb, 0xe9, 0xce, 0x2a, 0x97, 0x61, 0xcf, 0xfc, 0xd7,
+	0xdf, 0xef, 0x01, 0x00, 0x00, 0xff, 0xff, 0x85, 0x29, 0x80, 0x4b, 0x2e, 0x02, 0x00, 0x00,
+}

app/tool/gengo/cmd/deepcopy-gen/examples/api/v1/api.proto

@@ -0,0 +1,25 @@
+syntax = "proto3";
+package account.service.member.v1;
+option go_package = "v1";
+
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+
+// +bili:deepcopy-gen:structs=go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model.MemberBase
+message BaseInfoReply {
+  int64 mid = 1 [ (gogoproto.jsontag) = "mid" ];
+  string name = 2 [ (gogoproto.jsontag) = "name" ];
+  int64 sex = 3 [ (gogoproto.jsontag) = "sex" ];
+  string face = 4 [ (gogoproto.jsontag) = "face" ];
+  string sign = 5 [ (gogoproto.jsontag) = "sign" ];
+  int64 rank = 6 [ (gogoproto.jsontag) = "rank" ];
+  int64 birthday = 7 [
+    (gogoproto.jsontag) = "birthday",
+    (gogoproto.casttype) = "go-common/library/time.Time"
+  ];
+}
+
+// +bili:deepcopy-gen:structs=go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model.Names
+message NamesReply { map<int64, string> names = 1; }
+
+// +bili:deepcopy-gen:structs=go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model.Mids
+message MidsReply { repeated int64 mids = 1; }

app/tool/gengo/cmd/deepcopy-gen/examples/api/v1/copy.go

@@ -0,0 +1,167 @@
+// +build !ignore_autogenerated
+
+// Code generated by deepcopy-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	model "go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model"
+)
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *BaseInfoReply) DeepCopyInto(out *BaseInfoReply) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BaseInfoReply.
+func (in *BaseInfoReply) DeepCopy() *BaseInfoReply {
+	if in == nil {
+		return nil
+	}
+	out := new(BaseInfoReply)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyAsIntoMemberBase is an autogenerated deepcopy function, copying the receiver, writing into model.MemberBase.
+func (in *BaseInfoReply) DeepCopyAsIntoMemberBase(out *model.MemberBase) {
+	out.Mid = in.Mid
+	out.Name = in.Name
+	out.Sex = in.Sex
+	out.Face = in.Face
+	out.Sign = in.Sign
+	out.Rank = in.Rank
+	out.Birthday = in.Birthday
+	return
+}
+
+// DeepCopyFromMemberBase is an autogenerated deepcopy function, copying the receiver, writing into model.MemberBase.
+func (out *BaseInfoReply) DeepCopyFromMemberBase(in *model.MemberBase) {
+	out.Mid = in.Mid
+	out.Name = in.Name
+	out.Sex = in.Sex
+	out.Face = in.Face
+	out.Sign = in.Sign
+	out.Rank = in.Rank
+	out.Birthday = in.Birthday
+	return
+}
+
+// DeepCopyAsMemberBase is an autogenerated deepcopy function, copying the receiver, creating a new model.MemberBase.
+func (in *BaseInfoReply) DeepCopyAsMemberBase() *model.MemberBase {
+	if in == nil {
+		return nil
+	}
+	out := new(model.MemberBase)
+	in.DeepCopyAsIntoMemberBase(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *MidsReply) DeepCopyInto(out *MidsReply) {
+	*out = *in
+	if in.Mids != nil {
+		in, out := &in.Mids, &out.Mids
+		*out = make([]int64, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MidsReply.
+func (in *MidsReply) DeepCopy() *MidsReply {
+	if in == nil {
+		return nil
+	}
+	out := new(MidsReply)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyAsIntoMids is an autogenerated deepcopy function, copying the receiver, writing into model.Mids.
+func (in *MidsReply) DeepCopyAsIntoMids(out *model.Mids) {
+	if in.Mids != nil {
+		in, out := &in.Mids, &out.Mids
+		*out = make([]int64, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopyFromMids is an autogenerated deepcopy function, copying the receiver, writing into model.Mids.
+func (out *MidsReply) DeepCopyFromMids(in *model.Mids) {
+	if in.Mids != nil {
+		in, out := &in.Mids, &out.Mids
+		*out = make([]int64, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopyAsMids is an autogenerated deepcopy function, copying the receiver, creating a new model.Mids.
+func (in *MidsReply) DeepCopyAsMids() *model.Mids {
+	if in == nil {
+		return nil
+	}
+	out := new(model.Mids)
+	in.DeepCopyAsIntoMids(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamesReply) DeepCopyInto(out *NamesReply) {
+	*out = *in
+	if in.Names != nil {
+		in, out := &in.Names, &out.Names
+		*out = make(map[int64]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamesReply.
+func (in *NamesReply) DeepCopy() *NamesReply {
+	if in == nil {
+		return nil
+	}
+	out := new(NamesReply)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyAsIntoNames is an autogenerated deepcopy function, copying the receiver, writing into model.Names.
+func (in *NamesReply) DeepCopyAsIntoNames(out *model.Names) {
+	if in.Names != nil {
+		in, out := &in.Names, &out.Names
+		*out = make(map[int64]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopyFromNames is an autogenerated deepcopy function, copying the receiver, writing into model.Names.
+func (out *NamesReply) DeepCopyFromNames(in *model.Names) {
+	if in.Names != nil {
+		in, out := &in.Names, &out.Names
+		*out = make(map[int64]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopyAsNames is an autogenerated deepcopy function, copying the receiver, creating a new model.Names.
+func (in *NamesReply) DeepCopyAsNames() *model.Names {
+	if in == nil {
+		return nil
+	}
+	out := new(model.Names)
+	in.DeepCopyAsIntoNames(out)
+	return out
+}

app/tool/gengo/cmd/deepcopy-gen/examples/api/v1/doc.go

@@ -0,0 +1,2 @@
+// +bili:deepcopy-gen=package
+package v1

app/tool/gengo/cmd/deepcopy-gen/examples/model/BUILD

@@ -0,0 +1,32 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "model.go",
+    ],
+    importpath = "go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//library/time:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/tool/gengo/cmd/deepcopy-gen/examples/model/doc.go

@@ -0,0 +1 @@
+package model

app/tool/gengo/cmd/deepcopy-gen/examples/model/model.go

@@ -0,0 +1,26 @@
+package model
+
+import (
+	"go-common/library/time"
+)
+
+// MemberBase is
+type MemberBase struct {
+	Mid      int64
+	Name     string
+	Sex      int64
+	Face     string
+	Sign     string
+	Rank     int64
+	Birthday time.Time
+}
+
+// Names is
+type Names struct {
+	Names map[int64]string
+}
+
+// Mids is
+type Mids struct {
+	Mids []int64
+}

app/tool/gengo/cmd/deepcopy-gen/examples/tests/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["example_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/tool/gengo/cmd/deepcopy-gen/examples/api/v1:go_default_library",
+        "//app/tool/gengo/cmd/deepcopy-gen/examples/model:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["example.go"],
+    importpath = "go-common/app/tool/gengo/cmd/deepcopy-gen/examples/tests",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/tool/gengo/cmd/deepcopy-gen/examples/tests/example.go

@@ -0,0 +1 @@
+package tests

app/tool/gengo/cmd/deepcopy-gen/examples/tests/example_test.go

@@ -0,0 +1,77 @@
+package tests
+
+import (
+	"testing"
+	"time"
+	"unsafe"
+
+	"github.com/stretchr/testify/assert"
+
+	"go-common/app/tool/gengo/cmd/deepcopy-gen/examples/api/v1"
+	"go-common/app/tool/gengo/cmd/deepcopy-gen/examples/model"
+	xtime "go-common/library/time"
+)
+
+func TestCopyFromAllBuitin(t *testing.T) {
+	base := &model.MemberBase{
+		Mid:      1,
+		Name:     "name",
+		Sex:      1,
+		Face:     "aaa.jpg",
+		Sign:     "sign",
+		Rank:     10000,
+		Birthday: xtime.Time(time.Now().Unix()),
+	}
+	reply := new(v1.BaseInfoReply)
+	reply.DeepCopyFromMemberBase(base)
+
+	assert.Equal(t, base.Mid, reply.Mid)
+	assert.Equal(t, base.Name, reply.Name)
+	assert.Equal(t, base.Sex, reply.Sex)
+	assert.Equal(t, base.Face, reply.Face)
+	assert.Equal(t, base.Sign, reply.Sign)
+	assert.Equal(t, base.Rank, reply.Rank)
+	assert.Equal(t, base.Birthday, reply.Birthday)
+
+	copied := reply.DeepCopyAsMemberBase()
+	assert.Equal(t, base, copied)
+}
+
+func TestCopyFromMap(t *testing.T) {
+	names := &model.Names{
+		Names: map[int64]string{
+			1: "1",
+			2: "2",
+		},
+	}
+	reply := new(v1.NamesReply)
+	reply.DeepCopyFromNames(names)
+
+	assert.Equal(t, names.Names[1], reply.Names[1])
+	assert.Equal(t, names.Names[2], reply.Names[2])
+	assert.Equal(t, unsafe.Pointer(&names.Names), unsafe.Pointer(&names.Names))
+	assert.Equal(t, unsafe.Pointer(&reply.Names), unsafe.Pointer(&reply.Names))
+	assert.NotEqual(t, unsafe.Pointer(&names.Names), unsafe.Pointer(&reply.Names))
+
+	names.Names[3] = "3"
+	assert.Contains(t, names.Names, int64(3))
+	assert.NotContains(t, reply.Names, int64(3))
+}
+
+func TestCopyFromSlice(t *testing.T) {
+	mids := &model.Mids{
+		Mids: []int64{1, 2},
+	}
+	reply := new(v1.MidsReply)
+	reply.DeepCopyFromMids(mids)
+
+	assert.Equal(t, mids.Mids[0], reply.Mids[0])
+	assert.Equal(t, mids.Mids[1], reply.Mids[1])
+	assert.Equal(t, unsafe.Pointer(&mids.Mids), unsafe.Pointer(&mids.Mids))
+	assert.Equal(t, unsafe.Pointer(&reply.Mids), unsafe.Pointer(&reply.Mids))
+	assert.NotEqual(t, unsafe.Pointer(&mids.Mids), unsafe.Pointer(&reply.Mids))
+
+	mids.Mids = append(mids.Mids, 3)
+	assert.Equal(t, mids.Mids[2], int64(3))
+	assert.NotContains(t, reply.Mids, int64(3))
+}

app/tool/gengo/cmd/deepcopy-gen/generators/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["deepcopy_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = ["//app/tool/gengo/types:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["deepcopy.go"],
+    importpath = "go-common/app/tool/gengo/cmd/deepcopy-gen/generators",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/tool/gengo/args:go_default_library",
+        "//app/tool/gengo/cmd/deepcopy-gen/sets:go_default_library",
+        "//app/tool/gengo/generator:go_default_library",
+        "//app/tool/gengo/namer:go_default_library",
+        "//app/tool/gengo/types:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/tool/gengo/cmd/deepcopy-gen/generators/deepcopy_test.go

@@ -0,0 +1,697 @@
+package generators
+
+import (
+	"reflect"
+	"testing"
+
+	"go-common/app/tool/gengo/types"
+)
+
+func Test_isRootedUnder(t *testing.T) {
+	testCases := []struct {
+		path   string
+		roots  []string
+		expect bool
+	}{
+		{
+			path:   "/foo/bar",
+			roots:  nil,
+			expect: false,
+		},
+		{
+			path:   "/foo/bar",
+			roots:  []string{},
+			expect: false,
+		},
+		{
+			path: "/foo/bar",
+			roots: []string{
+				"/bad",
+			},
+			expect: false,
+		},
+		{
+			path: "/foo/bar",
+			roots: []string{
+				"/foo",
+			},
+			expect: true,
+		},
+		{
+			path: "/foo/bar",
+			roots: []string{
+				"/bad",
+				"/foo",
+			},
+			expect: true,
+		},
+		{
+			path: "/foo/bar/qux/zorb",
+			roots: []string{
+				"/foo/bar/qux",
+			},
+			expect: true,
+		},
+		{
+			path: "/foo/bar",
+			roots: []string{
+				"/foo/bar",
+			},
+			expect: true,
+		},
+		{
+			path: "/foo/barn",
+			roots: []string{
+				"/foo/bar",
+			},
+			expect: false,
+		},
+		{
+			path: "/foo/bar",
+			roots: []string{
+				"/foo/barn",
+			},
+			expect: false,
+		},
+		{
+			path: "/foo/bar",
+			roots: []string{
+				"",
+			},
+			expect: true,
+		},
+	}
+
+	for i, tc := range testCases {
+		r := isRootedUnder(tc.path, tc.roots)
+		if r != tc.expect {
+			t.Errorf("case[%d]: expected %t, got %t for %q in %q", i, tc.expect, r, tc.path, tc.roots)
+		}
+	}
+}
+
+func Test_deepCopyMethod(t *testing.T) {
+	testCases := []struct {
+		typ    types.Type
+		expect bool
+		error  bool
+	}{
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				// No DeepCopy method.
+				Methods: map[string]*types.Type{},
+			},
+			expect: false,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// No DeepCopy method.
+					"method": {
+						Name: types.Name{Package: "pkgname", Name: "func()"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results:    []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: false,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (no result).
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func()"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results:    []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (wrong result).
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func() int"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results: []*types.Type{
+								{
+									Name: types.Name{Name: "int"},
+									Kind: types.Builtin,
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature with pointer receiver, but non-pointer result.
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func() pkgname.typename"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results: []*types.Type{
+								{
+									Name: types.Name{Package: "pkgname", Name: "typename"},
+									Kind: types.Builtin,
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature with non-pointer receiver, but pointer result.
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func() pkgname.typename"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver:   &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							Parameters: []*types.Type{},
+							Results: []*types.Type{
+								{
+									Kind: types.Pointer,
+									Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Correct signature with non-pointer receiver.
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func() pkgname.typename"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver:   &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							Parameters: []*types.Type{},
+							Results: []*types.Type{
+								{
+									Name: types.Name{Package: "pkgname", Name: "typename"},
+									Kind: types.Builtin,
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Correct signature with pointer receiver.
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func() pkgname.typename"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results: []*types.Type{
+								{
+									Kind: types.Pointer,
+									Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (has params).
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func(int) pkgname.typename"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{
+								{
+									Name: types.Name{Name: "int"},
+									Kind: types.Builtin,
+								},
+							},
+							Results: []*types.Type{
+								{
+									Name: types.Name{Package: "pkgname", Name: "typename"},
+									Kind: types.Builtin,
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (extra results).
+					"DeepCopy": {
+						Name: types.Name{Package: "pkgname", Name: "func() (pkgname.typename, int)"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results: []*types.Type{
+								{
+									Name: types.Name{Package: "pkgname", Name: "typename"},
+									Kind: types.Builtin,
+								},
+								{
+									Name: types.Name{Name: "int"},
+									Kind: types.Builtin,
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+	}
+
+	for i, tc := range testCases {
+		r, err := deepCopyMethod(&tc.typ)
+		if tc.error && err == nil {
+			t.Errorf("case[%d]: expected an error, got none", i)
+		} else if !tc.error && err != nil {
+			t.Errorf("case[%d]: expected no error, got: %v", i, err)
+		} else if !tc.error && (r != nil) != tc.expect {
+			t.Errorf("case[%d]: expected result %v, got: %v", i, tc.expect, r)
+		}
+	}
+}
+
+func Test_deepCopyIntoMethod(t *testing.T) {
+	testCases := []struct {
+		typ    types.Type
+		expect bool
+		error  bool
+	}{
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				// No DeepCopyInto method.
+				Methods: map[string]*types.Type{},
+			},
+			expect: false,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// No DeepCopyInto method.
+					"method": {
+						Name: types.Name{Package: "pkgname", Name: "func()"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results:    []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: false,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (no parameter).
+					"DeepCopyInto": {
+						Name: types.Name{Package: "pkgname", Name: "func()"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{},
+							Results:    []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (unexpected result).
+					"DeepCopyInto": {
+						Name: types.Name{Package: "pkgname", Name: "func(*pkgname.typename) int"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{
+								{
+									Kind: types.Pointer,
+									Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+								},
+							},
+							Results: []*types.Type{
+								{
+									Name: types.Name{Name: "int"},
+									Kind: types.Builtin,
+								},
+							},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (non-pointer parameter, pointer receiver).
+					"DeepCopyInto": {
+						Name: types.Name{Package: "pkgname", Name: "func(pkgname.typename)"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{
+								{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Results: []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Wrong signature (non-pointer parameter, non-pointer receiver).
+					"DeepCopyInto": {
+						Name: types.Name{Package: "pkgname", Name: "func(pkgname.typename)"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							Parameters: []*types.Type{
+								{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Results: []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: false,
+			error:  true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Correct signature with non-pointer receiver.
+					"DeepCopyInto": {
+						Name: types.Name{Package: "pkgname", Name: "func(*pkgname.typename)"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							Parameters: []*types.Type{
+								{
+									Kind: types.Pointer,
+									Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+								},
+							},
+							Results: []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: true,
+		},
+		{
+			typ: types.Type{
+				Name: types.Name{Package: "pkgname", Name: "typename"},
+				Kind: types.Builtin,
+				Methods: map[string]*types.Type{
+					// Correct signature with pointer receiver.
+					"DeepCopyInto": {
+						Name: types.Name{Package: "pkgname", Name: "func(*pkgname.typename)"},
+						Kind: types.Func,
+						Signature: &types.Signature{
+							Receiver: &types.Type{
+								Kind: types.Pointer,
+								Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+							},
+							Parameters: []*types.Type{
+								{
+									Kind: types.Pointer,
+									Elem: &types.Type{Kind: types.Struct, Name: types.Name{Package: "pkgname", Name: "typename"}},
+								},
+							},
+							Results: []*types.Type{},
+						},
+					},
+				},
+			},
+			expect: true,
+		},
+	}
+
+	for i, tc := range testCases {
+		r, err := deepCopyIntoMethod(&tc.typ)
+		if tc.error && err == nil {
+			t.Errorf("case[%d]: expected an error, got none", i)
+		} else if !tc.error && err != nil {
+			t.Errorf("case[%d]: expected no error, got: %v", i, err)
+		} else if !tc.error && (r != nil) != tc.expect {
+			t.Errorf("case[%d]: expected result %v, got: %v", i, tc.expect, r)
+		}
+	}
+}
+
+func Test_extractTagParams(t *testing.T) {
+	testCases := []struct {
+		comments []string
+		expect   *tagValue
+	}{
+		{
+			comments: []string{
+				"Human comment",
+			},
+			expect: nil,
+		},
+		{
+			comments: []string{
+				"Human comment",
+				"+bili:deepcopy-gen",
+			},
+			expect: &tagValue{
+				value:    "",
+				register: false,
+			},
+		},
+		{
+			comments: []string{
+				"Human comment",
+				"+bili:deepcopy-gen=package",
+			},
+			expect: &tagValue{
+				value:    "package",
+				register: false,
+			},
+		},
+		{
+			comments: []string{
+				"Human comment",
+				"+bili:deepcopy-gen=package,register",
+			},
+			expect: &tagValue{
+				value:    "package",
+				register: true,
+			},
+		},
+		{
+			comments: []string{
+				"Human comment",
+				"+bili:deepcopy-gen=package,register=true",
+			},
+			expect: &tagValue{
+				value:    "package",
+				register: true,
+			},
+		},
+		{
+			comments: []string{
+				"Human comment",
+				"+bili:deepcopy-gen=package,register=false",
+			},
+			expect: &tagValue{
+				value:    "package",
+				register: false,
+			},
+		},
+	}
+
+	for i, tc := range testCases {
+		r := extractTag(tc.comments)
+		if r == nil && tc.expect != nil {
+			t.Errorf("case[%d]: expected non-nil", i)
+		}
+		if r != nil && tc.expect == nil {
+			t.Errorf("case[%d]: expected nil, got %v", i, *r)
+		}
+		if r != nil && *r != *tc.expect {
+			t.Errorf("case[%d]: expected %v, got %v", i, *tc.expect, *r)
+		}
+	}
+}
+
+func Test_extractInterfacesTag(t *testing.T) {
+	testCases := []struct {
+		comments []string
+		expect   []string
+	}{
+		{
+			comments: []string{},
+			expect:   nil,
+		},
+		{
+			comments: []string{
+				"+bili:deepcopy-gen:interfaces=k8s.io/kubernetes/runtime.Object",
+			},
+			expect: []string{
+				"k8s.io/kubernetes/runtime.Object",
+			},
+		},
+		{
+			comments: []string{
+				"+bili:deepcopy-gen:interfaces=k8s.io/kubernetes/runtime.Object",
+				"+bili:deepcopy-gen:interfaces=k8s.io/kubernetes/runtime.List",
+			},
+			expect: []string{
+				"k8s.io/kubernetes/runtime.Object",
+				"k8s.io/kubernetes/runtime.List",
+			},
+		},
+		{
+			comments: []string{
+				"+bili:deepcopy-gen:interfaces=k8s.io/kubernetes/runtime.Object",
+				"+bili:deepcopy-gen:interfaces=k8s.io/kubernetes/runtime.Object",
+			},
+			expect: []string{
+				"k8s.io/kubernetes/runtime.Object",
+				"k8s.io/kubernetes/runtime.Object",
+			},
+		},
+	}
+
+	for i, tc := range testCases {
+		r := extractInterfacesTag(tc.comments)
+		if r == nil && tc.expect != nil {
+			t.Errorf("case[%d]: expected non-nil", i)
+		}
+		if r != nil && tc.expect == nil {
+			t.Errorf("case[%d]: expected nil, got %v", i, r)
+		}
+		if r != nil && !reflect.DeepEqual(r, tc.expect) {
+			t.Errorf("case[%d]: expected %v, got %v", i, tc.expect, r)
+		}
+	}
+}

app/tool/gengo/cmd/deepcopy-gen/main.go

@@ -0,0 +1,72 @@
+// deepcopy-gen is a tool for auto-generating DeepCopy functions.
+//
+// Given a list of input directories, it will generate DeepCopy and DeepCopyInto
+// methods that efficiently perform a full deep-copy of each type. If these
+// already exist (are predefined by the developer), they are used instead of
+// generating new ones.
+//
+// If interfaces are referenced in types, it is expected that corresponding
+// DeepCopyInterfaceName methods exist, e.g. DeepCopyObject for runtime.Object.
+// These can be predefined by the developer or generated through tags, see below.
+// They must be added to the interfaces themselves manually, e.g.
+//   type Object interface {
+//     ...
+//     DeepCopyObject() Object
+//   }
+//
+// All generation is governed by comment tags in the source.  Any package may
+// request DeepCopy generation by including a comment in the file-comments of
+// one file, of the form:
+//   // +bili:deepcopy-gen=package
+//
+// DeepCopy functions can be generated for individual types, rather than the
+// entire package by specifying a comment on the type definion of the form:
+//   // +bili:deepcopy-gen=true
+//
+// When generating for a whole package, individual types may opt out of
+// DeepCopy generation by specifying a comment on the type definition of the form:
+//   // +bili:deepcopy-gen=false
+//
+// Additional DeepCopyInterfaceName methods can be generated by sepcifying a
+// comment on the type definition of the form:
+//   // +bili:deepcopy-gen:interfaces=k8s.io/kubernetes/runtime.Object,k8s.io/kubernetes/runtime.List
+// This leads to the generation of DeepCopyObject and DeepCopyList with the given
+// interfaces as return types. We say that the tagged type implements deepcopy for the
+// interfaces.
+//
+// The deepcopy funcs for interfaces using "+bili:deepcopy-gen:interfaces" use the pointer
+// of the type as receiver. For those special cases where the non-pointer object should
+// implement the interface, this can be done with:
+//   // +bili:deepcopy-gen:nonpointer-interfaces=true
+package main
+
+import (
+	"flag"
+
+	"go-common/app/tool/gengo/args"
+	"go-common/app/tool/gengo/cmd/deepcopy-gen/generators"
+
+	"github.com/golang/glog"
+)
+
+func main() {
+	arguments := args.Default()
+
+	// Override defaults.
+	arguments.OutputFileBaseName = "deepcopy_generated"
+
+	// Custom args.
+	customArgs := &generators.CustomArgs{}
+	flag.CommandLine.Var(&customArgs.BoundingDirs, "bounding-dirs", "Comma-separated list of import paths which bound the types for which deep-copies will be generated.")
+	arguments.CustomArgs = customArgs
+
+	// Run it.
+	if err := arguments.Execute(
+		generators.NameSystems(),
+		generators.DefaultNameSystem(),
+		generators.Packages,
+	); err != nil {
+		glog.Fatalf("Error: %v", err)
+	}
+	glog.V(2).Info("Completed successfully.")
+}

app/tool/gengo/cmd/deepcopy-gen/sets/BUILD

@@ -0,0 +1,28 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["string.go"],
+    importpath = "go-common/app/tool/gengo/cmd/deepcopy-gen/sets",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/tool/gengo/cmd/deepcopy-gen/sets/string.go

@@ -0,0 +1,187 @@
+package sets
+
+import (
+	"reflect"
+	"sort"
+)
+
+type Empty struct{}
+
+// sets.String is a set of strings, implemented via map[string]struct{} for minimal memory consumption.
+type String map[string]Empty
+
+// NewString creates a String from a list of values.
+func NewString(items ...string) String {
+	ss := String{}
+	ss.Insert(items...)
+	return ss
+}
+
+// StringKeySet creates a String from a keys of a map[string](? extends interface{}).
+// If the value passed in is not actually a map, this will panic.
+func StringKeySet(theMap interface{}) String {
+	v := reflect.ValueOf(theMap)
+	ret := String{}
+
+	for _, keyValue := range v.MapKeys() {
+		ret.Insert(keyValue.Interface().(string))
+	}
+	return ret
+}
+
+// Insert adds items to the set.
+func (s String) Insert(items ...string) {
+	for _, item := range items {
+		s[item] = Empty{}
+	}
+}
+
+// Delete removes all items from the set.
+func (s String) Delete(items ...string) {
+	for _, item := range items {
+		delete(s, item)
+	}
+}
+
+// Has returns true if and only if item is contained in the set.
+func (s String) Has(item string) bool {
+	_, contained := s[item]
+	return contained
+}
+
+// HasAll returns true if and only if all items are contained in the set.
+func (s String) HasAll(items ...string) bool {
+	for _, item := range items {
+		if !s.Has(item) {
+			return false
+		}
+	}
+	return true
+}
+
+// HasAny returns true if any items are contained in the set.
+func (s String) HasAny(items ...string) bool {
+	for _, item := range items {
+		if s.Has(item) {
+			return true
+		}
+	}
+	return false
+}
+
+// Difference returns a set of objects that are not in s2
+// For example:
+// s1 = {a1, a2, a3}
+// s2 = {a1, a2, a4, a5}
+// s1.Difference(s2) = {a3}
+// s2.Difference(s1) = {a4, a5}
+func (s String) Difference(s2 String) String {
+	result := NewString()
+	for key := range s {
+		if !s2.Has(key) {
+			result.Insert(key)
+		}
+	}
+	return result
+}
+
+// Union returns a new set which includes items in either s1 or s2.
+// For example:
+// s1 = {a1, a2}
+// s2 = {a3, a4}
+// s1.Union(s2) = {a1, a2, a3, a4}
+// s2.Union(s1) = {a1, a2, a3, a4}
+func (s1 String) Union(s2 String) String {
+	result := NewString()
+	for key := range s1 {
+		result.Insert(key)
+	}
+	for key := range s2 {
+		result.Insert(key)
+	}
+	return result
+}
+
+// Intersection returns a new set which includes the item in BOTH s1 and s2
+// For example:
+// s1 = {a1, a2}
+// s2 = {a2, a3}
+// s1.Intersection(s2) = {a2}
+func (s1 String) Intersection(s2 String) String {
+	var walk, other String
+	result := NewString()
+	if s1.Len() < s2.Len() {
+		walk = s1
+		other = s2
+	} else {
+		walk = s2
+		other = s1
+	}
+	for key := range walk {
+		if other.Has(key) {
+			result.Insert(key)
+		}
+	}
+	return result
+}
+
+// IsSuperset returns true if and only if s1 is a superset of s2.
+func (s1 String) IsSuperset(s2 String) bool {
+	for item := range s2 {
+		if !s1.Has(item) {
+			return false
+		}
+	}
+	return true
+}
+
+// Equal returns true if and only if s1 is equal (as a set) to s2.
+// Two sets are equal if their membership is identical.
+// (In practice, this means same elements, order doesn't matter)
+func (s1 String) Equal(s2 String) bool {
+	return len(s1) == len(s2) && s1.IsSuperset(s2)
+}
+
+type sortableSliceOfString []string
+
+func (s sortableSliceOfString) Len() int           { return len(s) }
+func (s sortableSliceOfString) Less(i, j int) bool { return lessString(s[i], s[j]) }
+func (s sortableSliceOfString) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// List returns the contents as a sorted string slice.
+func (s String) List() []string {
+	res := make(sortableSliceOfString, 0, len(s))
+	for key := range s {
+		res = append(res, key)
+	}
+	sort.Sort(res)
+	return []string(res)
+}
+
+// UnsortedList returns the slice with contents in random order.
+func (s String) UnsortedList() []string {
+	res := make([]string, 0, len(s))
+	for key := range s {
+		res = append(res, key)
+	}
+	return res
+}
+
+// Returns a single element from the set.
+func (s String) PopAny() (string, bool) {
+	for key := range s {
+		s.Delete(key)
+		return key, true
+	}
+	var zeroValue string
+	return zeroValue, false
+}
+
+// Len returns the size of the set.
+func (s String) Len() int {
+	return len(s)
+}
+
+func lessString(lhs, rhs string) bool {
+	return lhs < rhs
+}