github.com/bakjos/protoreflect@v1.9.2/desc/protoparse/ast.go (about) 1 package protoparse 2 3 import "github.com/bakjos/protoreflect/desc/protoparse/ast" 4 5 // SourcePos is the same as ast.SourcePos. This alias exists for 6 // backwards compatibility (SourcePos used to be defined in this package.) 7 type SourcePos = ast.SourcePos 8 9 // the types below are accumulator types: linked lists that are 10 // constructed during parsing and then converted to slices of AST nodes 11 // once the whole list has been parsed 12 13 type compactOptionList struct { 14 option *ast.OptionNode 15 comma *ast.RuneNode 16 next *compactOptionList 17 } 18 19 func (list *compactOptionList) toNodes() ([]*ast.OptionNode, []*ast.RuneNode) { 20 l := 0 21 for cur := list; cur != nil; cur = cur.next { 22 l++ 23 } 24 opts := make([]*ast.OptionNode, l) 25 commas := make([]*ast.RuneNode, l-1) 26 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 27 opts[i] = cur.option 28 if cur.comma != nil { 29 commas[i] = cur.comma 30 } 31 } 32 return opts, commas 33 } 34 35 type stringList struct { 36 str *ast.StringLiteralNode 37 next *stringList 38 } 39 40 func (list *stringList) toStringValueNode() ast.StringValueNode { 41 if list.next == nil { 42 // single name 43 return list.str 44 } 45 46 l := 0 47 for cur := list; cur != nil; cur = cur.next { 48 l++ 49 } 50 strs := make([]*ast.StringLiteralNode, l) 51 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 52 strs[i] = cur.str 53 } 54 return ast.NewCompoundLiteralStringNode(strs...) 55 } 56 57 type nameList struct { 58 name ast.StringValueNode 59 comma *ast.RuneNode 60 next *nameList 61 } 62 63 func (list *nameList) toNodes() ([]ast.StringValueNode, []*ast.RuneNode) { 64 l := 0 65 for cur := list; cur != nil; cur = cur.next { 66 l++ 67 } 68 names := make([]ast.StringValueNode, l) 69 commas := make([]*ast.RuneNode, l-1) 70 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 71 names[i] = cur.name 72 if cur.comma != nil { 73 commas[i] = cur.comma 74 } 75 } 76 return names, commas 77 } 78 79 type rangeList struct { 80 rng *ast.RangeNode 81 comma *ast.RuneNode 82 next *rangeList 83 } 84 85 func (list *rangeList) toNodes() ([]*ast.RangeNode, []*ast.RuneNode) { 86 l := 0 87 for cur := list; cur != nil; cur = cur.next { 88 l++ 89 } 90 ranges := make([]*ast.RangeNode, l) 91 commas := make([]*ast.RuneNode, l-1) 92 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 93 ranges[i] = cur.rng 94 if cur.comma != nil { 95 commas[i] = cur.comma 96 } 97 } 98 return ranges, commas 99 } 100 101 type valueList struct { 102 val ast.ValueNode 103 comma *ast.RuneNode 104 next *valueList 105 } 106 107 func (list *valueList) toNodes() ([]ast.ValueNode, []*ast.RuneNode) { 108 if list == nil { 109 return nil, nil 110 } 111 l := 0 112 for cur := list; cur != nil; cur = cur.next { 113 l++ 114 } 115 vals := make([]ast.ValueNode, l) 116 commas := make([]*ast.RuneNode, l-1) 117 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 118 vals[i] = cur.val 119 if cur.comma != nil { 120 commas[i] = cur.comma 121 } 122 } 123 return vals, commas 124 } 125 126 type fieldRefList struct { 127 ref *ast.FieldReferenceNode 128 dot *ast.RuneNode 129 next *fieldRefList 130 } 131 132 func (list *fieldRefList) toNodes() ([]*ast.FieldReferenceNode, []*ast.RuneNode) { 133 l := 0 134 for cur := list; cur != nil; cur = cur.next { 135 l++ 136 } 137 refs := make([]*ast.FieldReferenceNode, l) 138 dots := make([]*ast.RuneNode, l-1) 139 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 140 refs[i] = cur.ref 141 if cur.dot != nil { 142 dots[i] = cur.dot 143 } 144 } 145 146 return refs, dots 147 } 148 149 type identList struct { 150 ident *ast.IdentNode 151 dot *ast.RuneNode 152 next *identList 153 } 154 155 func (list *identList) toIdentValueNode(leadingDot *ast.RuneNode) ast.IdentValueNode { 156 if list.next == nil && leadingDot == nil { 157 // single name 158 return list.ident 159 } 160 161 l := 0 162 for cur := list; cur != nil; cur = cur.next { 163 l++ 164 } 165 idents := make([]*ast.IdentNode, l) 166 dots := make([]*ast.RuneNode, l-1) 167 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 168 idents[i] = cur.ident 169 if cur.dot != nil { 170 dots[i] = cur.dot 171 } 172 } 173 174 return ast.NewCompoundIdentNode(leadingDot, idents, dots) 175 } 176 177 type messageFieldEntry struct { 178 field *ast.MessageFieldNode 179 delimiter *ast.RuneNode 180 } 181 182 type messageFieldList struct { 183 field *messageFieldEntry 184 next *messageFieldList 185 } 186 187 func (list *messageFieldList) toNodes() ([]*ast.MessageFieldNode, []*ast.RuneNode) { 188 if list == nil { 189 return nil, nil 190 } 191 l := 0 192 for cur := list; cur != nil; cur = cur.next { 193 l++ 194 } 195 fields := make([]*ast.MessageFieldNode, l) 196 delimiters := make([]*ast.RuneNode, l) 197 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 198 fields[i] = cur.field.field 199 if cur.field.delimiter != nil { 200 delimiters[i] = cur.field.delimiter 201 } 202 } 203 204 return fields, delimiters 205 }