message_reflect.go

Documentation: google.golang.org/protobuf/internal/impl

     1  // Copyright 2019 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  	"fmt"
     9  	"reflect"
    10  
    11  	"google.golang.org/protobuf/internal/detrand"
    12  	"google.golang.org/protobuf/internal/pragma"
    13  	"google.golang.org/protobuf/reflect/protoreflect"
    14  )
    15  
    16  type reflectMessageInfo struct {
    17  	fields map[protoreflect.FieldNumber]*fieldInfo
    18  	oneofs map[protoreflect.Name]*oneofInfo
    19  
    20  	// fieldTypes contains the zero value of an enum or message field.
    21  	// For lists, it contains the element type.
    22  	// For maps, it contains the entry value type.
    23  	fieldTypes map[protoreflect.FieldNumber]interface{}
    24  
    25  	// denseFields is a subset of fields where:
    26  	//	0 < fieldDesc.Number() < len(denseFields)
    27  	// It provides faster access to the fieldInfo, but may be incomplete.
    28  	denseFields []*fieldInfo
    29  
    30  	// rangeInfos is a list of all fields (not belonging to a oneof) and oneofs.
    31  	rangeInfos []interface{} // either *fieldInfo or *oneofInfo
    32  
    33  	getUnknown   func(pointer) protoreflect.RawFields
    34  	setUnknown   func(pointer, protoreflect.RawFields)
    35  	extensionMap func(pointer) *extensionMap
    36  
    37  	nilMessage atomicNilMessage
    38  }
    39  
    40  // makeReflectFuncs generates the set of functions to support reflection.
    41  func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
    42  	mi.makeKnownFieldsFunc(si)
    43  	mi.makeUnknownFieldsFunc(t, si)
    44  	mi.makeExtensionFieldsFunc(t, si)
    45  	mi.makeFieldTypes(si)
    46  }
    47  
    48  // makeKnownFieldsFunc generates functions for operations that can be performed
    49  // on each protobuf message field. It takes in a reflect.Type representing the
    50  // Go struct and matches message fields with struct fields.
    51  //
    52  // This code assumes that the struct is well-formed and panics if there are
    53  // any discrepancies.
    54  func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
    55  	mi.fields = map[protoreflect.FieldNumber]*fieldInfo{}
    56  	md := mi.Desc
    57  	fds := md.Fields()
    58  	for i := 0; i < fds.Len(); i++ {
    59  		fd := fds.Get(i)
    60  		fs := si.fieldsByNumber[fd.Number()]
    61  		isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
    62  		if isOneof {
    63  			fs = si.oneofsByName[fd.ContainingOneof().Name()]
    64  		}
    65  		var fi fieldInfo
    66  		switch {
    67  		case fs.Type == nil:
    68  			fi = fieldInfoForMissing(fd) // never occurs for officially generated message types
    69  		case isOneof:
    70  			fi = fieldInfoForOneof(fd, fs, mi.Exporter, si.oneofWrappersByNumber[fd.Number()])
    71  		case fd.IsMap():
    72  			fi = fieldInfoForMap(fd, fs, mi.Exporter)
    73  		case fd.IsList():
    74  			fi = fieldInfoForList(fd, fs, mi.Exporter)
    75  		case fd.IsWeak():
    76  			fi = fieldInfoForWeakMessage(fd, si.weakOffset)
    77  		case fd.Message() != nil:
    78  			fi = fieldInfoForMessage(fd, fs, mi.Exporter)
    79  		default:
    80  			fi = fieldInfoForScalar(fd, fs, mi.Exporter)
    81  		}
    82  		mi.fields[fd.Number()] = &fi
    83  	}
    84  
    85  	mi.oneofs = map[protoreflect.Name]*oneofInfo{}
    86  	for i := 0; i < md.Oneofs().Len(); i++ {
    87  		od := md.Oneofs().Get(i)
    88  		mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter)
    89  	}
    90  
    91  	mi.denseFields = make([]*fieldInfo, fds.Len()*2)
    92  	for i := 0; i < fds.Len(); i++ {
    93  		if fd := fds.Get(i); int(fd.Number()) < len(mi.denseFields) {
    94  			mi.denseFields[fd.Number()] = mi.fields[fd.Number()]
    95  		}
    96  	}
    97  
    98  	for i := 0; i < fds.Len(); {
    99  		fd := fds.Get(i)
   100  		if od := fd.ContainingOneof(); od != nil && !od.IsSynthetic() {
   101  			mi.rangeInfos = append(mi.rangeInfos, mi.oneofs[od.Name()])
   102  			i += od.Fields().Len()
   103  		} else {
   104  			mi.rangeInfos = append(mi.rangeInfos, mi.fields[fd.Number()])
   105  			i++
   106  		}
   107  	}
   108  
   109  	// Introduce instability to iteration order, but keep it deterministic.
   110  	if len(mi.rangeInfos) > 1 && detrand.Bool() {
   111  		i := detrand.Intn(len(mi.rangeInfos) - 1)
   112  		mi.rangeInfos[i], mi.rangeInfos[i+1] = mi.rangeInfos[i+1], mi.rangeInfos[i]
   113  	}
   114  }
   115  
   116  func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
   117  	switch {
   118  	case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsAType:
   119  		// Handle as []byte.
   120  		mi.getUnknown = func(p pointer) protoreflect.RawFields {
   121  			if p.IsNil() {
   122  				return nil
   123  			}
   124  			return *p.Apply(mi.unknownOffset).Bytes()
   125  		}
   126  		mi.setUnknown = func(p pointer, b protoreflect.RawFields) {
   127  			if p.IsNil() {
   128  				panic("invalid SetUnknown on nil Message")
   129  			}
   130  			*p.Apply(mi.unknownOffset).Bytes() = b
   131  		}
   132  	case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsBType:
   133  		// Handle as *[]byte.
   134  		mi.getUnknown = func(p pointer) protoreflect.RawFields {
   135  			if p.IsNil() {
   136  				return nil
   137  			}
   138  			bp := p.Apply(mi.unknownOffset).BytesPtr()
   139  			if *bp == nil {
   140  				return nil
   141  			}
   142  			return **bp
   143  		}
   144  		mi.setUnknown = func(p pointer, b protoreflect.RawFields) {
   145  			if p.IsNil() {
   146  				panic("invalid SetUnknown on nil Message")
   147  			}
   148  			bp := p.Apply(mi.unknownOffset).BytesPtr()
   149  			if *bp == nil {
   150  				*bp = new([]byte)
   151  			}
   152  			**bp = b
   153  		}
   154  	default:
   155  		mi.getUnknown = func(pointer) protoreflect.RawFields {
   156  			return nil
   157  		}
   158  		mi.setUnknown = func(p pointer, _ protoreflect.RawFields) {
   159  			if p.IsNil() {
   160  				panic("invalid SetUnknown on nil Message")
   161  			}
   162  		}
   163  	}
   164  }
   165  
   166  func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
   167  	if si.extensionOffset.IsValid() {
   168  		mi.extensionMap = func(p pointer) *extensionMap {
   169  			if p.IsNil() {
   170  				return (*extensionMap)(nil)
   171  			}
   172  			v := p.Apply(si.extensionOffset).AsValueOf(extensionFieldsType)
   173  			return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))
   174  		}
   175  	} else {
   176  		mi.extensionMap = func(pointer) *extensionMap {
   177  			return (*extensionMap)(nil)
   178  		}
   179  	}
   180  }
   181  func (mi *MessageInfo) makeFieldTypes(si structInfo) {
   182  	md := mi.Desc
   183  	fds := md.Fields()
   184  	for i := 0; i < fds.Len(); i++ {
   185  		var ft reflect.Type
   186  		fd := fds.Get(i)
   187  		fs := si.fieldsByNumber[fd.Number()]
   188  		isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
   189  		if isOneof {
   190  			fs = si.oneofsByName[fd.ContainingOneof().Name()]
   191  		}
   192  		var isMessage bool
   193  		switch {
   194  		case fs.Type == nil:
   195  			continue // never occurs for officially generated message types
   196  		case isOneof:
   197  			if fd.Enum() != nil || fd.Message() != nil {
   198  				ft = si.oneofWrappersByNumber[fd.Number()].Field(0).Type
   199  			}
   200  		case fd.IsMap():
   201  			if fd.MapValue().Enum() != nil || fd.MapValue().Message() != nil {
   202  				ft = fs.Type.Elem()
   203  			}
   204  			isMessage = fd.MapValue().Message() != nil
   205  		case fd.IsList():
   206  			if fd.Enum() != nil || fd.Message() != nil {
   207  				ft = fs.Type.Elem()
   208  			}
   209  			isMessage = fd.Message() != nil
   210  		case fd.Enum() != nil:
   211  			ft = fs.Type
   212  			if fd.HasPresence() && ft.Kind() == reflect.Ptr {
   213  				ft = ft.Elem()
   214  			}
   215  		case fd.Message() != nil:
   216  			ft = fs.Type
   217  			if fd.IsWeak() {
   218  				ft = nil
   219  			}
   220  			isMessage = true
   221  		}
   222  		if isMessage && ft != nil && ft.Kind() != reflect.Ptr {
   223  			ft = reflect.PtrTo(ft) // never occurs for officially generated message types
   224  		}
   225  		if ft != nil {
   226  			if mi.fieldTypes == nil {
   227  				mi.fieldTypes = make(map[protoreflect.FieldNumber]interface{})
   228  			}
   229  			mi.fieldTypes[fd.Number()] = reflect.Zero(ft).Interface()
   230  		}
   231  	}
   232  }
   233  
   234  type extensionMap map[int32]ExtensionField
   235  
   236  func (m *extensionMap) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
   237  	if m != nil {
   238  		for _, x := range *m {
   239  			xd := x.Type().TypeDescriptor()
   240  			v := x.Value()
   241  			if xd.IsList() && v.List().Len() == 0 {
   242  				continue
   243  			}
   244  			if !f(xd, v) {
   245  				return
   246  			}
   247  		}
   248  	}
   249  }
   250  func (m *extensionMap) Has(xd protoreflect.ExtensionTypeDescriptor) (ok bool) {
   251  	if m == nil {
   252  		return false
   253  	}
   254  	x, ok := (*m)[int32(xd.Number())]
   255  	if !ok {
   256  		return false
   257  	}
   258  	switch {
   259  	case xd.IsList():
   260  		return x.Value().List().Len() > 0
   261  	case xd.IsMap():
   262  		return x.Value().Map().Len() > 0
   263  	}
   264  	return true
   265  }
   266  func (m *extensionMap) Clear(xd protoreflect.ExtensionTypeDescriptor) {
   267  	delete(*m, int32(xd.Number()))
   268  }
   269  func (m *extensionMap) Get(xd protoreflect.ExtensionTypeDescriptor) protoreflect.Value {
   270  	if m != nil {
   271  		if x, ok := (*m)[int32(xd.Number())]; ok {
   272  			return x.Value()
   273  		}
   274  	}
   275  	return xd.Type().Zero()
   276  }
   277  func (m *extensionMap) Set(xd protoreflect.ExtensionTypeDescriptor, v protoreflect.Value) {
   278  	xt := xd.Type()
   279  	isValid := true
   280  	switch {
   281  	case !xt.IsValidValue(v):
   282  		isValid = false
   283  	case xd.IsList():
   284  		isValid = v.List().IsValid()
   285  	case xd.IsMap():
   286  		isValid = v.Map().IsValid()
   287  	case xd.Message() != nil:
   288  		isValid = v.Message().IsValid()
   289  	}
   290  	if !isValid {
   291  		panic(fmt.Sprintf("%v: assigning invalid value", xd.FullName()))
   292  	}
   293  
   294  	if *m == nil {
   295  		*m = make(map[int32]ExtensionField)
   296  	}
   297  	var x ExtensionField
   298  	x.Set(xt, v)
   299  	(*m)[int32(xd.Number())] = x
   300  }
   301  func (m *extensionMap) Mutable(xd protoreflect.ExtensionTypeDescriptor) protoreflect.Value {
   302  	if xd.Kind() != protoreflect.MessageKind && xd.Kind() != protoreflect.GroupKind && !xd.IsList() && !xd.IsMap() {
   303  		panic("invalid Mutable on field with non-composite type")
   304  	}
   305  	if x, ok := (*m)[int32(xd.Number())]; ok {
   306  		return x.Value()
   307  	}
   308  	v := xd.Type().New()
   309  	m.Set(xd, v)
   310  	return v
   311  }
   312  
   313  // MessageState is a data structure that is nested as the first field in a
   314  // concrete message. It provides a way to implement the ProtoReflect method
   315  // in an allocation-free way without needing to have a shadow Go type generated
   316  // for every message type. This technique only works using unsafe.
   317  //
   318  // Example generated code:
   319  //
   320  //	type M struct {
   321  //		state protoimpl.MessageState
   322  //
   323  //		Field1 int32
   324  //		Field2 string
   325  //		Field3 *BarMessage
   326  //		...
   327  //	}
   328  //
   329  //	func (m *M) ProtoReflect() protoreflect.Message {
   330  //		mi := &file_fizz_buzz_proto_msgInfos[5]
   331  //		if protoimpl.UnsafeEnabled && m != nil {
   332  //			ms := protoimpl.X.MessageStateOf(Pointer(m))
   333  //			if ms.LoadMessageInfo() == nil {
   334  //				ms.StoreMessageInfo(mi)
   335  //			}
   336  //			return ms
   337  //		}
   338  //		return mi.MessageOf(m)
   339  //	}
   340  //
   341  // The MessageState type holds a *MessageInfo, which must be atomically set to
   342  // the message info associated with a given message instance.
   343  // By unsafely converting a *M into a *MessageState, the MessageState object
   344  // has access to all the information needed to implement protobuf reflection.
   345  // It has access to the message info as its first field, and a pointer to the
   346  // MessageState is identical to a pointer to the concrete message value.
   347  //
   348  // Requirements:
   349  //   - The type M must implement protoreflect.ProtoMessage.
   350  //   - The address of m must not be nil.
   351  //   - The address of m and the address of m.state must be equal,
   352  //     even though they are different Go types.
   353  type MessageState struct {
   354  	pragma.NoUnkeyedLiterals
   355  	pragma.DoNotCompare
   356  	pragma.DoNotCopy
   357  
   358  	atomicMessageInfo *MessageInfo
   359  }
   360  
   361  type messageState MessageState
   362  
   363  var (
   364  	_ protoreflect.Message = (*messageState)(nil)
   365  	_ unwrapper            = (*messageState)(nil)
   366  )
   367  
   368  // messageDataType is a tuple of a pointer to the message data and
   369  // a pointer to the message type. It is a generalized way of providing a
   370  // reflective view over a message instance. The disadvantage of this approach
   371  // is the need to allocate this tuple of 16B.
   372  type messageDataType struct {
   373  	p  pointer
   374  	mi *MessageInfo
   375  }
   376  
   377  type (
   378  	messageReflectWrapper messageDataType
   379  	messageIfaceWrapper   messageDataType
   380  )
   381  
   382  var (
   383  	_ protoreflect.Message      = (*messageReflectWrapper)(nil)
   384  	_ unwrapper                 = (*messageReflectWrapper)(nil)
   385  	_ protoreflect.ProtoMessage = (*messageIfaceWrapper)(nil)
   386  	_ unwrapper                 = (*messageIfaceWrapper)(nil)
   387  )
   388  
   389  // MessageOf returns a reflective view over a message. The input must be a
   390  // pointer to a named Go struct. If the provided type has a ProtoReflect method,
   391  // it must be implemented by calling this method.
   392  func (mi *MessageInfo) MessageOf(m interface{}) protoreflect.Message {
   393  	if reflect.TypeOf(m) != mi.GoReflectType {
   394  		panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
   395  	}
   396  	p := pointerOfIface(m)
   397  	if p.IsNil() {
   398  		return mi.nilMessage.Init(mi)
   399  	}
   400  	return &messageReflectWrapper{p, mi}
   401  }
   402  
   403  func (m *messageReflectWrapper) pointer() pointer          { return m.p }
   404  func (m *messageReflectWrapper) messageInfo() *MessageInfo { return m.mi }
   405  
   406  // Reset implements the v1 proto.Message.Reset method.
   407  func (m *messageIfaceWrapper) Reset() {
   408  	if mr, ok := m.protoUnwrap().(interface{ Reset() }); ok {
   409  		mr.Reset()
   410  		return
   411  	}
   412  	rv := reflect.ValueOf(m.protoUnwrap())
   413  	if rv.Kind() == reflect.Ptr && !rv.IsNil() {
   414  		rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
   415  	}
   416  }
   417  func (m *messageIfaceWrapper) ProtoReflect() protoreflect.Message {
   418  	return (*messageReflectWrapper)(m)
   419  }
   420  func (m *messageIfaceWrapper) protoUnwrap() interface{} {
   421  	return m.p.AsIfaceOf(m.mi.GoReflectType.Elem())
   422  }
   423  
   424  // checkField verifies that the provided field descriptor is valid.
   425  // Exactly one of the returned values is populated.
   426  func (mi *MessageInfo) checkField(fd protoreflect.FieldDescriptor) (*fieldInfo, protoreflect.ExtensionTypeDescriptor) {
   427  	var fi *fieldInfo
   428  	if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) {
   429  		fi = mi.denseFields[n]
   430  	} else {
   431  		fi = mi.fields[n]
   432  	}
   433  	if fi != nil {
   434  		if fi.fieldDesc != fd {
   435  			if got, want := fd.FullName(), fi.fieldDesc.FullName(); got != want {
   436  				panic(fmt.Sprintf("mismatching field: got %v, want %v", got, want))
   437  			}
   438  			panic(fmt.Sprintf("mismatching field: %v", fd.FullName()))
   439  		}
   440  		return fi, nil
   441  	}
   442  
   443  	if fd.IsExtension() {
   444  		if got, want := fd.ContainingMessage().FullName(), mi.Desc.FullName(); got != want {
   445  			// TODO: Should this be exact containing message descriptor match?
   446  			panic(fmt.Sprintf("extension %v has mismatching containing message: got %v, want %v", fd.FullName(), got, want))
   447  		}
   448  		if !mi.Desc.ExtensionRanges().Has(fd.Number()) {
   449  			panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
   450  		}
   451  		xtd, ok := fd.(protoreflect.ExtensionTypeDescriptor)
   452  		if !ok {
   453  			panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
   454  		}
   455  		return nil, xtd
   456  	}
   457  	panic(fmt.Sprintf("field %v is invalid", fd.FullName()))
   458  }
   459
View as plain text