Import of https://github.com/ciena/voltctl at commit 40d61fbf3f910ed4017cf67c9c79e8e1f82a33a5
Change-Id: I8464c59e60d76cb8612891db3303878975b5416c
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/ast.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/ast.go
new file mode 100644
index 0000000..2499917
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/ast.go
@@ -0,0 +1,1081 @@
+package protoparse
+
+import "fmt"
+
+// This file defines all of the nodes in the proto AST.
+
+// ErrorWithSourcePos is an error about a proto source file includes information
+// about the location in the file that caused the error.
+type ErrorWithSourcePos struct {
+ Underlying error
+ Pos *SourcePos
+}
+
+// Error implements the error interface
+func (e ErrorWithSourcePos) Error() string {
+ if e.Pos.Line <= 0 || e.Pos.Col <= 0 {
+ return fmt.Sprintf("%s: %v", e.Pos.Filename, e.Underlying)
+ }
+ return fmt.Sprintf("%s:%d:%d: %v", e.Pos.Filename, e.Pos.Line, e.Pos.Col, e.Underlying)
+}
+
+// SourcePos identifies a location in a proto source file.
+type SourcePos struct {
+ Filename string
+ Line, Col int
+ Offset int
+}
+
+func unknownPos(filename string) *SourcePos {
+ return &SourcePos{Filename: filename}
+}
+
+type node interface {
+ start() *SourcePos
+ end() *SourcePos
+ leadingComments() []*comment
+ trailingComments() []*comment
+}
+
+type terminalNode interface {
+ node
+ popLeadingComment() *comment
+ pushTrailingComment(*comment)
+}
+
+var _ terminalNode = (*basicNode)(nil)
+var _ terminalNode = (*stringLiteralNode)(nil)
+var _ terminalNode = (*intLiteralNode)(nil)
+var _ terminalNode = (*floatLiteralNode)(nil)
+var _ terminalNode = (*identNode)(nil)
+
+type fileDecl interface {
+ node
+ getSyntax() node
+}
+
+var _ fileDecl = (*fileNode)(nil)
+var _ fileDecl = (*noSourceNode)(nil)
+
+type optionDecl interface {
+ node
+ getName() node
+ getValue() valueNode
+}
+
+var _ optionDecl = (*optionNode)(nil)
+var _ optionDecl = (*noSourceNode)(nil)
+
+type fieldDecl interface {
+ node
+ fieldLabel() node
+ fieldName() node
+ fieldType() node
+ fieldTag() node
+ fieldExtendee() node
+ getGroupKeyword() node
+}
+
+var _ fieldDecl = (*fieldNode)(nil)
+var _ fieldDecl = (*groupNode)(nil)
+var _ fieldDecl = (*mapFieldNode)(nil)
+var _ fieldDecl = (*syntheticMapField)(nil)
+var _ fieldDecl = (*noSourceNode)(nil)
+
+type rangeDecl interface {
+ node
+ rangeStart() node
+ rangeEnd() node
+}
+
+var _ rangeDecl = (*rangeNode)(nil)
+var _ rangeDecl = (*noSourceNode)(nil)
+
+type enumValueDecl interface {
+ node
+ getName() node
+ getNumber() node
+}
+
+var _ enumValueDecl = (*enumValueNode)(nil)
+var _ enumValueDecl = (*noSourceNode)(nil)
+
+type msgDecl interface {
+ node
+ messageName() node
+ reservedNames() []*stringLiteralNode
+}
+
+var _ msgDecl = (*messageNode)(nil)
+var _ msgDecl = (*groupNode)(nil)
+var _ msgDecl = (*mapFieldNode)(nil)
+var _ msgDecl = (*noSourceNode)(nil)
+
+type methodDecl interface {
+ node
+ getInputType() node
+ getOutputType() node
+}
+
+var _ methodDecl = (*methodNode)(nil)
+var _ methodDecl = (*noSourceNode)(nil)
+
+type posRange struct {
+ start, end *SourcePos
+}
+
+type basicNode struct {
+ posRange
+ leading []*comment
+ trailing []*comment
+}
+
+func (n *basicNode) start() *SourcePos {
+ return n.posRange.start
+}
+
+func (n *basicNode) end() *SourcePos {
+ return n.posRange.end
+}
+
+func (n *basicNode) leadingComments() []*comment {
+ return n.leading
+}
+
+func (n *basicNode) trailingComments() []*comment {
+ return n.trailing
+}
+
+func (n *basicNode) popLeadingComment() *comment {
+ c := n.leading[0]
+ n.leading = n.leading[1:]
+ return c
+}
+
+func (n *basicNode) pushTrailingComment(c *comment) {
+ n.trailing = append(n.trailing, c)
+}
+
+type comment struct {
+ posRange
+ text string
+}
+
+type basicCompositeNode struct {
+ first node
+ last node
+}
+
+func (n *basicCompositeNode) start() *SourcePos {
+ return n.first.start()
+}
+
+func (n *basicCompositeNode) end() *SourcePos {
+ return n.last.end()
+}
+
+func (n *basicCompositeNode) leadingComments() []*comment {
+ return n.first.leadingComments()
+}
+
+func (n *basicCompositeNode) trailingComments() []*comment {
+ return n.last.trailingComments()
+}
+
+func (n *basicCompositeNode) setRange(first, last node) {
+ n.first = first
+ n.last = last
+}
+
+type fileNode struct {
+ basicCompositeNode
+ syntax *syntaxNode
+ decls []*fileElement
+
+ // These fields are populated after parsing, to make it easier to find them
+ // without searching decls. The parse result has a map of descriptors to
+ // nodes which makes the other declarations easily discoverable. But these
+ // elements do not map to descriptors -- they are just stored as strings in
+ // the file descriptor.
+ imports []*importNode
+ pkg *packageNode
+}
+
+func (n *fileNode) getSyntax() node {
+ return n.syntax
+}
+
+type fileElement struct {
+ // a discriminated union: only one field will be set
+ imp *importNode
+ pkg *packageNode
+ option *optionNode
+ message *messageNode
+ enum *enumNode
+ extend *extendNode
+ service *serviceNode
+ empty *basicNode
+}
+
+func (n *fileElement) start() *SourcePos {
+ return n.get().start()
+}
+
+func (n *fileElement) end() *SourcePos {
+ return n.get().end()
+}
+
+func (n *fileElement) leadingComments() []*comment {
+ return n.get().leadingComments()
+}
+
+func (n *fileElement) trailingComments() []*comment {
+ return n.get().trailingComments()
+}
+
+func (n *fileElement) get() node {
+ switch {
+ case n.imp != nil:
+ return n.imp
+ case n.pkg != nil:
+ return n.pkg
+ case n.option != nil:
+ return n.option
+ case n.message != nil:
+ return n.message
+ case n.enum != nil:
+ return n.enum
+ case n.extend != nil:
+ return n.extend
+ case n.service != nil:
+ return n.service
+ default:
+ return n.empty
+ }
+}
+
+type syntaxNode struct {
+ basicCompositeNode
+ syntax *stringLiteralNode
+}
+
+type importNode struct {
+ basicCompositeNode
+ name *stringLiteralNode
+ public bool
+ weak bool
+}
+
+type packageNode struct {
+ basicCompositeNode
+ name *identNode
+}
+
+type identifier string
+
+type identKind int
+
+const (
+ identSimpleName identKind = iota
+ identQualified
+ identTypeName
+)
+
+type identNode struct {
+ basicNode
+ val string
+ kind identKind
+}
+
+func (n *identNode) value() interface{} {
+ return identifier(n.val)
+}
+
+type optionNode struct {
+ basicCompositeNode
+ name *optionNameNode
+ val valueNode
+}
+
+func (n *optionNode) getName() node {
+ return n.name
+}
+
+func (n *optionNode) getValue() valueNode {
+ return n.val
+}
+
+type optionNameNode struct {
+ basicCompositeNode
+ parts []*optionNamePartNode
+}
+
+type optionNamePartNode struct {
+ basicCompositeNode
+ text *identNode
+ offset int
+ length int
+ isExtension bool
+ st, en *SourcePos
+}
+
+func (n *optionNamePartNode) start() *SourcePos {
+ if n.isExtension {
+ return n.basicCompositeNode.start()
+ }
+ return n.st
+}
+
+func (n *optionNamePartNode) end() *SourcePos {
+ if n.isExtension {
+ return n.basicCompositeNode.end()
+ }
+ return n.en
+}
+
+func (n *optionNamePartNode) setRange(first, last node) {
+ n.basicCompositeNode.setRange(first, last)
+ if !n.isExtension {
+ st := *first.start()
+ st.Col += n.offset
+ n.st = &st
+ en := st
+ en.Col += n.length
+ n.en = &en
+ }
+}
+
+type valueNode interface {
+ node
+ value() interface{}
+}
+
+var _ valueNode = (*stringLiteralNode)(nil)
+var _ valueNode = (*intLiteralNode)(nil)
+var _ valueNode = (*negativeIntLiteralNode)(nil)
+var _ valueNode = (*floatLiteralNode)(nil)
+var _ valueNode = (*boolLiteralNode)(nil)
+var _ valueNode = (*sliceLiteralNode)(nil)
+var _ valueNode = (*aggregateLiteralNode)(nil)
+var _ valueNode = (*noSourceNode)(nil)
+
+type stringLiteralNode struct {
+ basicCompositeNode
+ val string
+}
+
+func (n *stringLiteralNode) value() interface{} {
+ return n.val
+}
+
+func (n *stringLiteralNode) popLeadingComment() *comment {
+ return n.first.(terminalNode).popLeadingComment()
+}
+
+func (n *stringLiteralNode) pushTrailingComment(c *comment) {
+ n.last.(terminalNode).pushTrailingComment(c)
+}
+
+type intLiteralNode struct {
+ basicNode
+ val uint64
+}
+
+func (n *intLiteralNode) value() interface{} {
+ return n.val
+}
+
+type negativeIntLiteralNode struct {
+ basicCompositeNode
+ val int64
+}
+
+func (n *negativeIntLiteralNode) value() interface{} {
+ return n.val
+}
+
+type floatLiteralNode struct {
+ basicCompositeNode
+ val float64
+}
+
+func (n *floatLiteralNode) value() interface{} {
+ return n.val
+}
+
+func (n *floatLiteralNode) popLeadingComment() *comment {
+ return n.first.(terminalNode).popLeadingComment()
+}
+
+func (n *floatLiteralNode) pushTrailingComment(c *comment) {
+ n.last.(terminalNode).pushTrailingComment(c)
+}
+
+type boolLiteralNode struct {
+ basicNode
+ val bool
+}
+
+func (n *boolLiteralNode) value() interface{} {
+ return n.val
+}
+
+type sliceLiteralNode struct {
+ basicCompositeNode
+ elements []valueNode
+}
+
+func (n *sliceLiteralNode) value() interface{} {
+ return n.elements
+}
+
+type aggregateLiteralNode struct {
+ basicCompositeNode
+ elements []*aggregateEntryNode
+}
+
+func (n *aggregateLiteralNode) value() interface{} {
+ return n.elements
+}
+
+type aggregateEntryNode struct {
+ basicCompositeNode
+ name *aggregateNameNode
+ val valueNode
+}
+
+type aggregateNameNode struct {
+ basicCompositeNode
+ name *identNode
+ isExtension bool
+}
+
+func (a *aggregateNameNode) value() string {
+ if a.isExtension {
+ return "[" + a.name.val + "]"
+ } else {
+ return a.name.val
+ }
+}
+
+type fieldNode struct {
+ basicCompositeNode
+ label *labelNode
+ fldType *identNode
+ name *identNode
+ tag *intLiteralNode
+ options []*optionNode
+
+ // This field is populated after parsing, to allow lookup of extendee source
+ // locations when field extendees cannot be linked. (Otherwise, this is just
+ // stored as a string in the field descriptors defined inside the extend
+ // block).
+ extendee *extendNode
+}
+
+func (n *fieldNode) fieldLabel() node {
+ // proto3 fields and fields inside one-ofs will not have a label and we need
+ // this check in order to return a nil node -- otherwise we'd return a
+ // non-nil node that has a nil pointer value in it :/
+ if n.label == nil {
+ return nil
+ }
+ return n.label
+}
+
+func (n *fieldNode) fieldName() node {
+ return n.name
+}
+
+func (n *fieldNode) fieldType() node {
+ return n.fldType
+}
+
+func (n *fieldNode) fieldTag() node {
+ return n.tag
+}
+
+func (n *fieldNode) fieldExtendee() node {
+ if n.extendee != nil {
+ return n.extendee.extendee
+ }
+ return nil
+}
+
+func (n *fieldNode) getGroupKeyword() node {
+ return nil
+}
+
+type labelNode struct {
+ basicNode
+ repeated bool
+ required bool
+}
+
+type groupNode struct {
+ basicCompositeNode
+ groupKeyword *identNode
+ label *labelNode
+ name *identNode
+ tag *intLiteralNode
+ decls []*messageElement
+
+ // This field is populated after parsing, to make it easier to find them
+ // without searching decls. The parse result has a map of descriptors to
+ // nodes which makes the other declarations easily discoverable. But these
+ // elements do not map to descriptors -- they are just stored as strings in
+ // the message descriptor.
+ reserved []*stringLiteralNode
+ // This field is populated after parsing, to allow lookup of extendee source
+ // locations when field extendees cannot be linked. (Otherwise, this is just
+ // stored as a string in the field descriptors defined inside the extend
+ // block).
+ extendee *extendNode
+}
+
+func (n *groupNode) fieldLabel() node {
+ return n.label
+}
+
+func (n *groupNode) fieldName() node {
+ return n.name
+}
+
+func (n *groupNode) fieldType() node {
+ return n.name
+}
+
+func (n *groupNode) fieldTag() node {
+ return n.tag
+}
+
+func (n *groupNode) fieldExtendee() node {
+ if n.extendee != nil {
+ return n.extendee.extendee
+ }
+ return nil
+}
+
+func (n *groupNode) getGroupKeyword() node {
+ return n.groupKeyword
+}
+
+func (n *groupNode) messageName() node {
+ return n.name
+}
+
+func (n *groupNode) reservedNames() []*stringLiteralNode {
+ return n.reserved
+}
+
+type oneOfNode struct {
+ basicCompositeNode
+ name *identNode
+ decls []*oneOfElement
+}
+
+type oneOfElement struct {
+ // a discriminated union: only one field will be set
+ option *optionNode
+ field *fieldNode
+ empty *basicNode
+}
+
+func (n *oneOfElement) start() *SourcePos {
+ return n.get().start()
+}
+
+func (n *oneOfElement) end() *SourcePos {
+ return n.get().end()
+}
+
+func (n *oneOfElement) leadingComments() []*comment {
+ return n.get().leadingComments()
+}
+
+func (n *oneOfElement) trailingComments() []*comment {
+ return n.get().trailingComments()
+}
+
+func (n *oneOfElement) get() node {
+ switch {
+ case n.option != nil:
+ return n.option
+ case n.field != nil:
+ return n.field
+ default:
+ return n.empty
+ }
+}
+
+type mapFieldNode struct {
+ basicCompositeNode
+ mapKeyword *identNode
+ keyType *identNode
+ valueType *identNode
+ name *identNode
+ tag *intLiteralNode
+ options []*optionNode
+}
+
+func (n *mapFieldNode) fieldLabel() node {
+ return n.mapKeyword
+}
+
+func (n *mapFieldNode) fieldName() node {
+ return n.name
+}
+
+func (n *mapFieldNode) fieldType() node {
+ return n.mapKeyword
+}
+
+func (n *mapFieldNode) fieldTag() node {
+ return n.tag
+}
+
+func (n *mapFieldNode) fieldExtendee() node {
+ return nil
+}
+
+func (n *mapFieldNode) getGroupKeyword() node {
+ return nil
+}
+
+func (n *mapFieldNode) messageName() node {
+ return n.name
+}
+
+func (n *mapFieldNode) reservedNames() []*stringLiteralNode {
+ return nil
+}
+
+func (n *mapFieldNode) keyField() *syntheticMapField {
+ tag := &intLiteralNode{
+ basicNode: basicNode{
+ posRange: posRange{start: n.keyType.start(), end: n.keyType.end()},
+ },
+ val: 1,
+ }
+ return &syntheticMapField{ident: n.keyType, tag: tag}
+}
+
+func (n *mapFieldNode) valueField() *syntheticMapField {
+ tag := &intLiteralNode{
+ basicNode: basicNode{
+ posRange: posRange{start: n.valueType.start(), end: n.valueType.end()},
+ },
+ val: 2,
+ }
+ return &syntheticMapField{ident: n.valueType, tag: tag}
+}
+
+type syntheticMapField struct {
+ ident *identNode
+ tag *intLiteralNode
+}
+
+func (n *syntheticMapField) start() *SourcePos {
+ return n.ident.start()
+}
+
+func (n *syntheticMapField) end() *SourcePos {
+ return n.ident.end()
+}
+
+func (n *syntheticMapField) leadingComments() []*comment {
+ return nil
+}
+
+func (n *syntheticMapField) trailingComments() []*comment {
+ return nil
+}
+
+func (n *syntheticMapField) fieldLabel() node {
+ return n.ident
+}
+
+func (n *syntheticMapField) fieldName() node {
+ return n.ident
+}
+
+func (n *syntheticMapField) fieldType() node {
+ return n.ident
+}
+
+func (n *syntheticMapField) fieldTag() node {
+ return n.tag
+}
+
+func (n *syntheticMapField) fieldExtendee() node {
+ return nil
+}
+
+func (n *syntheticMapField) getGroupKeyword() node {
+ return nil
+}
+
+type extensionRangeNode struct {
+ basicCompositeNode
+ ranges []*rangeNode
+ options []*optionNode
+}
+
+type rangeNode struct {
+ basicCompositeNode
+ stNode, enNode node
+ st, en int32
+}
+
+func (n *rangeNode) rangeStart() node {
+ return n.stNode
+}
+
+func (n *rangeNode) rangeEnd() node {
+ return n.enNode
+}
+
+type reservedNode struct {
+ basicCompositeNode
+ ranges []*rangeNode
+ names []*stringLiteralNode
+}
+
+type enumNode struct {
+ basicCompositeNode
+ name *identNode
+ decls []*enumElement
+
+ // This field is populated after parsing, to make it easier to find them
+ // without searching decls. The parse result has a map of descriptors to
+ // nodes which makes the other declarations easily discoverable. But these
+ // elements do not map to descriptors -- they are just stored as strings in
+ // the message descriptor.
+ reserved []*stringLiteralNode
+}
+
+type enumElement struct {
+ // a discriminated union: only one field will be set
+ option *optionNode
+ value *enumValueNode
+ reserved *reservedNode
+ empty *basicNode
+}
+
+func (n *enumElement) start() *SourcePos {
+ return n.get().start()
+}
+
+func (n *enumElement) end() *SourcePos {
+ return n.get().end()
+}
+
+func (n *enumElement) leadingComments() []*comment {
+ return n.get().leadingComments()
+}
+
+func (n *enumElement) trailingComments() []*comment {
+ return n.get().trailingComments()
+}
+
+func (n *enumElement) get() node {
+ switch {
+ case n.option != nil:
+ return n.option
+ case n.value != nil:
+ return n.value
+ default:
+ return n.empty
+ }
+}
+
+type enumValueNode struct {
+ basicCompositeNode
+ name *identNode
+ options []*optionNode
+
+ // only one of these two will be set:
+
+ numberP *intLiteralNode // positive numeric value
+ numberN *negativeIntLiteralNode // negative numeric value
+}
+
+func (n *enumValueNode) getName() node {
+ return n.name
+}
+
+func (n *enumValueNode) getNumber() node {
+ if n.numberP != nil {
+ return n.numberP
+ }
+ return n.numberN
+}
+
+type messageNode struct {
+ basicCompositeNode
+ name *identNode
+ decls []*messageElement
+
+ // This field is populated after parsing, to make it easier to find them
+ // without searching decls. The parse result has a map of descriptors to
+ // nodes which makes the other declarations easily discoverable. But these
+ // elements do not map to descriptors -- they are just stored as strings in
+ // the message descriptor.
+ reserved []*stringLiteralNode
+}
+
+func (n *messageNode) messageName() node {
+ return n.name
+}
+
+func (n *messageNode) reservedNames() []*stringLiteralNode {
+ return n.reserved
+}
+
+type messageElement struct {
+ // a discriminated union: only one field will be set
+ option *optionNode
+ field *fieldNode
+ mapField *mapFieldNode
+ oneOf *oneOfNode
+ group *groupNode
+ nested *messageNode
+ enum *enumNode
+ extend *extendNode
+ extensionRange *extensionRangeNode
+ reserved *reservedNode
+ empty *basicNode
+}
+
+func (n *messageElement) start() *SourcePos {
+ return n.get().start()
+}
+
+func (n *messageElement) end() *SourcePos {
+ return n.get().end()
+}
+
+func (n *messageElement) leadingComments() []*comment {
+ return n.get().leadingComments()
+}
+
+func (n *messageElement) trailingComments() []*comment {
+ return n.get().trailingComments()
+}
+
+func (n *messageElement) get() node {
+ switch {
+ case n.option != nil:
+ return n.option
+ case n.field != nil:
+ return n.field
+ case n.mapField != nil:
+ return n.mapField
+ case n.oneOf != nil:
+ return n.oneOf
+ case n.group != nil:
+ return n.group
+ case n.nested != nil:
+ return n.nested
+ case n.enum != nil:
+ return n.enum
+ case n.extend != nil:
+ return n.extend
+ case n.extensionRange != nil:
+ return n.extensionRange
+ case n.reserved != nil:
+ return n.reserved
+ default:
+ return n.empty
+ }
+}
+
+type extendNode struct {
+ basicCompositeNode
+ extendee *identNode
+ decls []*extendElement
+}
+
+type extendElement struct {
+ // a discriminated union: only one field will be set
+ field *fieldNode
+ group *groupNode
+ empty *basicNode
+}
+
+func (n *extendElement) start() *SourcePos {
+ return n.get().start()
+}
+
+func (n *extendElement) end() *SourcePos {
+ return n.get().end()
+}
+
+func (n *extendElement) leadingComments() []*comment {
+ return n.get().leadingComments()
+}
+
+func (n *extendElement) trailingComments() []*comment {
+ return n.get().trailingComments()
+}
+
+func (n *extendElement) get() node {
+ switch {
+ case n.field != nil:
+ return n.field
+ case n.group != nil:
+ return n.group
+ default:
+ return n.empty
+ }
+}
+
+type serviceNode struct {
+ basicCompositeNode
+ name *identNode
+ decls []*serviceElement
+}
+
+type serviceElement struct {
+ // a discriminated union: only one field will be set
+ option *optionNode
+ rpc *methodNode
+ empty *basicNode
+}
+
+func (n *serviceElement) start() *SourcePos {
+ return n.get().start()
+}
+
+func (n *serviceElement) end() *SourcePos {
+ return n.get().end()
+}
+
+func (n *serviceElement) leadingComments() []*comment {
+ return n.get().leadingComments()
+}
+
+func (n *serviceElement) trailingComments() []*comment {
+ return n.get().trailingComments()
+}
+
+func (n *serviceElement) get() node {
+ switch {
+ case n.option != nil:
+ return n.option
+ case n.rpc != nil:
+ return n.rpc
+ default:
+ return n.empty
+ }
+}
+
+type methodNode struct {
+ basicCompositeNode
+ name *identNode
+ input *rpcTypeNode
+ output *rpcTypeNode
+ options []*optionNode
+}
+
+func (n *methodNode) getInputType() node {
+ return n.input.msgType
+}
+
+func (n *methodNode) getOutputType() node {
+ return n.output.msgType
+}
+
+type rpcTypeNode struct {
+ basicCompositeNode
+ msgType *identNode
+ streamKeyword node
+}
+
+type noSourceNode struct {
+ pos *SourcePos
+}
+
+func (n noSourceNode) start() *SourcePos {
+ return n.pos
+}
+
+func (n noSourceNode) end() *SourcePos {
+ return n.pos
+}
+
+func (n noSourceNode) leadingComments() []*comment {
+ return nil
+}
+
+func (n noSourceNode) trailingComments() []*comment {
+ return nil
+}
+
+func (n noSourceNode) getSyntax() node {
+ return n
+}
+
+func (n noSourceNode) getName() node {
+ return n
+}
+
+func (n noSourceNode) getValue() valueNode {
+ return n
+}
+
+func (n noSourceNode) fieldLabel() node {
+ return n
+}
+
+func (n noSourceNode) fieldName() node {
+ return n
+}
+
+func (n noSourceNode) fieldType() node {
+ return n
+}
+
+func (n noSourceNode) fieldTag() node {
+ return n
+}
+
+func (n noSourceNode) fieldExtendee() node {
+ return n
+}
+
+func (n noSourceNode) getGroupKeyword() node {
+ return n
+}
+
+func (n noSourceNode) rangeStart() node {
+ return n
+}
+
+func (n noSourceNode) rangeEnd() node {
+ return n
+}
+
+func (n noSourceNode) getNumber() node {
+ return n
+}
+
+func (n noSourceNode) messageName() node {
+ return n
+}
+
+func (n noSourceNode) reservedNames() []*stringLiteralNode {
+ return nil
+}
+
+func (n noSourceNode) getInputType() node {
+ return n
+}
+
+func (n noSourceNode) getOutputType() node {
+ return n
+}
+
+func (n noSourceNode) value() interface{} {
+ return nil
+}