+707

cue/ast/ast.go

reviewed

··· 1 1 + // Copyright 2018 The CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + // Package ast declares the types used to represent syntax trees for CUE 16 16 + // packages. 17 17 + package ast // import "cuelang.org/go/cue/ast" 18 18 + 19 19 + import ( 20 20 + "strconv" 21 21 + "strings" 22 22 + 23 23 + "cuelang.org/go/cue/token" 24 24 + ) 25 25 + 26 26 + // ---------------------------------------------------------------------------- 27 27 + // Interfaces 28 28 + // 29 29 + // There are two main classes of nodes: expressions, clauses, and declaration 30 30 + // nodes. The node names usually match the corresponding CUE spec production 31 31 + // names to which they correspond. The node fields correspond to the individual 32 32 + // parts of the respective productions. 33 33 + // 34 34 + // All nodes contain position information marking the beginning of the 35 35 + // corresponding source text segment; it is accessible via the Pos accessor 36 36 + // method. Nodes may contain additional position info for language constructs 37 37 + // where comments may be found between parts of the construct (typically any 38 38 + // larger, parenthesized subpart). That position information is needed to 39 39 + // properly position comments when printing the construct. 40 40 + 41 41 + // A Node represents any node in the abstract syntax tree. 42 42 + type Node interface { 43 43 + Pos() token.Pos // position of first character belonging to the node 44 44 + End() token.Pos // position of first character immediately after the node 45 45 + 46 46 + // TODO: SetPos(p token.RelPos) 47 47 + 48 48 + Comments() []*CommentGroup 49 49 + AddComment(*CommentGroup) 50 50 + } 51 51 + 52 52 + // An Expr is implemented by all expression nodes. 53 53 + type Expr interface { 54 54 + Node 55 55 + exprNode() 56 56 + } 57 57 + 58 58 + func (*BadExpr) exprNode() {} 59 59 + func (*Ident) exprNode() {} 60 60 + func (*Ellipsis) exprNode() {} 61 61 + func (*BasicLit) exprNode() {} 62 62 + func (*Interpolation) exprNode() {} 63 63 + func (*StructLit) exprNode() {} 64 64 + func (*ListLit) exprNode() {} 65 65 + func (*LambdaExpr) exprNode() {} 66 66 + 67 67 + // func (*StructComprehension) exprNode() {} 68 68 + func (*ListComprehension) exprNode() {} 69 69 + func (*ParenExpr) exprNode() {} 70 70 + func (*SelectorExpr) exprNode() {} 71 71 + func (*IndexExpr) exprNode() {} 72 72 + func (*SliceExpr) exprNode() {} 73 73 + func (*CallExpr) exprNode() {} 74 74 + func (*UnaryExpr) exprNode() {} 75 75 + func (*BinaryExpr) exprNode() {} 76 76 + func (*BottomLit) exprNode() {} 77 77 + 78 78 + // A Decl node is implemented by all declarations. 79 79 + type Decl interface { 80 80 + Node 81 81 + declNode() 82 82 + } 83 83 + 84 84 + func (*Field) declNode() {} 85 85 + func (*ComprehensionDecl) declNode() {} 86 86 + func (*ImportDecl) declNode() {} 87 87 + func (*BadDecl) declNode() {} 88 88 + func (*EmitDecl) declNode() {} 89 89 + func (*Alias) declNode() {} 90 90 + 91 91 + // A Label is any prduction that can be used as a LHS label. 92 92 + type Label interface { 93 93 + Node 94 94 + labelName() (name string, isIdent bool) 95 95 + } 96 96 + 97 97 + func (n *Ident) labelName() (string, bool) { 98 98 + return n.Name, true 99 99 + } 100 100 + 101 101 + func (n *BasicLit) labelName() (string, bool) { 102 102 + switch n.Kind { 103 103 + case token.STRING: 104 104 + // Use strconv to only allow double-quoted, single-line strings. 105 105 + if str, err := strconv.Unquote(n.Value); err == nil { 106 106 + return str, true 107 107 + } 108 108 + case token.NULL, token.TRUE, token.FALSE: 109 109 + return n.Value, true 110 110 + 111 111 + // TODO: allow numbers to be fields? 112 112 + } 113 113 + return "", false 114 114 + } 115 115 + 116 116 + func (n *TemplateLabel) labelName() (string, bool) { 117 117 + return n.Ident.Name, false 118 118 + } 119 119 + 120 120 + func (n *Interpolation) labelName() (string, bool) { 121 121 + return "", false 122 122 + } 123 123 + func (n *ExprLabel) labelName() (string, bool) { 124 124 + return "", false 125 125 + } 126 126 + 127 127 + // LabelName reports the name of a label, if known, and whether it is valid. 128 128 + func LabelName(x Label) (name string, ok bool) { 129 129 + return x.labelName() 130 130 + } 131 131 + 132 132 + // As for now, a ExprLabel is not a label, as it can only use used in 133 133 + // struct comprehensions. 134 134 + 135 135 + // Clause nodes are part of comprehensions. 136 136 + type Clause interface { 137 137 + Node 138 138 + clauseNode() 139 139 + } 140 140 + 141 141 + func (x *ForClause) clauseNode() {} 142 142 + func (x *IfClause) clauseNode() {} 143 143 + func (x *Alias) clauseNode() {} 144 144 + 145 145 + // Comments 146 146 + 147 147 + type comments struct { 148 148 + groups *[]*CommentGroup 149 149 + } 150 150 + 151 151 + func (c *comments) Comments() []*CommentGroup { 152 152 + if c.groups == nil { 153 153 + return []*CommentGroup{} 154 154 + } 155 155 + return *c.groups 156 156 + } 157 157 + 158 158 + // // AddComment adds the given comments to the fields. 159 159 + // // If line is true the comment is inserted at the preceding token. 160 160 + 161 161 + func (c *comments) AddComment(cg *CommentGroup) { 162 162 + if cg == nil { 163 163 + return 164 164 + } 165 165 + if c.groups == nil { 166 166 + a := []*CommentGroup{cg} 167 167 + c.groups = &a 168 168 + return 169 169 + } 170 170 + *c.groups = append(*c.groups, cg) 171 171 + } 172 172 + 173 173 + // A Comment node represents a single //-style or /*-style comment. 174 174 + type Comment struct { 175 175 + Slash token.Pos // position of "/" starting the comment 176 176 + Text string // comment text (excluding '\n' for //-style comments) 177 177 + } 178 178 + 179 179 + func (g *Comment) Comments() []*CommentGroup { return nil } 180 180 + func (g *Comment) AddComment(*CommentGroup) {} 181 181 + 182 182 + func (c *Comment) Pos() token.Pos { return c.Slash } 183 183 + func (c *Comment) End() token.Pos { return c.Slash.Add(len(c.Text)) } 184 184 + 185 185 + // A CommentGroup represents a sequence of comments 186 186 + // with no other tokens and no empty lines between. 187 187 + type CommentGroup struct { 188 188 + // TODO: remove and use the token position of the first commment. 189 189 + Doc bool 190 190 + Line bool // true if it is on the same line as the node's end pos. 191 191 + 192 192 + // Position indicates where a comment should be attached if a node has 193 193 + // multiple tokens. 0 means before the first token, 1 means before the 194 194 + // second, etc. For instance, for a field, the positions are: 195 195 + // <0> Label <1> ":" <2> Expr <3> "," <4> 196 196 + Position int8 197 197 + List []*Comment // len(List) > 0 198 198 + } 199 199 + 200 200 + func (g *CommentGroup) Pos() token.Pos { return g.List[0].Pos() } 201 201 + func (g *CommentGroup) End() token.Pos { return g.List[len(g.List)-1].End() } 202 202 + 203 203 + func (g *CommentGroup) Comments() []*CommentGroup { return nil } 204 204 + func (g *CommentGroup) AddComment(*CommentGroup) {} 205 205 + 206 206 + func isWhitespace(ch byte) bool { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' } 207 207 + 208 208 + func stripTrailingWhitespace(s string) string { 209 209 + i := len(s) 210 210 + for i > 0 && isWhitespace(s[i-1]) { 211 211 + i-- 212 212 + } 213 213 + return s[0:i] 214 214 + } 215 215 + 216 216 + // Text returns the text of the comment. 217 217 + // Comment markers (//, /*, and */), the first space of a line comment, and 218 218 + // leading and trailing empty lines are removed. Multiple empty lines are 219 219 + // reduced to one, and trailing space on lines is trimmed. Unless the result 220 220 + // is empty, it is newline-terminated. 221 221 + func (g *CommentGroup) Text() string { 222 222 + if g == nil { 223 223 + return "" 224 224 + } 225 225 + comments := make([]string, len(g.List)) 226 226 + for i, c := range g.List { 227 227 + comments[i] = c.Text 228 228 + } 229 229 + 230 230 + lines := make([]string, 0, 10) // most comments are less than 10 lines 231 231 + for _, c := range comments { 232 232 + // Remove comment markers. 233 233 + // The parser has given us exactly the comment text. 234 234 + switch c[1] { 235 235 + case '/': 236 236 + //-style comment (no newline at the end) 237 237 + c = c[2:] 238 238 + // strip first space - required for Example tests 239 239 + if len(c) > 0 && c[0] == ' ' { 240 240 + c = c[1:] 241 241 + } 242 242 + case '*': 243 243 + /*-style comment */ 244 244 + c = c[2 : len(c)-2] 245 245 + } 246 246 + 247 247 + // Split on newlines. 248 248 + cl := strings.Split(c, "\n") 249 249 + 250 250 + // Walk lines, stripping trailing white space and adding to list. 251 251 + for _, l := range cl { 252 252 + lines = append(lines, stripTrailingWhitespace(l)) 253 253 + } 254 254 + } 255 255 + 256 256 + // Remove leading blank lines; convert runs of 257 257 + // interior blank lines to a single blank line. 258 258 + n := 0 259 259 + for _, line := range lines { 260 260 + if line != "" || n > 0 && lines[n-1] != "" { 261 261 + lines[n] = line 262 262 + n++ 263 263 + } 264 264 + } 265 265 + lines = lines[0:n] 266 266 + 267 267 + // Add final "" entry to get trailing newline from Join. 268 268 + if n > 0 && lines[n-1] != "" { 269 269 + lines = append(lines, "") 270 270 + } 271 271 + 272 272 + return strings.Join(lines, "\n") 273 273 + } 274 274 + 275 275 + // A Field represents a field declaration in a struct. 276 276 + type Field struct { 277 277 + comments 278 278 + Label Label // must have at least one element. 279 279 + 280 280 + // No colon: Value must be an StructLit with one field or a 281 281 + // LambdaExpr. 282 282 + Colon token.Pos 283 283 + Value Expr // the value associated with this field. 284 284 + } 285 285 + 286 286 + func (d *Field) Pos() token.Pos { return d.Label.Pos() } 287 287 + func (d *Field) End() token.Pos { return d.Value.End() } 288 288 + 289 289 + // An Alias binds another field to the alias name in the current struct. 290 290 + type Alias struct { 291 291 + comments 292 292 + Ident *Ident // field name, always an Ident 293 293 + Equal token.Pos // position of "=" 294 294 + Expr Expr // An Ident or SelectorExpr 295 295 + } 296 296 + 297 297 + func (a *Alias) Pos() token.Pos { return a.Ident.Pos() } 298 298 + func (a *Alias) End() token.Pos { return a.Expr.End() } 299 299 + 300 300 + // A ComprehensionDecl node represents a field comprehension. 301 301 + type ComprehensionDecl struct { 302 302 + comments 303 303 + Field *Field 304 304 + Select token.Pos 305 305 + Clauses []Clause 306 306 + } 307 307 + 308 308 + func (x *ComprehensionDecl) Pos() token.Pos { return x.Field.Pos() } 309 309 + func (x *ComprehensionDecl) End() token.Pos { 310 310 + if len(x.Clauses) > 0 { 311 311 + return x.Clauses[len(x.Clauses)-1].End() 312 312 + } 313 313 + return x.Select 314 314 + } 315 315 + 316 316 + // ---------------------------------------------------------------------------- 317 317 + // Expressions and types 318 318 + // 319 319 + // An expression is represented by a tree consisting of one 320 320 + // or more of the following concrete expression nodes. 321 321 + 322 322 + // A LambdaExpr defines a function expression. 323 323 + // 324 324 + // Lambdas are only used internally under controlled conditions. Although 325 325 + // the implementation of lambdas is fully functional, enabling them will 326 326 + // cause the language to be Turing-complete (if not otherwise limited). 327 327 + // Also, lambdas would provide yet another way to create structure, and one 328 328 + // that is known to not work well for declarative configuration languages. 329 329 + type LambdaExpr struct { 330 330 + comments 331 331 + Lparen token.Pos // position of "(" 332 332 + Params []*Field // parameters with possible initializers 333 333 + Rparen token.Pos // position of ")" 334 334 + Expr Expr 335 335 + } 336 336 + 337 337 + func (t *LambdaExpr) Pos() token.Pos { return t.Lparen } 338 338 + func (t *LambdaExpr) End() token.Pos { return t.Rparen } 339 339 + 340 340 + // A BadExpr node is a placeholder for expressions containing 341 341 + // syntax errors for which no correct expression nodes can be 342 342 + // created. This is different from an ErrorExpr which represents 343 343 + // an explicitly marked error in the source. 344 344 + type BadExpr struct { 345 345 + comments 346 346 + From, To token.Pos // position range of bad expression 347 347 + } 348 348 + 349 349 + // A BottomLit indicates an error. 350 350 + type BottomLit struct { 351 351 + comments 352 352 + Bottom token.Pos 353 353 + } 354 354 + 355 355 + // An Ident node represents an left-hand side identifier. 356 356 + type Ident struct { 357 357 + comments 358 358 + NamePos token.Pos // identifier position 359 359 + 360 360 + // This LHS path element may be an identifier. Possible forms: 361 361 + // foo: a normal identifier 362 362 + // "foo": JSON compatible 363 363 + // <foo>: a template shorthand 364 364 + Name string 365 365 + 366 366 + Scope Node // scope in which node was found or nil if referring directly 367 367 + Node Node 368 368 + } 369 369 + 370 370 + // A TemplateLabel represents a field template declaration in a struct. 371 371 + type TemplateLabel struct { 372 372 + comments 373 373 + Langle token.Pos 374 374 + Ident *Ident 375 375 + Rangle token.Pos 376 376 + } 377 377 + 378 378 + // An ExprLabel is an expression to create a label in struct comprehensions. 379 379 + type ExprLabel struct { 380 380 + comments 381 381 + Lbrack token.Pos 382 382 + Label Expr 383 383 + Rbrack token.Pos 384 384 + } 385 385 + 386 386 + // An Ellipsis node stands for the "..." type in a 387 387 + // parameter list or the "..." length in an array type. 388 388 + type Ellipsis struct { 389 389 + comments 390 390 + Ellipsis token.Pos // position of "..." 391 391 + Elt Expr // ellipsis element type (parameter lists only); or nil 392 392 + } 393 393 + 394 394 + // A BasicLit node represents a literal of basic type. 395 395 + type BasicLit struct { 396 396 + comments 397 397 + ValuePos token.Pos // literal position 398 398 + Kind token.Token // INT, FLOAT, DURATION, or STRING 399 399 + Value string // literal string; e.g. 42, 0x7f, 3.14, 1_234_567, 1e-9, 2.4i, 'a', '\x7f', "foo", or '\m\n\o' 400 400 + } 401 401 + 402 402 + // A Interpolation node represents a string or bytes interpolation. 403 403 + type Interpolation struct { // TODO: rename to TemplateLit 404 404 + comments 405 405 + Elts []Expr // interleaving of strings and expressions. 406 406 + } 407 407 + 408 408 + // A StructLit node represents a literal struct. 409 409 + type StructLit struct { 410 410 + comments 411 411 + Lbrace token.Pos // position of "{" 412 412 + Elts []Decl // list of elements; or nil 413 413 + Rbrace token.Pos // position of "}" 414 414 + } 415 415 + 416 416 + // A ListLit node represents a literal list. 417 417 + type ListLit struct { 418 418 + comments 419 419 + Lbrack token.Pos // position of "[" 420 420 + Elts []Expr // list of composite elements; or nil 421 421 + Ellipsis token.Pos // open list if set 422 422 + Type Expr // type for the remaining elements 423 423 + Rbrack token.Pos // position of "]" 424 424 + } 425 425 + 426 426 + // A ListComprehension node represents as list comprehension. 427 427 + type ListComprehension struct { 428 428 + comments 429 429 + Lbrack token.Pos // position of "[" 430 430 + Expr Expr 431 431 + Clauses []Clause // Feed or Guard (TODO let) 432 432 + Rbrack token.Pos // position of "]" 433 433 + } 434 434 + 435 435 + // A ForClause node represents a for clause in a comprehension. 436 436 + type ForClause struct { 437 437 + comments 438 438 + For token.Pos 439 439 + Key *Ident // allow pattern matching? 440 440 + Colon token.Pos 441 441 + Value *Ident // allow pattern matching? 442 442 + In token.Pos 443 443 + Source Expr 444 444 + } 445 445 + 446 446 + // A IfClause node represents an if guard clause in a comprehension. 447 447 + type IfClause struct { 448 448 + comments 449 449 + If token.Pos 450 450 + Condition Expr 451 451 + } 452 452 + 453 453 + // A ParenExpr node represents a parenthesized expression. 454 454 + type ParenExpr struct { 455 455 + comments 456 456 + Lparen token.Pos // position of "(" 457 457 + X Expr // parenthesized expression 458 458 + Rparen token.Pos // position of ")" 459 459 + } 460 460 + 461 461 + // A SelectorExpr node represents an expression followed by a selector. 462 462 + type SelectorExpr struct { 463 463 + comments 464 464 + X Expr // expression 465 465 + Sel *Ident // field selector 466 466 + } 467 467 + 468 468 + // An IndexExpr node represents an expression followed by an index. 469 469 + type IndexExpr struct { 470 470 + comments 471 471 + X Expr // expression 472 472 + Lbrack token.Pos // position of "[" 473 473 + Index Expr // index expression 474 474 + Rbrack token.Pos // position of "]" 475 475 + } 476 476 + 477 477 + // An SliceExpr node represents an expression followed by slice indices. 478 478 + type SliceExpr struct { 479 479 + comments 480 480 + X Expr // expression 481 481 + Lbrack token.Pos // position of "[" 482 482 + Low Expr // begin of slice range; or nil 483 483 + High Expr // end of slice range; or nil 484 484 + Rbrack token.Pos // position of "]" 485 485 + } 486 486 + 487 487 + // A CallExpr node represents an expression followed by an argument list. 488 488 + type CallExpr struct { 489 489 + comments 490 490 + Fun Expr // function expression 491 491 + Lparen token.Pos // position of "(" 492 492 + Args []Expr // function arguments; or nil 493 493 + Rparen token.Pos // position of ")" 494 494 + } 495 495 + 496 496 + // A UnaryExpr node represents a unary expression. 497 497 + type UnaryExpr struct { 498 498 + comments 499 499 + OpPos token.Pos // position of Op 500 500 + Op token.Token // operator 501 501 + X Expr // operand 502 502 + } 503 503 + 504 504 + // A BinaryExpr node represents a binary expression. 505 505 + type BinaryExpr struct { 506 506 + comments 507 507 + X Expr // left operand 508 508 + OpPos token.Pos // position of Op 509 509 + Op token.Token // operator 510 510 + Y Expr // right operand 511 511 + } 512 512 + 513 513 + // token.Pos and End implementations for expression/type nodes. 514 514 + 515 515 + func (x *BadExpr) Pos() token.Pos { return x.From } 516 516 + func (x *Ident) Pos() token.Pos { return x.NamePos } 517 517 + func (x *TemplateLabel) Pos() token.Pos { return x.Langle } 518 518 + func (x *ExprLabel) Pos() token.Pos { return x.Lbrack } 519 519 + func (x *Ellipsis) Pos() token.Pos { return x.Ellipsis } 520 520 + func (x *BasicLit) Pos() token.Pos { return x.ValuePos } 521 521 + func (x *Interpolation) Pos() token.Pos { return x.Elts[0].Pos() } 522 522 + func (x *StructLit) Pos() token.Pos { 523 523 + if x.Lbrace == token.NoPos && len(x.Elts) > 0 { 524 524 + return x.Elts[0].Pos() 525 525 + } 526 526 + return x.Lbrace 527 527 + } 528 528 + 529 529 + func (x *ListLit) Pos() token.Pos { return x.Lbrack } 530 530 + func (x *ListComprehension) Pos() token.Pos { return x.Lbrack } 531 531 + func (x *ForClause) Pos() token.Pos { return x.For } 532 532 + func (x *IfClause) Pos() token.Pos { return x.If } 533 533 + func (x *ParenExpr) Pos() token.Pos { return x.Lparen } 534 534 + func (x *SelectorExpr) Pos() token.Pos { return x.X.Pos() } 535 535 + func (x *IndexExpr) Pos() token.Pos { return x.X.Pos() } 536 536 + func (x *SliceExpr) Pos() token.Pos { return x.X.Pos() } 537 537 + func (x *CallExpr) Pos() token.Pos { return x.Fun.Pos() } 538 538 + func (x *UnaryExpr) Pos() token.Pos { return x.OpPos } 539 539 + func (x *BinaryExpr) Pos() token.Pos { return x.X.Pos() } 540 540 + func (x *BottomLit) Pos() token.Pos { return x.Bottom } 541 541 + 542 542 + func (x *BadExpr) End() token.Pos { return x.To } 543 543 + func (x *Ident) End() token.Pos { 544 544 + return x.NamePos.Add(len(x.Name)) 545 545 + } 546 546 + func (x *TemplateLabel) End() token.Pos { return x.Rangle } 547 547 + func (x *ExprLabel) End() token.Pos { return x.Rbrack } 548 548 + func (x *Ellipsis) End() token.Pos { 549 549 + if x.Elt != nil { 550 550 + return x.Elt.End() 551 551 + } 552 552 + return x.Ellipsis + 3 // len("...") 553 553 + } 554 554 + func (x *BasicLit) End() token.Pos { return token.Pos(int(x.ValuePos) + len(x.Value)) } 555 555 + func (x *Interpolation) End() token.Pos { return x.Elts[len(x.Elts)-1].Pos() } 556 556 + func (x *StructLit) End() token.Pos { 557 557 + if x.Rbrace == token.NoPos && len(x.Elts) > 0 { 558 558 + return x.Elts[len(x.Elts)-1].Pos() 559 559 + } 560 560 + return x.Rbrace.Add(1) 561 561 + } 562 562 + func (x *ListLit) End() token.Pos { return x.Rbrack.Add(1) } 563 563 + func (x *ListComprehension) End() token.Pos { return x.Rbrack } 564 564 + func (x *ForClause) End() token.Pos { return x.Source.End() } 565 565 + func (x *IfClause) End() token.Pos { return x.Condition.End() } 566 566 + func (x *ParenExpr) End() token.Pos { return x.Rparen.Add(1) } 567 567 + func (x *SelectorExpr) End() token.Pos { return x.Sel.End() } 568 568 + func (x *IndexExpr) End() token.Pos { return x.Rbrack.Add(1) } 569 569 + func (x *SliceExpr) End() token.Pos { return x.Rbrack.Add(1) } 570 570 + func (x *CallExpr) End() token.Pos { return x.Rparen.Add(1) } 571 571 + func (x *UnaryExpr) End() token.Pos { return x.X.End() } 572 572 + func (x *BinaryExpr) End() token.Pos { return x.Y.End() } 573 573 + func (x *BottomLit) End() token.Pos { return x.Bottom.Add(1) } 574 574 + 575 575 + // ---------------------------------------------------------------------------- 576 576 + // Convenience functions for Idents 577 577 + 578 578 + // NewIdent creates a new Ident without position. 579 579 + // Useful for ASTs generated by code other than the Go 580 580 + func NewIdent(name string) *Ident { 581 581 + return &Ident{comments{}, token.NoPos, name, nil, nil} 582 582 + } 583 583 + 584 584 + func (id *Ident) String() string { 585 585 + if id != nil { 586 586 + return id.Name 587 587 + } 588 588 + return "<nil>" 589 589 + } 590 590 + 591 591 + // ---------------------------------------------------------------------------- 592 592 + // Declarations 593 593 + 594 594 + // An ImportSpec node represents a single package import. 595 595 + type ImportSpec struct { 596 596 + comments 597 597 + Name *Ident // local package name (including "."); or nil 598 598 + Path *BasicLit // import path 599 599 + EndPos token.Pos // end of spec (overrides Path.Pos if nonzero) 600 600 + } 601 601 + 602 602 + // Pos and End implementations for spec nodes. 603 603 + 604 604 + func (s *ImportSpec) Pos() token.Pos { 605 605 + if s.Name != nil { 606 606 + return s.Name.Pos() 607 607 + } 608 608 + return s.Path.Pos() 609 609 + } 610 610 + 611 611 + // func (s *AliasSpec) Pos() token.Pos { return s.Name.Pos() } 612 612 + // func (s *ValueSpec) Pos() token.Pos { return s.Names[0].Pos() } 613 613 + // func (s *TypeSpec) Pos() token.Pos { return s.Name.Pos() } 614 614 + 615 615 + func (s *ImportSpec) End() token.Pos { 616 616 + if s.EndPos != 0 { 617 617 + return s.EndPos 618 618 + } 619 619 + return s.Path.End() 620 620 + } 621 621 + 622 622 + // specNode() ensures that only spec nodes can be assigned to a Spec. 623 623 + func (*ImportSpec) specNode() {} 624 624 + 625 625 + // A declaration is represented by one of the following declaration nodes. 626 626 + type ( 627 627 + // A BadDecl node is a placeholder for declarations containing 628 628 + // syntax errors for which no correct declaration nodes can be 629 629 + // created. 630 630 + BadDecl struct { 631 631 + comments 632 632 + From, To token.Pos // position range of bad declaration 633 633 + } 634 634 + 635 635 + // A ImportDecl node represents a series of import declarations. A valid 636 636 + // Lparen position (Lparen.Line > 0) indicates a parenthesized declaration. 637 637 + ImportDecl struct { 638 638 + comments 639 639 + Import token.Pos 640 640 + Lparen token.Pos // position of '(', if any 641 641 + Specs []*ImportSpec 642 642 + Rparen token.Pos // position of ')', if any 643 643 + } 644 644 + 645 645 + // An EmitDecl node represents a single expression used as a declaration. 646 646 + // The expressions in this declaration is what will be emitted as 647 647 + // configuration output. 648 648 + // 649 649 + // An EmitDecl may only appear at the top level. 650 650 + EmitDecl struct { 651 651 + comments 652 652 + Expr Expr 653 653 + } 654 654 + ) 655 655 + 656 656 + // Pos and End implementations for declaration nodes. 657 657 + 658 658 + func (d *BadDecl) Pos() token.Pos { return d.From } 659 659 + func (d *ImportDecl) Pos() token.Pos { return d.Import } 660 660 + func (d *EmitDecl) Pos() token.Pos { return d.Expr.Pos() } 661 661 + 662 662 + func (d *BadDecl) End() token.Pos { return d.To } 663 663 + func (d *ImportDecl) End() token.Pos { 664 664 + if d.Rparen.IsValid() { 665 665 + return d.Rparen.Add(1) 666 666 + } 667 667 + return d.Specs[0].End() 668 668 + } 669 669 + func (d *EmitDecl) End() token.Pos { return d.Expr.End() } 670 670 + 671 671 + // ---------------------------------------------------------------------------- 672 672 + // Files and packages 673 673 + 674 674 + // A File node represents a Go source file. 675 675 + // 676 676 + // The Comments list contains all comments in the source file in order of 677 677 + // appearance, including the comments that are pointed to from other nodes 678 678 + // via Doc and Comment fields. 679 679 + type File struct { 680 680 + Filename string 681 681 + comments 682 682 + Package token.Pos // position of "package" pseudo-keyword 683 683 + Name *Ident // package names 684 684 + // TODO: Change Expr to Decl? 685 685 + Imports []*ImportSpec // imports in this file 686 686 + Decls []Decl // top-level declarations; or nil 687 687 + Unresolved []*Ident // unresolved identifiers in this file 688 688 + } 689 689 + 690 690 + func (f *File) Pos() token.Pos { 691 691 + if f.Package != token.NoPos { 692 692 + return f.Package 693 693 + } 694 694 + if len(f.Decls) > 0 { 695 695 + return f.Decls[0].Pos() 696 696 + } 697 697 + return token.NoPos 698 698 + } 699 699 + func (f *File) End() token.Pos { 700 700 + if n := len(f.Decls); n > 0 { 701 701 + return f.Decls[n-1].End() 702 702 + } 703 703 + if f.Name != nil { 704 704 + return f.Name.End() 705 705 + } 706 706 + return token.NoPos 707 707 + }

+60

cue/ast/ast_test.go

reviewed

··· 1 1 + // Copyright 2018 The CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + package ast 16 16 + 17 17 + import ( 18 18 + "testing" 19 19 + ) 20 20 + 21 21 + func TestCommentText(t *testing.T) { 22 22 + testCases := []struct { 23 23 + list []string 24 24 + text string 25 25 + }{ 26 26 + {[]string{"//"}, ""}, 27 27 + {[]string{"// "}, ""}, 28 28 + {[]string{"//", "//", "// "}, ""}, 29 29 + {[]string{"// foo "}, "foo\n"}, 30 30 + {[]string{"//", "//", "// foo"}, "foo\n"}, 31 31 + {[]string{"// foo bar "}, "foo bar\n"}, 32 32 + {[]string{"// foo", "// bar"}, "foo\nbar\n"}, 33 33 + {[]string{"// foo", "//", "//", "//", "// bar"}, "foo\n\nbar\n"}, 34 34 + {[]string{"// foo", "/* bar */"}, "foo\n bar\n"}, 35 35 + {[]string{"//", "//", "//", "// foo", "//", "//", "//"}, "foo\n"}, 36 36 + 37 37 + {[]string{"/**/"}, ""}, 38 38 + {[]string{"/* */"}, ""}, 39 39 + {[]string{"/**/", "/**/", "/* */"}, ""}, 40 40 + {[]string{"/* Foo */"}, " Foo\n"}, 41 41 + {[]string{"/* Foo Bar */"}, " Foo Bar\n"}, 42 42 + {[]string{"/* Foo*/", "/* Bar*/"}, " Foo\n Bar\n"}, 43 43 + {[]string{"/* Foo*/", "/**/", "/**/", "/**/", "// Bar"}, " Foo\n\nBar\n"}, 44 44 + {[]string{"/* Foo*/", "/*\n*/", "//", "/*\n*/", "// Bar"}, " Foo\n\nBar\n"}, 45 45 + {[]string{"/* Foo*/", "// Bar"}, " Foo\nBar\n"}, 46 46 + {[]string{"/* Foo\n Bar*/"}, " Foo\n Bar\n"}, 47 47 + } 48 48 + 49 49 + for i, c := range testCases { 50 50 + list := make([]*Comment, len(c.list)) 51 51 + for i, s := range c.list { 52 52 + list[i] = &Comment{Text: s} 53 53 + } 54 54 + 55 55 + text := (&CommentGroup{List: list}).Text() 56 56 + if text != c.text { 57 57 + t.Errorf("case %d: got %q; expected %q", i, text, c.text) 58 58 + } 59 59 + } 60 60 + }

+287

cue/ast/walk.go

reviewed

··· 1 1 + // Copyright 2018 The CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + package ast 16 16 + 17 17 + import ( 18 18 + "fmt" 19 19 + 20 20 + "cuelang.org/go/cue/token" 21 21 + ) 22 22 + 23 23 + // Walk traverses an AST in depth-first order: It starts by calling f(node); 24 24 + // node must not be nil. If before returns true, Walk invokes f recursively for 25 25 + // each of the non-nil children of node, followed by a call of after. Both 26 26 + // functions may be nil. If before is nil, it is assumed to always return true. 27 27 + // 28 28 + func Walk(node Node, before func(Node) bool, after func(Node)) { 29 29 + walk(&inspector{before: before, after: after}, node) 30 30 + } 31 31 + 32 32 + // A visitor's before method is invoked for each node encountered by Walk. 33 33 + // If the result visitor w is not nil, Walk visits each of the children 34 34 + // of node with the visitor w, followed by a call of w.After. 35 35 + type visitor interface { 36 36 + Before(node Node) (w visitor) 37 37 + After(node Node) 38 38 + } 39 39 + 40 40 + // Helper functions for common node lists. They may be empty. 41 41 + 42 42 + func walkIdentList(v visitor, list []*Ident) { 43 43 + for _, x := range list { 44 44 + walk(v, x) 45 45 + } 46 46 + } 47 47 + 48 48 + func walkExprList(v visitor, list []Expr) { 49 49 + for _, x := range list { 50 50 + walk(v, x) 51 51 + } 52 52 + } 53 53 + 54 54 + func walkDeclList(v visitor, list []Decl) { 55 55 + for _, x := range list { 56 56 + walk(v, x) 57 57 + } 58 58 + } 59 59 + 60 60 + // walk traverses an AST in depth-first order: It starts by calling 61 61 + // v.Visit(node); node must not be nil. If the visitor w returned by 62 62 + // v.Visit(node) is not nil, walk is invoked recursively with visitor 63 63 + // w for each of the non-nil children of node, followed by a call of 64 64 + // w.Visit(nil). 65 65 + // 66 66 + func walk(v visitor, node Node) { 67 67 + if v = v.Before(node); v == nil { 68 68 + return 69 69 + } 70 70 + 71 71 + // TODO: record the comment groups and interleave with the values like for 72 72 + // parsing and printing? 73 73 + for _, c := range node.Comments() { 74 74 + walk(v, c) 75 75 + } 76 76 + 77 77 + // walk children 78 78 + // (the order of the cases matches the order 79 79 + // of the corresponding node types in go) 80 80 + switch n := node.(type) { 81 81 + // Comments and fields 82 82 + case *Comment: 83 83 + // nothing to do 84 84 + 85 85 + case *CommentGroup: 86 86 + for _, c := range n.List { 87 87 + walk(v, c) 88 88 + } 89 89 + 90 90 + case *Field: 91 91 + walk(v, n.Label) 92 92 + if n.Value != nil { 93 93 + walk(v, n.Value) 94 94 + } 95 95 + 96 96 + case *LambdaExpr: 97 97 + for _, p := range n.Params { 98 98 + walk(v, p) 99 99 + } 100 100 + walk(v, n.Expr) 101 101 + 102 102 + case *StructLit: 103 103 + for _, f := range n.Elts { 104 104 + walk(v, f) 105 105 + } 106 106 + 107 107 + // Expressions 108 108 + case *BottomLit, *BadExpr, *Ident, *BasicLit: 109 109 + // nothing to do 110 110 + 111 111 + case *ExprLabel: 112 112 + walk(v, n.Label) 113 113 + 114 114 + case *TemplateLabel: 115 115 + walk(v, n.Ident) 116 116 + 117 117 + case *Interpolation: 118 118 + for _, e := range n.Elts { 119 119 + walk(v, e) 120 120 + } 121 121 + 122 122 + case *Ellipsis: 123 123 + if n.Elt != nil { 124 124 + walk(v, n.Elt) 125 125 + } 126 126 + 127 127 + case *ListLit: 128 128 + walkExprList(v, n.Elts) 129 129 + if n.Type != nil { 130 130 + walk(v, n.Type) 131 131 + } 132 132 + 133 133 + case *ParenExpr: 134 134 + walk(v, n.X) 135 135 + 136 136 + case *SelectorExpr: 137 137 + walk(v, n.X) 138 138 + walk(v, n.Sel) 139 139 + 140 140 + case *IndexExpr: 141 141 + walk(v, n.X) 142 142 + walk(v, n.Index) 143 143 + 144 144 + case *SliceExpr: 145 145 + walk(v, n.X) 146 146 + if n.Low != nil { 147 147 + walk(v, n.Low) 148 148 + } 149 149 + if n.High != nil { 150 150 + walk(v, n.High) 151 151 + } 152 152 + 153 153 + case *CallExpr: 154 154 + walk(v, n.Fun) 155 155 + walkExprList(v, n.Args) 156 156 + 157 157 + case *UnaryExpr: 158 158 + walk(v, n.X) 159 159 + 160 160 + case *BinaryExpr: 161 161 + walk(v, n.X) 162 162 + walk(v, n.Y) 163 163 + 164 164 + // Declarations 165 165 + case *ImportSpec: 166 166 + if n.Name != nil { 167 167 + walk(v, n.Name) 168 168 + } 169 169 + walk(v, n.Path) 170 170 + 171 171 + case *BadDecl: 172 172 + // nothing to do 173 173 + 174 174 + case *ImportDecl: 175 175 + for _, s := range n.Specs { 176 176 + walk(v, s) 177 177 + } 178 178 + 179 179 + case *EmitDecl: 180 180 + walk(v, n.Expr) 181 181 + 182 182 + case *Alias: 183 183 + walk(v, n.Ident) 184 184 + walk(v, n.Expr) 185 185 + 186 186 + case *ComprehensionDecl: 187 187 + walk(v, n.Field) 188 188 + for _, c := range n.Clauses { 189 189 + walk(v, c) 190 190 + } 191 191 + 192 192 + // Files and packages 193 193 + case *File: 194 194 + if n.Name != nil { 195 195 + walk(v, n.Name) 196 196 + } 197 197 + walkDeclList(v, n.Decls) 198 198 + // don't walk n.Comments - they have been 199 199 + // visited already through the individual 200 200 + // nodes 201 201 + 202 202 + case *ListComprehension: 203 203 + walk(v, n.Expr) 204 204 + for _, c := range n.Clauses { 205 205 + walk(v, c) 206 206 + } 207 207 + 208 208 + case *ForClause: 209 209 + if n.Key != nil { 210 210 + walk(v, n.Key) 211 211 + } 212 212 + walk(v, n.Value) 213 213 + walk(v, n.Source) 214 214 + 215 215 + case *IfClause: 216 216 + walk(v, n.Condition) 217 217 + 218 218 + default: 219 219 + panic(fmt.Sprintf("Walk: unexpected node type %T", n)) 220 220 + } 221 221 + 222 222 + v.After(node) 223 223 + } 224 224 + 225 225 + type inspector struct { 226 226 + before func(Node) bool 227 227 + after func(Node) 228 228 + 229 229 + commentStack []commentFrame 230 230 + current commentFrame 231 231 + } 232 232 + 233 233 + type commentFrame struct { 234 234 + cg []*CommentGroup 235 235 + pos int8 236 236 + } 237 237 + 238 238 + func (f *inspector) Before(node Node) visitor { 239 239 + if f.before == nil || f.before(node) { 240 240 + f.commentStack = append(f.commentStack, f.current) 241 241 + f.current = commentFrame{cg: node.Comments()} 242 242 + f.visitComments(f.current.pos) 243 243 + return f 244 244 + } 245 245 + return nil 246 246 + } 247 247 + 248 248 + func (f *inspector) After(node Node) { 249 249 + f.visitComments(127) 250 250 + p := len(f.commentStack) - 1 251 251 + f.current = f.commentStack[p] 252 252 + f.commentStack = f.commentStack[:p] 253 253 + f.current.pos++ 254 254 + if f.after != nil { 255 255 + f.after(node) 256 256 + } 257 257 + } 258 258 + 259 259 + func (f *inspector) Token(t token.Token) { 260 260 + f.current.pos++ 261 261 + } 262 262 + 263 263 + func (f *inspector) setPos(i int8) { 264 264 + f.current.pos = i 265 265 + } 266 266 + 267 267 + func (f *inspector) visitComments(pos int8) { 268 268 + c := &f.current 269 269 + for ; len(c.cg) > 0; c.cg = c.cg[1:] { 270 270 + cg := c.cg[0] 271 271 + if cg.Position == pos { 272 272 + continue 273 273 + } 274 274 + if f.before == nil || f.before(cg) { 275 275 + for _, c := range cg.List { 276 276 + if f.before == nil || f.before(c) { 277 277 + if f.after != nil { 278 278 + f.after(c) 279 279 + } 280 280 + } 281 281 + } 282 282 + if f.after != nil { 283 283 + f.after(cg) 284 284 + } 285 285 + } 286 286 + } 287 287 + }