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 protoregistry provides data structures to register and lookup 6// protobuf descriptor types. 7// 8// The Files registry contains file descriptors and provides the ability 9// to iterate over the files or lookup a specific descriptor within the files. 10// Files only contains protobuf descriptors and has no understanding of Go 11// type information that may be associated with each descriptor. 12// 13// The Types registry contains descriptor types for which there is a known 14// Go type associated with that descriptor. It provides the ability to iterate 15// over the registered types or lookup a type by name. 16package protoregistry 17 18import ( 19 "fmt" 20 "log" 21 "strings" 22 "sync" 23 24 "google.golang.org/protobuf/internal/encoding/messageset" 25 "google.golang.org/protobuf/internal/errors" 26 "google.golang.org/protobuf/internal/flags" 27 "google.golang.org/protobuf/reflect/protoreflect" 28) 29 30// ignoreConflict reports whether to ignore a registration conflict 31// given the descriptor being registered and the error. 32// It is a variable so that the behavior is easily overridden in another file. 33var ignoreConflict = func(d protoreflect.Descriptor, err error) bool { 34 log.Printf(""+ 35 "WARNING: %v\n"+ 36 "A future release will panic on registration conflicts. See:\n"+ 37 "https://developers.google.com/protocol-buffers/docs/reference/go/faq#namespace-conflict\n"+ 38 "\n", err) 39 return true 40} 41 42var globalMutex sync.RWMutex 43 44// GlobalFiles is a global registry of file descriptors. 45var GlobalFiles *Files = new(Files) 46 47// GlobalTypes is the registry used by default for type lookups 48// unless a local registry is provided by the user. 49var GlobalTypes *Types = new(Types) 50 51// NotFound is a sentinel error value to indicate that the type was not found. 52// 53// Since registry lookup can happen in the critical performance path, resolvers 54// must return this exact error value, not an error wrapping it. 55var NotFound = errors.New("not found") 56 57// Files is a registry for looking up or iterating over files and the 58// descriptors contained within them. 59// The Find and Range methods are safe for concurrent use. 60type Files struct { 61 // The map of descsByName contains: 62 // EnumDescriptor 63 // EnumValueDescriptor 64 // MessageDescriptor 65 // ExtensionDescriptor 66 // ServiceDescriptor 67 // *packageDescriptor 68 // 69 // Note that files are stored as a slice, since a package may contain 70 // multiple files. Only top-level declarations are registered. 71 // Note that enum values are in the top-level since that are in the same 72 // scope as the parent enum. 73 descsByName map[protoreflect.FullName]interface{} 74 filesByPath map[string]protoreflect.FileDescriptor 75} 76 77type packageDescriptor struct { 78 files []protoreflect.FileDescriptor 79} 80 81// RegisterFile registers the provided file descriptor. 82// 83// If any descriptor within the file conflicts with the descriptor of any 84// previously registered file (e.g., two enums with the same full name), 85// then the file is not registered and an error is returned. 86// 87// It is permitted for multiple files to have the same file path. 88func (r *Files) RegisterFile(file protoreflect.FileDescriptor) error { 89 if r == GlobalFiles { 90 globalMutex.Lock() 91 defer globalMutex.Unlock() 92 } 93 if r.descsByName == nil { 94 r.descsByName = map[protoreflect.FullName]interface{}{ 95 "": &packageDescriptor{}, 96 } 97 r.filesByPath = make(map[string]protoreflect.FileDescriptor) 98 } 99 path := file.Path() 100 if prev := r.filesByPath[path]; prev != nil { 101 // TODO: Remove this after some soak-in period after moving these types. 102 var prevPath string 103 const prevModule = "google.golang.org/genproto" 104 const prevVersion = "cb27e3aa (May 26th, 2020)" 105 switch path { 106 case "google/protobuf/field_mask.proto": 107 prevPath = prevModule + "/protobuf/field_mask" 108 case "google/protobuf/api.proto": 109 prevPath = prevModule + "/protobuf/api" 110 case "google/protobuf/type.proto": 111 prevPath = prevModule + "/protobuf/ptype" 112 case "google/protobuf/source_context.proto": 113 prevPath = prevModule + "/protobuf/source_context" 114 } 115 if r == GlobalFiles && prevPath != "" { 116 pkgName := strings.TrimSuffix(strings.TrimPrefix(path, "google/protobuf/"), ".proto") 117 pkgName = strings.Replace(pkgName, "_", "", -1) + "pb" 118 currPath := "google.golang.org/protobuf/types/known/" + pkgName 119 panic(fmt.Sprintf(""+ 120 "duplicate registration of %q\n"+ 121 "\n"+ 122 "The generated definition for this file has moved:\n"+ 123 "\tfrom: %q\n"+ 124 "\tto: %q\n"+ 125 "A dependency on the %q module must\n"+ 126 "be at version %v or higher.\n"+ 127 "\n"+ 128 "Upgrade the dependency by running:\n"+ 129 "\tgo get -u %v\n", 130 path, prevPath, currPath, prevModule, prevVersion, prevPath)) 131 } 132 133 err := errors.New("file %q is already registered", file.Path()) 134 err = amendErrorWithCaller(err, prev, file) 135 if r == GlobalFiles && ignoreConflict(file, err) { 136 err = nil 137 } 138 return err 139 } 140 141 for name := file.Package(); name != ""; name = name.Parent() { 142 switch prev := r.descsByName[name]; prev.(type) { 143 case nil, *packageDescriptor: 144 default: 145 err := errors.New("file %q has a package name conflict over %v", file.Path(), name) 146 err = amendErrorWithCaller(err, prev, file) 147 if r == GlobalFiles && ignoreConflict(file, err) { 148 err = nil 149 } 150 return err 151 } 152 } 153 var err error 154 var hasConflict bool 155 rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) { 156 if prev := r.descsByName[d.FullName()]; prev != nil { 157 hasConflict = true 158 err = errors.New("file %q has a name conflict over %v", file.Path(), d.FullName()) 159 err = amendErrorWithCaller(err, prev, file) 160 if r == GlobalFiles && ignoreConflict(d, err) { 161 err = nil 162 } 163 } 164 }) 165 if hasConflict { 166 return err 167 } 168 169 for name := file.Package(); name != ""; name = name.Parent() { 170 if r.descsByName[name] == nil { 171 r.descsByName[name] = &packageDescriptor{} 172 } 173 } 174 p := r.descsByName[file.Package()].(*packageDescriptor) 175 p.files = append(p.files, file) 176 rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) { 177 r.descsByName[d.FullName()] = d 178 }) 179 r.filesByPath[path] = file 180 return nil 181} 182 183// FindDescriptorByName looks up a descriptor by the full name. 184// 185// This returns (nil, NotFound) if not found. 186func (r *Files) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) { 187 if r == nil { 188 return nil, NotFound 189 } 190 if r == GlobalFiles { 191 globalMutex.RLock() 192 defer globalMutex.RUnlock() 193 } 194 prefix := name 195 suffix := nameSuffix("") 196 for prefix != "" { 197 if d, ok := r.descsByName[prefix]; ok { 198 switch d := d.(type) { 199 case protoreflect.EnumDescriptor: 200 if d.FullName() == name { 201 return d, nil 202 } 203 case protoreflect.EnumValueDescriptor: 204 if d.FullName() == name { 205 return d, nil 206 } 207 case protoreflect.MessageDescriptor: 208 if d.FullName() == name { 209 return d, nil 210 } 211 if d := findDescriptorInMessage(d, suffix); d != nil && d.FullName() == name { 212 return d, nil 213 } 214 case protoreflect.ExtensionDescriptor: 215 if d.FullName() == name { 216 return d, nil 217 } 218 case protoreflect.ServiceDescriptor: 219 if d.FullName() == name { 220 return d, nil 221 } 222 if d := d.Methods().ByName(suffix.Pop()); d != nil && d.FullName() == name { 223 return d, nil 224 } 225 } 226 return nil, NotFound 227 } 228 prefix = prefix.Parent() 229 suffix = nameSuffix(name[len(prefix)+len("."):]) 230 } 231 return nil, NotFound 232} 233 234func findDescriptorInMessage(md protoreflect.MessageDescriptor, suffix nameSuffix) protoreflect.Descriptor { 235 name := suffix.Pop() 236 if suffix == "" { 237 if ed := md.Enums().ByName(name); ed != nil { 238 return ed 239 } 240 for i := md.Enums().Len() - 1; i >= 0; i-- { 241 if vd := md.Enums().Get(i).Values().ByName(name); vd != nil { 242 return vd 243 } 244 } 245 if xd := md.Extensions().ByName(name); xd != nil { 246 return xd 247 } 248 if fd := md.Fields().ByName(name); fd != nil { 249 return fd 250 } 251 if od := md.Oneofs().ByName(name); od != nil { 252 return od 253 } 254 } 255 if md := md.Messages().ByName(name); md != nil { 256 if suffix == "" { 257 return md 258 } 259 return findDescriptorInMessage(md, suffix) 260 } 261 return nil 262} 263 264type nameSuffix string 265 266func (s *nameSuffix) Pop() (name protoreflect.Name) { 267 if i := strings.IndexByte(string(*s), '.'); i >= 0 { 268 name, *s = protoreflect.Name((*s)[:i]), (*s)[i+1:] 269 } else { 270 name, *s = protoreflect.Name((*s)), "" 271 } 272 return name 273} 274 275// FindFileByPath looks up a file by the path. 276// 277// This returns (nil, NotFound) if not found. 278func (r *Files) FindFileByPath(path string) (protoreflect.FileDescriptor, error) { 279 if r == nil { 280 return nil, NotFound 281 } 282 if r == GlobalFiles { 283 globalMutex.RLock() 284 defer globalMutex.RUnlock() 285 } 286 if fd, ok := r.filesByPath[path]; ok { 287 return fd, nil 288 } 289 return nil, NotFound 290} 291 292// NumFiles reports the number of registered files. 293func (r *Files) NumFiles() int { 294 if r == nil { 295 return 0 296 } 297 if r == GlobalFiles { 298 globalMutex.RLock() 299 defer globalMutex.RUnlock() 300 } 301 return len(r.filesByPath) 302} 303 304// RangeFiles iterates over all registered files while f returns true. 305// The iteration order is undefined. 306func (r *Files) RangeFiles(f func(protoreflect.FileDescriptor) bool) { 307 if r == nil { 308 return 309 } 310 if r == GlobalFiles { 311 globalMutex.RLock() 312 defer globalMutex.RUnlock() 313 } 314 for _, file := range r.filesByPath { 315 if !f(file) { 316 return 317 } 318 } 319} 320 321// NumFilesByPackage reports the number of registered files in a proto package. 322func (r *Files) NumFilesByPackage(name protoreflect.FullName) int { 323 if r == nil { 324 return 0 325 } 326 if r == GlobalFiles { 327 globalMutex.RLock() 328 defer globalMutex.RUnlock() 329 } 330 p, ok := r.descsByName[name].(*packageDescriptor) 331 if !ok { 332 return 0 333 } 334 return len(p.files) 335} 336 337// RangeFilesByPackage iterates over all registered files in a given proto package 338// while f returns true. The iteration order is undefined. 339func (r *Files) RangeFilesByPackage(name protoreflect.FullName, f func(protoreflect.FileDescriptor) bool) { 340 if r == nil { 341 return 342 } 343 if r == GlobalFiles { 344 globalMutex.RLock() 345 defer globalMutex.RUnlock() 346 } 347 p, ok := r.descsByName[name].(*packageDescriptor) 348 if !ok { 349 return 350 } 351 for _, file := range p.files { 352 if !f(file) { 353 return 354 } 355 } 356} 357 358// rangeTopLevelDescriptors iterates over all top-level descriptors in a file 359// which will be directly entered into the registry. 360func rangeTopLevelDescriptors(fd protoreflect.FileDescriptor, f func(protoreflect.Descriptor)) { 361 eds := fd.Enums() 362 for i := eds.Len() - 1; i >= 0; i-- { 363 f(eds.Get(i)) 364 vds := eds.Get(i).Values() 365 for i := vds.Len() - 1; i >= 0; i-- { 366 f(vds.Get(i)) 367 } 368 } 369 mds := fd.Messages() 370 for i := mds.Len() - 1; i >= 0; i-- { 371 f(mds.Get(i)) 372 } 373 xds := fd.Extensions() 374 for i := xds.Len() - 1; i >= 0; i-- { 375 f(xds.Get(i)) 376 } 377 sds := fd.Services() 378 for i := sds.Len() - 1; i >= 0; i-- { 379 f(sds.Get(i)) 380 } 381} 382 383// MessageTypeResolver is an interface for looking up messages. 384// 385// A compliant implementation must deterministically return the same type 386// if no error is encountered. 387// 388// The Types type implements this interface. 389type MessageTypeResolver interface { 390 // FindMessageByName looks up a message by its full name. 391 // E.g., "google.protobuf.Any" 392 // 393 // This return (nil, NotFound) if not found. 394 FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) 395 396 // FindMessageByURL looks up a message by a URL identifier. 397 // See documentation on google.protobuf.Any.type_url for the URL format. 398 // 399 // This returns (nil, NotFound) if not found. 400 FindMessageByURL(url string) (protoreflect.MessageType, error) 401} 402 403// ExtensionTypeResolver is an interface for looking up extensions. 404// 405// A compliant implementation must deterministically return the same type 406// if no error is encountered. 407// 408// The Types type implements this interface. 409type ExtensionTypeResolver interface { 410 // FindExtensionByName looks up a extension field by the field's full name. 411 // Note that this is the full name of the field as determined by 412 // where the extension is declared and is unrelated to the full name of the 413 // message being extended. 414 // 415 // This returns (nil, NotFound) if not found. 416 FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) 417 418 // FindExtensionByNumber looks up a extension field by the field number 419 // within some parent message, identified by full name. 420 // 421 // This returns (nil, NotFound) if not found. 422 FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) 423} 424 425var ( 426 _ MessageTypeResolver = (*Types)(nil) 427 _ ExtensionTypeResolver = (*Types)(nil) 428) 429 430// Types is a registry for looking up or iterating over descriptor types. 431// The Find and Range methods are safe for concurrent use. 432type Types struct { 433 typesByName typesByName 434 extensionsByMessage extensionsByMessage 435 436 numEnums int 437 numMessages int 438 numExtensions int 439} 440 441type ( 442 typesByName map[protoreflect.FullName]interface{} 443 extensionsByMessage map[protoreflect.FullName]extensionsByNumber 444 extensionsByNumber map[protoreflect.FieldNumber]protoreflect.ExtensionType 445) 446 447// RegisterMessage registers the provided message type. 448// 449// If a naming conflict occurs, the type is not registered and an error is returned. 450func (r *Types) RegisterMessage(mt protoreflect.MessageType) error { 451 // Under rare circumstances getting the descriptor might recursively 452 // examine the registry, so fetch it before locking. 453 md := mt.Descriptor() 454 455 if r == GlobalTypes { 456 globalMutex.Lock() 457 defer globalMutex.Unlock() 458 } 459 460 if err := r.register("message", md, mt); err != nil { 461 return err 462 } 463 r.numMessages++ 464 return nil 465} 466 467// RegisterEnum registers the provided enum type. 468// 469// If a naming conflict occurs, the type is not registered and an error is returned. 470func (r *Types) RegisterEnum(et protoreflect.EnumType) error { 471 // Under rare circumstances getting the descriptor might recursively 472 // examine the registry, so fetch it before locking. 473 ed := et.Descriptor() 474 475 if r == GlobalTypes { 476 globalMutex.Lock() 477 defer globalMutex.Unlock() 478 } 479 480 if err := r.register("enum", ed, et); err != nil { 481 return err 482 } 483 r.numEnums++ 484 return nil 485} 486 487// RegisterExtension registers the provided extension type. 488// 489// If a naming conflict occurs, the type is not registered and an error is returned. 490func (r *Types) RegisterExtension(xt protoreflect.ExtensionType) error { 491 // Under rare circumstances getting the descriptor might recursively 492 // examine the registry, so fetch it before locking. 493 // 494 // A known case where this can happen: Fetching the TypeDescriptor for a 495 // legacy ExtensionDesc can consult the global registry. 496 xd := xt.TypeDescriptor() 497 498 if r == GlobalTypes { 499 globalMutex.Lock() 500 defer globalMutex.Unlock() 501 } 502 503 field := xd.Number() 504 message := xd.ContainingMessage().FullName() 505 if prev := r.extensionsByMessage[message][field]; prev != nil { 506 err := errors.New("extension number %d is already registered on message %v", field, message) 507 err = amendErrorWithCaller(err, prev, xt) 508 if !(r == GlobalTypes && ignoreConflict(xd, err)) { 509 return err 510 } 511 } 512 513 if err := r.register("extension", xd, xt); err != nil { 514 return err 515 } 516 if r.extensionsByMessage == nil { 517 r.extensionsByMessage = make(extensionsByMessage) 518 } 519 if r.extensionsByMessage[message] == nil { 520 r.extensionsByMessage[message] = make(extensionsByNumber) 521 } 522 r.extensionsByMessage[message][field] = xt 523 r.numExtensions++ 524 return nil 525} 526 527func (r *Types) register(kind string, desc protoreflect.Descriptor, typ interface{}) error { 528 name := desc.FullName() 529 prev := r.typesByName[name] 530 if prev != nil { 531 err := errors.New("%v %v is already registered", kind, name) 532 err = amendErrorWithCaller(err, prev, typ) 533 if !(r == GlobalTypes && ignoreConflict(desc, err)) { 534 return err 535 } 536 } 537 if r.typesByName == nil { 538 r.typesByName = make(typesByName) 539 } 540 r.typesByName[name] = typ 541 return nil 542} 543 544// FindEnumByName looks up an enum by its full name. 545// E.g., "google.protobuf.Field.Kind". 546// 547// This returns (nil, NotFound) if not found. 548func (r *Types) FindEnumByName(enum protoreflect.FullName) (protoreflect.EnumType, error) { 549 if r == nil { 550 return nil, NotFound 551 } 552 if r == GlobalTypes { 553 globalMutex.RLock() 554 defer globalMutex.RUnlock() 555 } 556 if v := r.typesByName[enum]; v != nil { 557 if et, _ := v.(protoreflect.EnumType); et != nil { 558 return et, nil 559 } 560 return nil, errors.New("found wrong type: got %v, want enum", typeName(v)) 561 } 562 return nil, NotFound 563} 564 565// FindMessageByName looks up a message by its full name, 566// e.g. "google.protobuf.Any". 567// 568// This returns (nil, NotFound) if not found. 569func (r *Types) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) { 570 if r == nil { 571 return nil, NotFound 572 } 573 if r == GlobalTypes { 574 globalMutex.RLock() 575 defer globalMutex.RUnlock() 576 } 577 if v := r.typesByName[message]; v != nil { 578 if mt, _ := v.(protoreflect.MessageType); mt != nil { 579 return mt, nil 580 } 581 return nil, errors.New("found wrong type: got %v, want message", typeName(v)) 582 } 583 return nil, NotFound 584} 585 586// FindMessageByURL looks up a message by a URL identifier. 587// See documentation on google.protobuf.Any.type_url for the URL format. 588// 589// This returns (nil, NotFound) if not found. 590func (r *Types) FindMessageByURL(url string) (protoreflect.MessageType, error) { 591 // This function is similar to FindMessageByName but 592 // truncates anything before and including '/' in the URL. 593 if r == nil { 594 return nil, NotFound 595 } 596 if r == GlobalTypes { 597 globalMutex.RLock() 598 defer globalMutex.RUnlock() 599 } 600 message := protoreflect.FullName(url) 601 if i := strings.LastIndexByte(url, '/'); i >= 0 { 602 message = message[i+len("/"):] 603 } 604 605 if v := r.typesByName[message]; v != nil { 606 if mt, _ := v.(protoreflect.MessageType); mt != nil { 607 return mt, nil 608 } 609 return nil, errors.New("found wrong type: got %v, want message", typeName(v)) 610 } 611 return nil, NotFound 612} 613 614// FindExtensionByName looks up a extension field by the field's full name. 615// Note that this is the full name of the field as determined by 616// where the extension is declared and is unrelated to the full name of the 617// message being extended. 618// 619// This returns (nil, NotFound) if not found. 620func (r *Types) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) { 621 if r == nil { 622 return nil, NotFound 623 } 624 if r == GlobalTypes { 625 globalMutex.RLock() 626 defer globalMutex.RUnlock() 627 } 628 if v := r.typesByName[field]; v != nil { 629 if xt, _ := v.(protoreflect.ExtensionType); xt != nil { 630 return xt, nil 631 } 632 633 // MessageSet extensions are special in that the name of the extension 634 // is the name of the message type used to extend the MessageSet. 635 // This naming scheme is used by text and JSON serialization. 636 // 637 // This feature is protected by the ProtoLegacy flag since MessageSets 638 // are a proto1 feature that is long deprecated. 639 if flags.ProtoLegacy { 640 if _, ok := v.(protoreflect.MessageType); ok { 641 field := field.Append(messageset.ExtensionName) 642 if v := r.typesByName[field]; v != nil { 643 if xt, _ := v.(protoreflect.ExtensionType); xt != nil { 644 if messageset.IsMessageSetExtension(xt.TypeDescriptor()) { 645 return xt, nil 646 } 647 } 648 } 649 } 650 } 651 652 return nil, errors.New("found wrong type: got %v, want extension", typeName(v)) 653 } 654 return nil, NotFound 655} 656 657// FindExtensionByNumber looks up a extension field by the field number 658// within some parent message, identified by full name. 659// 660// This returns (nil, NotFound) if not found. 661func (r *Types) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) { 662 if r == nil { 663 return nil, NotFound 664 } 665 if r == GlobalTypes { 666 globalMutex.RLock() 667 defer globalMutex.RUnlock() 668 } 669 if xt, ok := r.extensionsByMessage[message][field]; ok { 670 return xt, nil 671 } 672 return nil, NotFound 673} 674 675// NumEnums reports the number of registered enums. 676func (r *Types) NumEnums() int { 677 if r == nil { 678 return 0 679 } 680 if r == GlobalTypes { 681 globalMutex.RLock() 682 defer globalMutex.RUnlock() 683 } 684 return r.numEnums 685} 686 687// RangeEnums iterates over all registered enums while f returns true. 688// Iteration order is undefined. 689func (r *Types) RangeEnums(f func(protoreflect.EnumType) bool) { 690 if r == nil { 691 return 692 } 693 if r == GlobalTypes { 694 globalMutex.RLock() 695 defer globalMutex.RUnlock() 696 } 697 for _, typ := range r.typesByName { 698 if et, ok := typ.(protoreflect.EnumType); ok { 699 if !f(et) { 700 return 701 } 702 } 703 } 704} 705 706// NumMessages reports the number of registered messages. 707func (r *Types) NumMessages() int { 708 if r == nil { 709 return 0 710 } 711 if r == GlobalTypes { 712 globalMutex.RLock() 713 defer globalMutex.RUnlock() 714 } 715 return r.numMessages 716} 717 718// RangeMessages iterates over all registered messages while f returns true. 719// Iteration order is undefined. 720func (r *Types) RangeMessages(f func(protoreflect.MessageType) bool) { 721 if r == nil { 722 return 723 } 724 if r == GlobalTypes { 725 globalMutex.RLock() 726 defer globalMutex.RUnlock() 727 } 728 for _, typ := range r.typesByName { 729 if mt, ok := typ.(protoreflect.MessageType); ok { 730 if !f(mt) { 731 return 732 } 733 } 734 } 735} 736 737// NumExtensions reports the number of registered extensions. 738func (r *Types) NumExtensions() int { 739 if r == nil { 740 return 0 741 } 742 if r == GlobalTypes { 743 globalMutex.RLock() 744 defer globalMutex.RUnlock() 745 } 746 return r.numExtensions 747} 748 749// RangeExtensions iterates over all registered extensions while f returns true. 750// Iteration order is undefined. 751func (r *Types) RangeExtensions(f func(protoreflect.ExtensionType) bool) { 752 if r == nil { 753 return 754 } 755 if r == GlobalTypes { 756 globalMutex.RLock() 757 defer globalMutex.RUnlock() 758 } 759 for _, typ := range r.typesByName { 760 if xt, ok := typ.(protoreflect.ExtensionType); ok { 761 if !f(xt) { 762 return 763 } 764 } 765 } 766} 767 768// NumExtensionsByMessage reports the number of registered extensions for 769// a given message type. 770func (r *Types) NumExtensionsByMessage(message protoreflect.FullName) int { 771 if r == nil { 772 return 0 773 } 774 if r == GlobalTypes { 775 globalMutex.RLock() 776 defer globalMutex.RUnlock() 777 } 778 return len(r.extensionsByMessage[message]) 779} 780 781// RangeExtensionsByMessage iterates over all registered extensions filtered 782// by a given message type while f returns true. Iteration order is undefined. 783func (r *Types) RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool) { 784 if r == nil { 785 return 786 } 787 if r == GlobalTypes { 788 globalMutex.RLock() 789 defer globalMutex.RUnlock() 790 } 791 for _, xt := range r.extensionsByMessage[message] { 792 if !f(xt) { 793 return 794 } 795 } 796} 797 798func typeName(t interface{}) string { 799 switch t.(type) { 800 case protoreflect.EnumType: 801 return "enum" 802 case protoreflect.MessageType: 803 return "message" 804 case protoreflect.ExtensionType: 805 return "extension" 806 default: 807 return fmt.Sprintf("%T", t) 808 } 809} 810 811func amendErrorWithCaller(err error, prev, curr interface{}) error { 812 prevPkg := goPackage(prev) 813 currPkg := goPackage(curr) 814 if prevPkg == "" || currPkg == "" || prevPkg == currPkg { 815 return err 816 } 817 return errors.New("%s\n\tpreviously from: %q\n\tcurrently from: %q", err, prevPkg, currPkg) 818} 819 820func goPackage(v interface{}) string { 821 switch d := v.(type) { 822 case protoreflect.EnumType: 823 v = d.Descriptor() 824 case protoreflect.MessageType: 825 v = d.Descriptor() 826 case protoreflect.ExtensionType: 827 v = d.TypeDescriptor() 828 } 829 if d, ok := v.(protoreflect.Descriptor); ok { 830 v = d.ParentFile() 831 } 832 if d, ok := v.(interface{ GoPackagePath() string }); ok { 833 return d.GoPackagePath() 834 } 835 return "" 836} 837