github.com/hoveychen/protoreflect@v1.4.7-0.20221103114119-0b4b3385ec76/desc/protoparse/ast.go (about) 1 package protoparse 2 3 // This file defines all of the nodes in the proto AST. 4 5 // SourcePos identifies a location in a proto source file. 6 type SourcePos struct { 7 Filename string 8 Line, Col int 9 Offset int 10 } 11 12 func unknownPos(filename string) *SourcePos { 13 return &SourcePos{Filename: filename} 14 } 15 16 // node is the interface implemented by all nodes in the AST 17 type node interface { 18 start() *SourcePos 19 end() *SourcePos 20 leadingComments() []comment 21 trailingComments() []comment 22 } 23 24 type terminalNode interface { 25 node 26 popLeadingComment() comment 27 pushTrailingComment(comment) 28 } 29 30 var _ terminalNode = (*basicNode)(nil) 31 var _ terminalNode = (*stringLiteralNode)(nil) 32 var _ terminalNode = (*intLiteralNode)(nil) 33 var _ terminalNode = (*floatLiteralNode)(nil) 34 var _ terminalNode = (*identNode)(nil) 35 36 type fileDecl interface { 37 node 38 getSyntax() node 39 } 40 41 var _ fileDecl = (*fileNode)(nil) 42 var _ fileDecl = (*noSourceNode)(nil) 43 44 type optionDecl interface { 45 node 46 getName() node 47 getValue() valueNode 48 } 49 50 var _ optionDecl = (*optionNode)(nil) 51 var _ optionDecl = (*noSourceNode)(nil) 52 53 type fieldDecl interface { 54 node 55 fieldLabel() node 56 fieldName() node 57 fieldType() node 58 fieldTag() node 59 fieldExtendee() node 60 getGroupKeyword() node 61 } 62 63 var _ fieldDecl = (*fieldNode)(nil) 64 var _ fieldDecl = (*groupNode)(nil) 65 var _ fieldDecl = (*mapFieldNode)(nil) 66 var _ fieldDecl = (*syntheticMapField)(nil) 67 var _ fieldDecl = (*noSourceNode)(nil) 68 69 type rangeDecl interface { 70 node 71 rangeStart() node 72 rangeEnd() node 73 } 74 75 var _ rangeDecl = (*rangeNode)(nil) 76 var _ rangeDecl = (*noSourceNode)(nil) 77 78 type enumValueDecl interface { 79 node 80 getName() node 81 getNumber() node 82 } 83 84 var _ enumValueDecl = (*enumValueNode)(nil) 85 var _ enumValueDecl = (*noSourceNode)(nil) 86 87 type msgDecl interface { 88 node 89 messageName() node 90 } 91 92 var _ msgDecl = (*messageNode)(nil) 93 var _ msgDecl = (*groupNode)(nil) 94 var _ msgDecl = (*mapFieldNode)(nil) 95 var _ msgDecl = (*noSourceNode)(nil) 96 97 type methodDecl interface { 98 node 99 getInputType() node 100 getOutputType() node 101 } 102 103 var _ methodDecl = (*methodNode)(nil) 104 var _ methodDecl = (*noSourceNode)(nil) 105 106 type posRange struct { 107 start, end SourcePos 108 } 109 110 type basicNode struct { 111 posRange 112 leading []comment 113 trailing []comment 114 } 115 116 func (n *basicNode) start() *SourcePos { 117 return &n.posRange.start 118 } 119 120 func (n *basicNode) end() *SourcePos { 121 return &n.posRange.end 122 } 123 124 func (n *basicNode) leadingComments() []comment { 125 return n.leading 126 } 127 128 func (n *basicNode) trailingComments() []comment { 129 return n.trailing 130 } 131 132 func (n *basicNode) popLeadingComment() comment { 133 c := n.leading[0] 134 n.leading = n.leading[1:] 135 return c 136 } 137 138 func (n *basicNode) pushTrailingComment(c comment) { 139 n.trailing = append(n.trailing, c) 140 } 141 142 type comment struct { 143 posRange 144 text string 145 } 146 147 type basicCompositeNode struct { 148 first node 149 last node 150 } 151 152 func (n *basicCompositeNode) start() *SourcePos { 153 return n.first.start() 154 } 155 156 func (n *basicCompositeNode) end() *SourcePos { 157 return n.last.end() 158 } 159 160 func (n *basicCompositeNode) leadingComments() []comment { 161 return n.first.leadingComments() 162 } 163 164 func (n *basicCompositeNode) trailingComments() []comment { 165 return n.last.trailingComments() 166 } 167 168 func (n *basicCompositeNode) setRange(first, last node) { 169 n.first = first 170 n.last = last 171 } 172 173 type fileNode struct { 174 basicCompositeNode 175 syntax *syntaxNode 176 decls []*fileElement 177 178 // This field is populated after parsing, to make it easier to find 179 // source locations by import name for constructing link errors. 180 imports []*importNode 181 } 182 183 func (n *fileNode) getSyntax() node { 184 return n.syntax 185 } 186 187 type fileElement struct { 188 // a discriminated union: only one field will be set 189 imp *importNode 190 pkg *packageNode 191 option *optionNode 192 message *messageNode 193 enum *enumNode 194 extend *extendNode 195 service *serviceNode 196 empty *basicNode 197 } 198 199 func (n *fileElement) start() *SourcePos { 200 return n.get().start() 201 } 202 203 func (n *fileElement) end() *SourcePos { 204 return n.get().end() 205 } 206 207 func (n *fileElement) leadingComments() []comment { 208 return n.get().leadingComments() 209 } 210 211 func (n *fileElement) trailingComments() []comment { 212 return n.get().trailingComments() 213 } 214 215 func (n *fileElement) get() node { 216 switch { 217 case n.imp != nil: 218 return n.imp 219 case n.pkg != nil: 220 return n.pkg 221 case n.option != nil: 222 return n.option 223 case n.message != nil: 224 return n.message 225 case n.enum != nil: 226 return n.enum 227 case n.extend != nil: 228 return n.extend 229 case n.service != nil: 230 return n.service 231 default: 232 return n.empty 233 } 234 } 235 236 type syntaxNode struct { 237 basicCompositeNode 238 syntax *stringLiteralNode 239 } 240 241 type importNode struct { 242 basicCompositeNode 243 name *stringLiteralNode 244 public bool 245 weak bool 246 } 247 248 type packageNode struct { 249 basicCompositeNode 250 name *identNode 251 } 252 253 type identifier string 254 255 type identKind int 256 257 const ( 258 identSimpleName identKind = iota 259 identQualified 260 identTypeName 261 ) 262 263 type identNode struct { 264 basicCompositeNode 265 val string 266 kind identKind 267 } 268 269 func (n *identNode) value() interface{} { 270 return identifier(n.val) 271 } 272 273 func (n *identNode) popLeadingComment() comment { 274 return n.first.(terminalNode).popLeadingComment() 275 } 276 277 func (n *identNode) pushTrailingComment(c comment) { 278 n.last.(terminalNode).pushTrailingComment(c) 279 } 280 281 type compactOptionsNode struct { 282 basicCompositeNode 283 decls []*optionNode 284 } 285 286 func (n *compactOptionsNode) Elements() []*optionNode { 287 if n == nil { 288 return nil 289 } 290 return n.decls 291 } 292 293 type optionNode struct { 294 basicCompositeNode 295 name *optionNameNode 296 val valueNode 297 } 298 299 func (n *optionNode) getName() node { 300 return n.name 301 } 302 303 func (n *optionNode) getValue() valueNode { 304 return n.val 305 } 306 307 type optionNameNode struct { 308 basicCompositeNode 309 parts []*optionNamePartNode 310 } 311 312 type optionNamePartNode struct { 313 basicCompositeNode 314 text *identNode 315 offset int 316 length int 317 isExtension bool 318 st, en *SourcePos 319 } 320 321 func (n *optionNamePartNode) start() *SourcePos { 322 if n.isExtension { 323 return n.basicCompositeNode.start() 324 } 325 return n.st 326 } 327 328 func (n *optionNamePartNode) end() *SourcePos { 329 if n.isExtension { 330 return n.basicCompositeNode.end() 331 } 332 return n.en 333 } 334 335 func (n *optionNamePartNode) setRange(first, last node) { 336 n.basicCompositeNode.setRange(first, last) 337 if !n.isExtension { 338 st := *first.start() 339 st.Col += n.offset 340 n.st = &st 341 en := st 342 en.Col += n.length 343 n.en = &en 344 } 345 } 346 347 type valueNode interface { 348 node 349 value() interface{} 350 } 351 352 var _ valueNode = (*identNode)(nil) 353 var _ valueNode = (*stringLiteralNode)(nil) 354 var _ valueNode = (*intLiteralNode)(nil) 355 var _ valueNode = (*negativeIntLiteralNode)(nil) 356 var _ valueNode = (*floatLiteralNode)(nil) 357 var _ valueNode = (*boolLiteralNode)(nil) 358 var _ valueNode = (*sliceLiteralNode)(nil) 359 var _ valueNode = (*aggregateLiteralNode)(nil) 360 var _ valueNode = (*noSourceNode)(nil) 361 362 type stringLiteralNode struct { 363 basicCompositeNode 364 val string 365 } 366 367 func (n *stringLiteralNode) value() interface{} { 368 return n.val 369 } 370 371 func (n *stringLiteralNode) popLeadingComment() comment { 372 return n.first.(terminalNode).popLeadingComment() 373 } 374 375 func (n *stringLiteralNode) pushTrailingComment(c comment) { 376 n.last.(terminalNode).pushTrailingComment(c) 377 } 378 379 type intLiteralNode struct { 380 basicNode 381 val uint64 382 } 383 384 func (n *intLiteralNode) value() interface{} { 385 return n.val 386 } 387 388 type negativeIntLiteralNode struct { 389 basicCompositeNode 390 val int64 391 } 392 393 func (n *negativeIntLiteralNode) value() interface{} { 394 return n.val 395 } 396 397 type floatLiteralNode struct { 398 basicCompositeNode 399 val float64 400 } 401 402 func (n *floatLiteralNode) value() interface{} { 403 return n.val 404 } 405 406 func (n *floatLiteralNode) popLeadingComment() comment { 407 return n.first.(terminalNode).popLeadingComment() 408 } 409 410 func (n *floatLiteralNode) pushTrailingComment(c comment) { 411 n.last.(terminalNode).pushTrailingComment(c) 412 } 413 414 type boolLiteralNode struct { 415 *identNode 416 val bool 417 } 418 419 func (n *boolLiteralNode) value() interface{} { 420 return n.val 421 } 422 423 type sliceLiteralNode struct { 424 basicCompositeNode 425 elements []valueNode 426 } 427 428 func (n *sliceLiteralNode) value() interface{} { 429 return n.elements 430 } 431 432 type aggregateLiteralNode struct { 433 basicCompositeNode 434 elements []*aggregateEntryNode 435 } 436 437 func (n *aggregateLiteralNode) value() interface{} { 438 return n.elements 439 } 440 441 type aggregateEntryNode struct { 442 basicCompositeNode 443 name *aggregateNameNode 444 val valueNode 445 } 446 447 type aggregateNameNode struct { 448 basicCompositeNode 449 name *identNode 450 isExtension bool 451 } 452 453 func (a *aggregateNameNode) value() string { 454 if a.isExtension { 455 return "[" + a.name.val + "]" 456 } else { 457 return a.name.val 458 } 459 } 460 461 type fieldNode struct { 462 basicCompositeNode 463 label *labelNode 464 fldType *identNode 465 name *identNode 466 tag *intLiteralNode 467 options *compactOptionsNode 468 469 // This field is populated after parsing, to allow lookup of extendee source 470 // locations when field extendees cannot be linked. (Otherwise, this is just 471 // stored as a string in the field descriptors defined inside the extend 472 // block). 473 extendee *extendNode 474 } 475 476 func (n *fieldNode) fieldLabel() node { 477 // proto3 fields and fields inside one-ofs will not have a label and we need 478 // this check in order to return a nil node -- otherwise we'd return a 479 // non-nil node that has a nil pointer value in it :/ 480 if n.label == nil { 481 return nil 482 } 483 return n.label 484 } 485 486 func (n *fieldNode) fieldName() node { 487 return n.name 488 } 489 490 func (n *fieldNode) fieldType() node { 491 return n.fldType 492 } 493 494 func (n *fieldNode) fieldTag() node { 495 return n.tag 496 } 497 498 func (n *fieldNode) fieldExtendee() node { 499 if n.extendee != nil { 500 return n.extendee.extendee 501 } 502 return nil 503 } 504 505 func (n *fieldNode) getGroupKeyword() node { 506 return nil 507 } 508 509 type labelNode struct { 510 *identNode 511 repeated bool 512 required bool 513 } 514 515 type groupNode struct { 516 basicCompositeNode 517 groupKeyword *identNode 518 label *labelNode 519 name *identNode 520 tag *intLiteralNode 521 decls []*messageElement 522 523 // This field is populated after parsing, to allow lookup of extendee source 524 // locations when field extendees cannot be linked. (Otherwise, this is just 525 // stored as a string in the field descriptors defined inside the extend 526 // block). 527 extendee *extendNode 528 } 529 530 func (n *groupNode) fieldLabel() node { 531 return n.label 532 } 533 534 func (n *groupNode) fieldName() node { 535 return n.name 536 } 537 538 func (n *groupNode) fieldType() node { 539 return n.groupKeyword 540 } 541 542 func (n *groupNode) fieldTag() node { 543 return n.tag 544 } 545 546 func (n *groupNode) fieldExtendee() node { 547 if n.extendee != nil { 548 return n.extendee.extendee 549 } 550 return nil 551 } 552 553 func (n *groupNode) getGroupKeyword() node { 554 return n.groupKeyword 555 } 556 557 func (n *groupNode) messageName() node { 558 return n.name 559 } 560 561 type oneOfNode struct { 562 basicCompositeNode 563 name *identNode 564 decls []*oneOfElement 565 } 566 567 type oneOfElement struct { 568 // a discriminated union: only one field will be set 569 option *optionNode 570 field *fieldNode 571 empty *basicNode 572 } 573 574 func (n *oneOfElement) start() *SourcePos { 575 return n.get().start() 576 } 577 578 func (n *oneOfElement) end() *SourcePos { 579 return n.get().end() 580 } 581 582 func (n *oneOfElement) leadingComments() []comment { 583 return n.get().leadingComments() 584 } 585 586 func (n *oneOfElement) trailingComments() []comment { 587 return n.get().trailingComments() 588 } 589 590 func (n *oneOfElement) get() node { 591 switch { 592 case n.option != nil: 593 return n.option 594 case n.field != nil: 595 return n.field 596 default: 597 return n.empty 598 } 599 } 600 601 type mapTypeNode struct { 602 basicCompositeNode 603 mapKeyword *identNode 604 keyType *identNode 605 valueType *identNode 606 } 607 608 type mapFieldNode struct { 609 basicCompositeNode 610 mapType *mapTypeNode 611 name *identNode 612 tag *intLiteralNode 613 options *compactOptionsNode 614 } 615 616 func (n *mapFieldNode) fieldLabel() node { 617 return nil 618 } 619 620 func (n *mapFieldNode) fieldName() node { 621 return n.name 622 } 623 624 func (n *mapFieldNode) fieldType() node { 625 return n.mapType 626 } 627 628 func (n *mapFieldNode) fieldTag() node { 629 return n.tag 630 } 631 632 func (n *mapFieldNode) fieldExtendee() node { 633 return nil 634 } 635 636 func (n *mapFieldNode) getGroupKeyword() node { 637 return nil 638 } 639 640 func (n *mapFieldNode) messageName() node { 641 return n.name 642 } 643 644 func (n *mapFieldNode) keyField() *syntheticMapField { 645 return newSyntheticMapField(n.mapType.keyType, 1) 646 } 647 648 func (n *mapFieldNode) valueField() *syntheticMapField { 649 return newSyntheticMapField(n.mapType.valueType, 2) 650 } 651 652 func newSyntheticMapField(ident *identNode, tagNum uint64) *syntheticMapField { 653 tag := &intLiteralNode{ 654 basicNode: basicNode{ 655 posRange: posRange{start: *ident.start(), end: *ident.end()}, 656 }, 657 val: tagNum, 658 } 659 return &syntheticMapField{ident: ident, tag: tag} 660 } 661 662 type syntheticMapField struct { 663 ident *identNode 664 tag *intLiteralNode 665 } 666 667 func (n *syntheticMapField) start() *SourcePos { 668 return n.ident.start() 669 } 670 671 func (n *syntheticMapField) end() *SourcePos { 672 return n.ident.end() 673 } 674 675 func (n *syntheticMapField) leadingComments() []comment { 676 return nil 677 } 678 679 func (n *syntheticMapField) trailingComments() []comment { 680 return nil 681 } 682 683 func (n *syntheticMapField) fieldLabel() node { 684 return n.ident 685 } 686 687 func (n *syntheticMapField) fieldName() node { 688 return n.ident 689 } 690 691 func (n *syntheticMapField) fieldType() node { 692 return n.ident 693 } 694 695 func (n *syntheticMapField) fieldTag() node { 696 return n.tag 697 } 698 699 func (n *syntheticMapField) fieldExtendee() node { 700 return nil 701 } 702 703 func (n *syntheticMapField) getGroupKeyword() node { 704 return nil 705 } 706 707 type extensionRangeNode struct { 708 basicCompositeNode 709 ranges []*rangeNode 710 options *compactOptionsNode 711 } 712 713 type rangeNode struct { 714 basicCompositeNode 715 stNode, enNode node 716 st, en int32 717 } 718 719 func (n *rangeNode) rangeStart() node { 720 return n.stNode 721 } 722 723 func (n *rangeNode) rangeEnd() node { 724 return n.enNode 725 } 726 727 type reservedNode struct { 728 basicCompositeNode 729 ranges []*rangeNode 730 names []*stringLiteralNode 731 } 732 733 type enumNode struct { 734 basicCompositeNode 735 name *identNode 736 decls []*enumElement 737 } 738 739 type enumElement struct { 740 // a discriminated union: only one field will be set 741 option *optionNode 742 value *enumValueNode 743 reserved *reservedNode 744 empty *basicNode 745 } 746 747 func (n *enumElement) start() *SourcePos { 748 return n.get().start() 749 } 750 751 func (n *enumElement) end() *SourcePos { 752 return n.get().end() 753 } 754 755 func (n *enumElement) leadingComments() []comment { 756 return n.get().leadingComments() 757 } 758 759 func (n *enumElement) trailingComments() []comment { 760 return n.get().trailingComments() 761 } 762 763 func (n *enumElement) get() node { 764 switch { 765 case n.option != nil: 766 return n.option 767 case n.value != nil: 768 return n.value 769 default: 770 return n.empty 771 } 772 } 773 774 type enumValueNode struct { 775 basicCompositeNode 776 name *identNode 777 options *compactOptionsNode 778 779 // only one of these two will be set: 780 781 numberP *intLiteralNode // positive numeric value 782 numberN *negativeIntLiteralNode // negative numeric value 783 } 784 785 func (n *enumValueNode) getName() node { 786 return n.name 787 } 788 789 func (n *enumValueNode) getNumber() node { 790 if n.numberP != nil { 791 return n.numberP 792 } 793 return n.numberN 794 } 795 796 type messageNode struct { 797 basicCompositeNode 798 name *identNode 799 decls []*messageElement 800 } 801 802 func (n *messageNode) messageName() node { 803 return n.name 804 } 805 806 type messageElement struct { 807 // a discriminated union: only one field will be set 808 option *optionNode 809 field *fieldNode 810 mapField *mapFieldNode 811 oneOf *oneOfNode 812 group *groupNode 813 nested *messageNode 814 enum *enumNode 815 extend *extendNode 816 extensionRange *extensionRangeNode 817 reserved *reservedNode 818 empty *basicNode 819 } 820 821 func (n *messageElement) start() *SourcePos { 822 return n.get().start() 823 } 824 825 func (n *messageElement) end() *SourcePos { 826 return n.get().end() 827 } 828 829 func (n *messageElement) leadingComments() []comment { 830 return n.get().leadingComments() 831 } 832 833 func (n *messageElement) trailingComments() []comment { 834 return n.get().trailingComments() 835 } 836 837 func (n *messageElement) get() node { 838 switch { 839 case n.option != nil: 840 return n.option 841 case n.field != nil: 842 return n.field 843 case n.mapField != nil: 844 return n.mapField 845 case n.oneOf != nil: 846 return n.oneOf 847 case n.group != nil: 848 return n.group 849 case n.nested != nil: 850 return n.nested 851 case n.enum != nil: 852 return n.enum 853 case n.extend != nil: 854 return n.extend 855 case n.extensionRange != nil: 856 return n.extensionRange 857 case n.reserved != nil: 858 return n.reserved 859 default: 860 return n.empty 861 } 862 } 863 864 type extendNode struct { 865 basicCompositeNode 866 extendee *identNode 867 decls []*extendElement 868 } 869 870 type extendElement struct { 871 // a discriminated union: only one field will be set 872 field *fieldNode 873 group *groupNode 874 empty *basicNode 875 } 876 877 func (n *extendElement) start() *SourcePos { 878 return n.get().start() 879 } 880 881 func (n *extendElement) end() *SourcePos { 882 return n.get().end() 883 } 884 885 func (n *extendElement) leadingComments() []comment { 886 return n.get().leadingComments() 887 } 888 889 func (n *extendElement) trailingComments() []comment { 890 return n.get().trailingComments() 891 } 892 893 func (n *extendElement) get() node { 894 switch { 895 case n.field != nil: 896 return n.field 897 case n.group != nil: 898 return n.group 899 default: 900 return n.empty 901 } 902 } 903 904 type serviceNode struct { 905 basicCompositeNode 906 name *identNode 907 decls []*serviceElement 908 } 909 910 type serviceElement struct { 911 // a discriminated union: only one field will be set 912 option *optionNode 913 rpc *methodNode 914 empty *basicNode 915 } 916 917 func (n *serviceElement) start() *SourcePos { 918 return n.get().start() 919 } 920 921 func (n *serviceElement) end() *SourcePos { 922 return n.get().end() 923 } 924 925 func (n *serviceElement) leadingComments() []comment { 926 return n.get().leadingComments() 927 } 928 929 func (n *serviceElement) trailingComments() []comment { 930 return n.get().trailingComments() 931 } 932 933 func (n *serviceElement) get() node { 934 switch { 935 case n.option != nil: 936 return n.option 937 case n.rpc != nil: 938 return n.rpc 939 default: 940 return n.empty 941 } 942 } 943 944 type methodNode struct { 945 basicCompositeNode 946 name *identNode 947 input *rpcTypeNode 948 output *rpcTypeNode 949 options []*optionNode 950 } 951 952 func (n *methodNode) getInputType() node { 953 return n.input.msgType 954 } 955 956 func (n *methodNode) getOutputType() node { 957 return n.output.msgType 958 } 959 960 type rpcTypeNode struct { 961 basicCompositeNode 962 msgType *identNode 963 streamKeyword node 964 } 965 966 type noSourceNode struct { 967 pos *SourcePos 968 } 969 970 func (n noSourceNode) start() *SourcePos { 971 return n.pos 972 } 973 974 func (n noSourceNode) end() *SourcePos { 975 return n.pos 976 } 977 978 func (n noSourceNode) leadingComments() []comment { 979 return nil 980 } 981 982 func (n noSourceNode) trailingComments() []comment { 983 return nil 984 } 985 986 func (n noSourceNode) getSyntax() node { 987 return n 988 } 989 990 func (n noSourceNode) getName() node { 991 return n 992 } 993 994 func (n noSourceNode) getValue() valueNode { 995 return n 996 } 997 998 func (n noSourceNode) fieldLabel() node { 999 return n 1000 } 1001 1002 func (n noSourceNode) fieldName() node { 1003 return n 1004 } 1005 1006 func (n noSourceNode) fieldType() node { 1007 return n 1008 } 1009 1010 func (n noSourceNode) fieldTag() node { 1011 return n 1012 } 1013 1014 func (n noSourceNode) fieldExtendee() node { 1015 return n 1016 } 1017 1018 func (n noSourceNode) getGroupKeyword() node { 1019 return n 1020 } 1021 1022 func (n noSourceNode) rangeStart() node { 1023 return n 1024 } 1025 1026 func (n noSourceNode) rangeEnd() node { 1027 return n 1028 } 1029 1030 func (n noSourceNode) getNumber() node { 1031 return n 1032 } 1033 1034 func (n noSourceNode) messageName() node { 1035 return n 1036 } 1037 1038 func (n noSourceNode) getInputType() node { 1039 return n 1040 } 1041 1042 func (n noSourceNode) getOutputType() node { 1043 return n 1044 } 1045 1046 func (n noSourceNode) value() interface{} { 1047 return nil 1048 }