Elia Battiston | be9edc1 | 2022-03-09 11:35:58 +0100 | [diff] [blame^] | 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 | |
| 5 | package impl |
| 6 | |
| 7 | import ( |
| 8 | "reflect" |
| 9 | |
| 10 | "google.golang.org/protobuf/internal/descopts" |
| 11 | "google.golang.org/protobuf/internal/encoding/messageset" |
| 12 | ptag "google.golang.org/protobuf/internal/encoding/tag" |
| 13 | "google.golang.org/protobuf/internal/filedesc" |
| 14 | "google.golang.org/protobuf/internal/pragma" |
| 15 | pref "google.golang.org/protobuf/reflect/protoreflect" |
| 16 | preg "google.golang.org/protobuf/reflect/protoregistry" |
| 17 | piface "google.golang.org/protobuf/runtime/protoiface" |
| 18 | ) |
| 19 | |
| 20 | func (xi *ExtensionInfo) initToLegacy() { |
| 21 | xd := xi.desc |
| 22 | var parent piface.MessageV1 |
| 23 | messageName := xd.ContainingMessage().FullName() |
| 24 | if mt, _ := preg.GlobalTypes.FindMessageByName(messageName); mt != nil { |
| 25 | // Create a new parent message and unwrap it if possible. |
| 26 | mv := mt.New().Interface() |
| 27 | t := reflect.TypeOf(mv) |
| 28 | if mv, ok := mv.(unwrapper); ok { |
| 29 | t = reflect.TypeOf(mv.protoUnwrap()) |
| 30 | } |
| 31 | |
| 32 | // Check whether the message implements the legacy v1 Message interface. |
| 33 | mz := reflect.Zero(t).Interface() |
| 34 | if mz, ok := mz.(piface.MessageV1); ok { |
| 35 | parent = mz |
| 36 | } |
| 37 | } |
| 38 | |
| 39 | // Determine the v1 extension type, which is unfortunately not the same as |
| 40 | // the v2 ExtensionType.GoType. |
| 41 | extType := xi.goType |
| 42 | switch extType.Kind() { |
| 43 | case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String: |
| 44 | extType = reflect.PtrTo(extType) // T -> *T for singular scalar fields |
| 45 | } |
| 46 | |
| 47 | // Reconstruct the legacy enum full name. |
| 48 | var enumName string |
| 49 | if xd.Kind() == pref.EnumKind { |
| 50 | enumName = legacyEnumName(xd.Enum()) |
| 51 | } |
| 52 | |
| 53 | // Derive the proto file that the extension was declared within. |
| 54 | var filename string |
| 55 | if fd := xd.ParentFile(); fd != nil { |
| 56 | filename = fd.Path() |
| 57 | } |
| 58 | |
| 59 | // For MessageSet extensions, the name used is the parent message. |
| 60 | name := xd.FullName() |
| 61 | if messageset.IsMessageSetExtension(xd) { |
| 62 | name = name.Parent() |
| 63 | } |
| 64 | |
| 65 | xi.ExtendedType = parent |
| 66 | xi.ExtensionType = reflect.Zero(extType).Interface() |
| 67 | xi.Field = int32(xd.Number()) |
| 68 | xi.Name = string(name) |
| 69 | xi.Tag = ptag.Marshal(xd, enumName) |
| 70 | xi.Filename = filename |
| 71 | } |
| 72 | |
| 73 | // initFromLegacy initializes an ExtensionInfo from |
| 74 | // the contents of the deprecated exported fields of the type. |
| 75 | func (xi *ExtensionInfo) initFromLegacy() { |
| 76 | // The v1 API returns "type incomplete" descriptors where only the |
| 77 | // field number is specified. In such a case, use a placeholder. |
| 78 | if xi.ExtendedType == nil || xi.ExtensionType == nil { |
| 79 | xd := placeholderExtension{ |
| 80 | name: pref.FullName(xi.Name), |
| 81 | number: pref.FieldNumber(xi.Field), |
| 82 | } |
| 83 | xi.desc = extensionTypeDescriptor{xd, xi} |
| 84 | return |
| 85 | } |
| 86 | |
| 87 | // Resolve enum or message dependencies. |
| 88 | var ed pref.EnumDescriptor |
| 89 | var md pref.MessageDescriptor |
| 90 | t := reflect.TypeOf(xi.ExtensionType) |
| 91 | isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct |
| 92 | isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 |
| 93 | if isOptional || isRepeated { |
| 94 | t = t.Elem() |
| 95 | } |
| 96 | switch v := reflect.Zero(t).Interface().(type) { |
| 97 | case pref.Enum: |
| 98 | ed = v.Descriptor() |
| 99 | case enumV1: |
| 100 | ed = LegacyLoadEnumDesc(t) |
| 101 | case pref.ProtoMessage: |
| 102 | md = v.ProtoReflect().Descriptor() |
| 103 | case messageV1: |
| 104 | md = LegacyLoadMessageDesc(t) |
| 105 | } |
| 106 | |
| 107 | // Derive basic field information from the struct tag. |
| 108 | var evs pref.EnumValueDescriptors |
| 109 | if ed != nil { |
| 110 | evs = ed.Values() |
| 111 | } |
| 112 | fd := ptag.Unmarshal(xi.Tag, t, evs).(*filedesc.Field) |
| 113 | |
| 114 | // Construct a v2 ExtensionType. |
| 115 | xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)} |
| 116 | xd.L0.ParentFile = filedesc.SurrogateProto2 |
| 117 | xd.L0.FullName = pref.FullName(xi.Name) |
| 118 | xd.L1.Number = pref.FieldNumber(xi.Field) |
| 119 | xd.L1.Cardinality = fd.L1.Cardinality |
| 120 | xd.L1.Kind = fd.L1.Kind |
| 121 | xd.L2.IsPacked = fd.L1.IsPacked |
| 122 | xd.L2.Default = fd.L1.Default |
| 123 | xd.L1.Extendee = Export{}.MessageDescriptorOf(xi.ExtendedType) |
| 124 | xd.L2.Enum = ed |
| 125 | xd.L2.Message = md |
| 126 | |
| 127 | // Derive real extension field name for MessageSets. |
| 128 | if messageset.IsMessageSet(xd.L1.Extendee) && md.FullName() == xd.L0.FullName { |
| 129 | xd.L0.FullName = xd.L0.FullName.Append(messageset.ExtensionName) |
| 130 | } |
| 131 | |
| 132 | tt := reflect.TypeOf(xi.ExtensionType) |
| 133 | if isOptional { |
| 134 | tt = tt.Elem() |
| 135 | } |
| 136 | xi.goType = tt |
| 137 | xi.desc = extensionTypeDescriptor{xd, xi} |
| 138 | } |
| 139 | |
| 140 | type placeholderExtension struct { |
| 141 | name pref.FullName |
| 142 | number pref.FieldNumber |
| 143 | } |
| 144 | |
| 145 | func (x placeholderExtension) ParentFile() pref.FileDescriptor { return nil } |
| 146 | func (x placeholderExtension) Parent() pref.Descriptor { return nil } |
| 147 | func (x placeholderExtension) Index() int { return 0 } |
| 148 | func (x placeholderExtension) Syntax() pref.Syntax { return 0 } |
| 149 | func (x placeholderExtension) Name() pref.Name { return x.name.Name() } |
| 150 | func (x placeholderExtension) FullName() pref.FullName { return x.name } |
| 151 | func (x placeholderExtension) IsPlaceholder() bool { return true } |
| 152 | func (x placeholderExtension) Options() pref.ProtoMessage { return descopts.Field } |
| 153 | func (x placeholderExtension) Number() pref.FieldNumber { return x.number } |
| 154 | func (x placeholderExtension) Cardinality() pref.Cardinality { return 0 } |
| 155 | func (x placeholderExtension) Kind() pref.Kind { return 0 } |
| 156 | func (x placeholderExtension) HasJSONName() bool { return false } |
| 157 | func (x placeholderExtension) JSONName() string { return "[" + string(x.name) + "]" } |
| 158 | func (x placeholderExtension) TextName() string { return "[" + string(x.name) + "]" } |
| 159 | func (x placeholderExtension) HasPresence() bool { return false } |
| 160 | func (x placeholderExtension) HasOptionalKeyword() bool { return false } |
| 161 | func (x placeholderExtension) IsExtension() bool { return true } |
| 162 | func (x placeholderExtension) IsWeak() bool { return false } |
| 163 | func (x placeholderExtension) IsPacked() bool { return false } |
| 164 | func (x placeholderExtension) IsList() bool { return false } |
| 165 | func (x placeholderExtension) IsMap() bool { return false } |
| 166 | func (x placeholderExtension) MapKey() pref.FieldDescriptor { return nil } |
| 167 | func (x placeholderExtension) MapValue() pref.FieldDescriptor { return nil } |
| 168 | func (x placeholderExtension) HasDefault() bool { return false } |
| 169 | func (x placeholderExtension) Default() pref.Value { return pref.Value{} } |
| 170 | func (x placeholderExtension) DefaultEnumValue() pref.EnumValueDescriptor { return nil } |
| 171 | func (x placeholderExtension) ContainingOneof() pref.OneofDescriptor { return nil } |
| 172 | func (x placeholderExtension) ContainingMessage() pref.MessageDescriptor { return nil } |
| 173 | func (x placeholderExtension) Enum() pref.EnumDescriptor { return nil } |
| 174 | func (x placeholderExtension) Message() pref.MessageDescriptor { return nil } |
| 175 | func (x placeholderExtension) ProtoType(pref.FieldDescriptor) { return } |
| 176 | func (x placeholderExtension) ProtoInternal(pragma.DoNotImplement) { return } |