1// Copyright 2018 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package impl
6
7import (
8 "fmt"
9 "reflect"
10 "strings"
11 "sync"
12
13 "google.golang.org/protobuf/internal/filedesc"
14 "google.golang.org/protobuf/internal/strs"
15 "google.golang.org/protobuf/reflect/protoreflect"
16)
17
18// legacyEnumName returns the name of enums used in legacy code.
19// It is neither the protobuf full name nor the qualified Go name,
20// but rather an odd hybrid of both.
21func legacyEnumName(ed protoreflect.EnumDescriptor) string {
22 var protoPkg string
23 enumName := string(ed.FullName())
24 if fd := ed.ParentFile(); fd != nil {
25 protoPkg = string(fd.Package())
26 enumName = strings.TrimPrefix(enumName, protoPkg+".")
27 }
28 if protoPkg == "" {
29 return strs.GoCamelCase(enumName)
30 }
31 return protoPkg + "." + strs.GoCamelCase(enumName)
32}
33
34// legacyWrapEnum wraps v as a protoreflect.Enum,
35// where v must be a int32 kind and not implement the v2 API already.
36func legacyWrapEnum(v reflect.Value) protoreflect.Enum {
37 et := legacyLoadEnumType(v.Type())
38 return et.New(protoreflect.EnumNumber(v.Int()))
39}
40
41var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
42
43// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
44// where t must be an int32 kind and not implement the v2 API already.
45func legacyLoadEnumType(t reflect.Type) protoreflect.EnumType {
46 // Fast-path: check if a EnumType is cached for this concrete type.
47 if et, ok := legacyEnumTypeCache.Load(t); ok {
48 return et.(protoreflect.EnumType)
49 }
50
51 // Slow-path: derive enum descriptor and initialize EnumType.
52 var et protoreflect.EnumType
53 ed := LegacyLoadEnumDesc(t)
54 et = &legacyEnumType{
55 desc: ed,
56 goType: t,
57 }
58 if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok {
59 return et.(protoreflect.EnumType)
60 }
61 return et
62}
63
64type legacyEnumType struct {
65 desc protoreflect.EnumDescriptor
66 goType reflect.Type
67 m sync.Map // map[protoreflect.EnumNumber]proto.Enum
68}
69
70func (t *legacyEnumType) New(n protoreflect.EnumNumber) protoreflect.Enum {
71 if e, ok := t.m.Load(n); ok {
72 return e.(protoreflect.Enum)
73 }
74 e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType}
75 t.m.Store(n, e)
76 return e
77}
78func (t *legacyEnumType) Descriptor() protoreflect.EnumDescriptor {
79 return t.desc
80}
81
82type legacyEnumWrapper struct {
83 num protoreflect.EnumNumber
84 pbTyp protoreflect.EnumType
85 goTyp reflect.Type
86}
87
88func (e *legacyEnumWrapper) Descriptor() protoreflect.EnumDescriptor {
89 return e.pbTyp.Descriptor()
90}
91func (e *legacyEnumWrapper) Type() protoreflect.EnumType {
92 return e.pbTyp
93}
94func (e *legacyEnumWrapper) Number() protoreflect.EnumNumber {
95 return e.num
96}
97func (e *legacyEnumWrapper) ProtoReflect() protoreflect.Enum {
98 return e
99}
100func (e *legacyEnumWrapper) protoUnwrap() any {
101 v := reflect.New(e.goTyp).Elem()
102 v.SetInt(int64(e.num))
103 return v.Interface()
104}
105
106var (
107 _ protoreflect.Enum = (*legacyEnumWrapper)(nil)
108 _ unwrapper = (*legacyEnumWrapper)(nil)
109)
110
111var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
112
113// LegacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
114// which must be an int32 kind and not implement the v2 API already.
115//
116// This is exported for testing purposes.
117func LegacyLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
118 // Fast-path: check if an EnumDescriptor is cached for this concrete type.
119 if ed, ok := legacyEnumDescCache.Load(t); ok {
120 return ed.(protoreflect.EnumDescriptor)
121 }
122
123 // Slow-path: initialize EnumDescriptor from the raw descriptor.
124 ev := reflect.Zero(t).Interface()
125 if _, ok := ev.(protoreflect.Enum); ok {
126 panic(fmt.Sprintf("%v already implements proto.Enum", t))
127 }
128 edV1, ok := ev.(enumV1)
129 if !ok {
130 return aberrantLoadEnumDesc(t)
131 }
132 b, idxs := edV1.EnumDescriptor()
133
134 var ed protoreflect.EnumDescriptor
135 if len(idxs) == 1 {
136 ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
137 } else {
138 md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
139 for _, i := range idxs[1 : len(idxs)-1] {
140 md = md.Messages().Get(i)
141 }
142 ed = md.Enums().Get(idxs[len(idxs)-1])
143 }
144 if ed, ok := legacyEnumDescCache.LoadOrStore(t, ed); ok {
145 return ed.(protoreflect.EnumDescriptor)
146 }
147 return ed
148}
149
150var aberrantEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
151
152// aberrantLoadEnumDesc returns an EnumDescriptor derived from the Go type,
153// which must not implement protoreflect.Enum or enumV1.
154//
155// If the type does not implement enumV1, then there is no reliable
156// way to derive the original protobuf type information.
157// We are unable to use the global enum registry since it is
158// unfortunately keyed by the protobuf full name, which we also do not know.
159// Thus, this produces some bogus enum descriptor based on the Go type name.
160func aberrantLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
161 // Fast-path: check if an EnumDescriptor is cached for this concrete type.
162 if ed, ok := aberrantEnumDescCache.Load(t); ok {
163 return ed.(protoreflect.EnumDescriptor)
164 }
165
166 // Slow-path: construct a bogus, but unique EnumDescriptor.
167 ed := &filedesc.Enum{L2: new(filedesc.EnumL2)}
168 ed.L0.FullName = AberrantDeriveFullName(t) // e.g., github_com.user.repo.MyEnum
169 ed.L0.ParentFile = filedesc.SurrogateProto3
170 ed.L1.EditionFeatures = ed.L0.ParentFile.L1.EditionFeatures
171 ed.L2.Values.List = append(ed.L2.Values.List, filedesc.EnumValue{})
172
173 // TODO: Use the presence of a UnmarshalJSON method to determine proto2?
174
175 vd := &ed.L2.Values.List[0]
176 vd.L0.FullName = ed.L0.FullName + "_UNKNOWN" // e.g., github_com.user.repo.MyEnum_UNKNOWN
177 vd.L0.ParentFile = ed.L0.ParentFile
178 vd.L0.Parent = ed
179
180 // TODO: We could use the String method to obtain some enum value names by
181 // starting at 0 and print the enum until it produces invalid identifiers.
182 // An exhaustive query is clearly impractical, but can be best-effort.
183
184 if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok {
185 return ed.(protoreflect.EnumDescriptor)
186 }
187 return ed
188}
189
190// AberrantDeriveFullName derives a fully qualified protobuf name for the given Go type
191// The provided name is not guaranteed to be stable nor universally unique.
192// It should be sufficiently unique within a program.
193//
194// This is exported for testing purposes.
195func AberrantDeriveFullName(t reflect.Type) protoreflect.FullName {
196 sanitize := func(r rune) rune {
197 switch {
198 case r == '/':
199 return '.'
200 case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
201 return r
202 default:
203 return '_'
204 }
205 }
206 prefix := strings.Map(sanitize, t.PkgPath())
207 suffix := strings.Map(sanitize, t.Name())
208 if suffix == "" {
209 suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
210 }
211
212 ss := append(strings.Split(prefix, "."), suffix)
213 for i, s := range ss {
214 if s == "" || ('0' <= s[0] && s[0] <= '9') {
215 ss[i] = "x" + s
216 }
217 }
218 return protoreflect.FullName(strings.Join(ss, "."))
219}