| 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 |
| } |