Source file src/github.com/bazelbuild/buildtools/build/parse.y.go

Documentation: github.com/bazelbuild/buildtools/build

     1  //line build/parse.y:29
     2  package build
     3  
     4  import __yyfmt__ "fmt"
     5  
     6  //line build/parse.y:29
     7  
     8  //line build/parse.y:34
     9  type yySymType struct {
    10  	yys int
    11  	// input tokens
    12  	tok    string   // raw input syntax
    13  	str    string   // decoding of quoted string
    14  	pos    Position // position of token
    15  	triple bool     // was string triple quoted?
    16  
    17  	// partial syntax trees
    18  	expr    Expr
    19  	exprs   []Expr
    20  	kv      *KeyValueExpr
    21  	kvs     []*KeyValueExpr
    22  	string  *StringExpr
    23  	ifstmt  *IfStmt
    24  	loadarg *struct {
    25  		from Ident
    26  		to   Ident
    27  	}
    28  	loadargs []*struct {
    29  		from Ident
    30  		to   Ident
    31  	}
    32  	def_header *DefStmt // partially filled in def statement, without the body
    33  
    34  	// supporting information
    35  	comma    Position // position of trailing comma in list, if present
    36  	lastStmt Expr     // most recent rule, to attach line comments to
    37  }
    38  
    39  const _AUGM = 57346
    40  const _AND = 57347
    41  const _COMMENT = 57348
    42  const _EOF = 57349
    43  const _EQ = 57350
    44  const _FOR = 57351
    45  const _GE = 57352
    46  const _IDENT = 57353
    47  const _INT = 57354
    48  const _IF = 57355
    49  const _ELSE = 57356
    50  const _ELIF = 57357
    51  const _IN = 57358
    52  const _IS = 57359
    53  const _LAMBDA = 57360
    54  const _LOAD = 57361
    55  const _LE = 57362
    56  const _NE = 57363
    57  const _STAR_STAR = 57364
    58  const _INT_DIV = 57365
    59  const _BIT_LSH = 57366
    60  const _BIT_RSH = 57367
    61  const _ARROW = 57368
    62  const _NOT = 57369
    63  const _OR = 57370
    64  const _STRING = 57371
    65  const _DEF = 57372
    66  const _RETURN = 57373
    67  const _PASS = 57374
    68  const _BREAK = 57375
    69  const _CONTINUE = 57376
    70  const _INDENT = 57377
    71  const _UNINDENT = 57378
    72  const ShiftInstead = 57379
    73  const _ASSERT = 57380
    74  const _UNARY = 57381
    75  
    76  var yyToknames = [...]string{
    77  	"$end",
    78  	"error",
    79  	"$unk",
    80  	"'%'",
    81  	"'('",
    82  	"')'",
    83  	"'*'",
    84  	"'+'",
    85  	"','",
    86  	"'-'",
    87  	"'.'",
    88  	"'/'",
    89  	"':'",
    90  	"'<'",
    91  	"'='",
    92  	"'>'",
    93  	"'['",
    94  	"']'",
    95  	"'{'",
    96  	"'}'",
    97  	"'|'",
    98  	"'&'",
    99  	"'^'",
   100  	"'~'",
   101  	"_AUGM",
   102  	"_AND",
   103  	"_COMMENT",
   104  	"_EOF",
   105  	"_EQ",
   106  	"_FOR",
   107  	"_GE",
   108  	"_IDENT",
   109  	"_INT",
   110  	"_IF",
   111  	"_ELSE",
   112  	"_ELIF",
   113  	"_IN",
   114  	"_IS",
   115  	"_LAMBDA",
   116  	"_LOAD",
   117  	"_LE",
   118  	"_NE",
   119  	"_STAR_STAR",
   120  	"_INT_DIV",
   121  	"_BIT_LSH",
   122  	"_BIT_RSH",
   123  	"_ARROW",
   124  	"_NOT",
   125  	"_OR",
   126  	"_STRING",
   127  	"_DEF",
   128  	"_RETURN",
   129  	"_PASS",
   130  	"_BREAK",
   131  	"_CONTINUE",
   132  	"_INDENT",
   133  	"_UNINDENT",
   134  	"ShiftInstead",
   135  	"'\\n'",
   136  	"_ASSERT",
   137  	"_UNARY",
   138  	"';'",
   139  }
   140  
   141  var yyStatenames = [...]string{}
   142  
   143  const yyEofCode = 1
   144  const yyErrCode = 2
   145  const yyInitialStackSize = 16
   146  
   147  //line build/parse.y:1058
   148  
   149  // Go helper code.
   150  
   151  // unary returns a unary expression with the given
   152  // position, operator, and subexpression.
   153  func unary(pos Position, op string, x Expr) Expr {
   154  	return &UnaryExpr{
   155  		OpStart: pos,
   156  		Op:      op,
   157  		X:       x,
   158  	}
   159  }
   160  
   161  // binary returns a binary expression with the given
   162  // operands, position, and operator.
   163  func binary(x Expr, pos Position, op string, y Expr) Expr {
   164  	_, xend := x.Span()
   165  	ystart, _ := y.Span()
   166  
   167  	switch op {
   168  	case "=", "+=", "-=", "*=", "/=", "//=", "%=", "|=":
   169  		return &AssignExpr{
   170  			LHS:       x,
   171  			OpPos:     pos,
   172  			Op:        op,
   173  			LineBreak: xend.Line < ystart.Line,
   174  			RHS:       y,
   175  		}
   176  	}
   177  
   178  	return &BinaryExpr{
   179  		X:         x,
   180  		OpStart:   pos,
   181  		Op:        op,
   182  		LineBreak: xend.Line < ystart.Line,
   183  		Y:         y,
   184  	}
   185  }
   186  
   187  // typed returns a TypedIdent expression
   188  func typed(x, y Expr) *TypedIdent {
   189  	return &TypedIdent{
   190  		Ident: x.(*Ident),
   191  		Type:  y,
   192  	}
   193  }
   194  
   195  // isSimpleExpression returns whether an expression is simple and allowed to exist in
   196  // compact forms of sequences.
   197  // The formal criteria are the following: an expression is considered simple if it's
   198  // a literal (variable, string or a number), a literal with a unary operator or an empty sequence.
   199  func isSimpleExpression(expr *Expr) bool {
   200  	switch x := (*expr).(type) {
   201  	case *LiteralExpr, *StringExpr, *Ident:
   202  		return true
   203  	case *UnaryExpr:
   204  		_, literal := x.X.(*LiteralExpr)
   205  		_, ident := x.X.(*Ident)
   206  		return literal || ident
   207  	case *ListExpr:
   208  		return len(x.List) == 0
   209  	case *TupleExpr:
   210  		return len(x.List) == 0
   211  	case *DictExpr:
   212  		return len(x.List) == 0
   213  	case *SetExpr:
   214  		return len(x.List) == 0
   215  	default:
   216  		return false
   217  	}
   218  }
   219  
   220  // forceCompact returns the setting for the ForceCompact field for a call or tuple.
   221  //
   222  // NOTE 1: The field is called ForceCompact, not ForceSingleLine,
   223  // because it only affects the formatting associated with the call or tuple syntax,
   224  // not the formatting of the arguments. For example:
   225  //
   226  //	call([
   227  //		1,
   228  //		2,
   229  //		3,
   230  //	])
   231  //
   232  // is still a compact call even though it runs on multiple lines.
   233  //
   234  // In contrast the multiline form puts a linebreak after the (.
   235  //
   236  //	call(
   237  //		[
   238  //			1,
   239  //			2,
   240  //			3,
   241  //		],
   242  //	)
   243  //
   244  // NOTE 2: Because of NOTE 1, we cannot use start and end on the
   245  // same line as a signal for compact mode: the formatting of an
   246  // embedded list might move the end to a different line, which would
   247  // then look different on rereading and cause buildifier not to be
   248  // idempotent. Instead, we have to look at properties guaranteed
   249  // to be preserved by the reformatting, namely that the opening
   250  // paren and the first expression are on the same line and that
   251  // each subsequent expression begins on the same line as the last
   252  // one ended (no line breaks after comma).
   253  func forceCompact(start Position, list []Expr, end Position) bool {
   254  	if len(list) <= 1 {
   255  		// The call or tuple will probably be compact anyway; don't force it.
   256  		return false
   257  	}
   258  
   259  	// If there are any named arguments or non-string, non-literal
   260  	// arguments, cannot force compact mode.
   261  	line := start.Line
   262  	for _, x := range list {
   263  		start, end := x.Span()
   264  		if start.Line != line {
   265  			return false
   266  		}
   267  		line = end.Line
   268  		if !isSimpleExpression(&x) {
   269  			return false
   270  		}
   271  	}
   272  	return end.Line == line
   273  }
   274  
   275  // forceMultiLine returns the setting for the ForceMultiLine field.
   276  func forceMultiLine(start Position, list []Expr, end Position) bool {
   277  	if len(list) > 1 {
   278  		// The call will be multiline anyway, because it has multiple elements. Don't force it.
   279  		return false
   280  	}
   281  
   282  	if len(list) == 0 {
   283  		// Empty list: use position of brackets.
   284  		return start.Line != end.Line
   285  	}
   286  
   287  	// Single-element list.
   288  	// Check whether opening bracket is on different line than beginning of
   289  	// element, or closing bracket is on different line than end of element.
   290  	elemStart, elemEnd := list[0].Span()
   291  	return start.Line != elemStart.Line || end.Line != elemEnd.Line
   292  }
   293  
   294  // forceMultiLineComprehension returns the setting for the ForceMultiLine field for a comprehension.
   295  func forceMultiLineComprehension(start Position, expr Expr, clauses []Expr, end Position) bool {
   296  	// Return true if there's at least one line break between start, expr, each clause, and end
   297  	exprStart, exprEnd := expr.Span()
   298  	if start.Line != exprStart.Line {
   299  		return true
   300  	}
   301  	previousEnd := exprEnd
   302  	for _, clause := range clauses {
   303  		clauseStart, clauseEnd := clause.Span()
   304  		if previousEnd.Line != clauseStart.Line {
   305  			return true
   306  		}
   307  		previousEnd = clauseEnd
   308  	}
   309  	return previousEnd.Line != end.Line
   310  }
   311  
   312  // extractTrailingComments extracts trailing comments of an indented block starting with the first
   313  // comment line with indentation less than the block indentation.
   314  // The comments can either belong to CommentBlock statements or to the last non-comment statement
   315  // as After-comments.
   316  func extractTrailingComments(stmt Expr) []Expr {
   317  	body := getLastBody(stmt)
   318  	var comments []Expr
   319  	if body != nil && len(*body) > 0 {
   320  		// Get the current indentation level
   321  		start, _ := (*body)[0].Span()
   322  		indentation := start.LineRune
   323  
   324  		// Find the last non-comment statement
   325  		lastNonCommentIndex := -1
   326  		for i, stmt := range *body {
   327  			if _, ok := stmt.(*CommentBlock); !ok {
   328  				lastNonCommentIndex = i
   329  			}
   330  		}
   331  		if lastNonCommentIndex == -1 {
   332  			return comments
   333  		}
   334  
   335  		// Iterate over the trailing comments, find the first comment line that's not indented enough,
   336  		// dedent it and all the following comments.
   337  		for i := lastNonCommentIndex; i < len(*body); i++ {
   338  			stmt := (*body)[i]
   339  			if comment := extractDedentedComment(stmt, indentation); comment != nil {
   340  				// This comment and all the following CommentBlock statements are to be extracted.
   341  				comments = append(comments, comment)
   342  				comments = append(comments, (*body)[i+1:]...)
   343  				*body = (*body)[:i+1]
   344  				// If the current statement is a CommentBlock statement without any comment lines
   345  				// it should be removed too.
   346  				if i > lastNonCommentIndex && len(stmt.Comment().After) == 0 {
   347  					*body = (*body)[:i]
   348  				}
   349  			}
   350  		}
   351  	}
   352  	return comments
   353  }
   354  
   355  // extractDedentedComment extract the first comment line from `stmt` which indentation is smaller
   356  // than `indentation`, and all following comment lines, and returns them in a newly created
   357  // CommentBlock statement.
   358  func extractDedentedComment(stmt Expr, indentation int) Expr {
   359  	for i, line := range stmt.Comment().After {
   360  		// line.Start.LineRune == 0 can't exist in parsed files, it indicates that the comment line
   361  		// has been added by an AST modification. Don't take such lines into account.
   362  		if line.Start.LineRune > 0 && line.Start.LineRune < indentation {
   363  			// This and all the following lines should be dedented
   364  			cb := &CommentBlock{
   365  				Start:    line.Start,
   366  				Comments: Comments{After: stmt.Comment().After[i:]},
   367  			}
   368  			stmt.Comment().After = stmt.Comment().After[:i]
   369  			return cb
   370  		}
   371  	}
   372  	return nil
   373  }
   374  
   375  // getLastBody returns the last body of a block statement (the only body for For- and DefStmt
   376  // objects, the last in a if-elif-else chain
   377  func getLastBody(stmt Expr) *[]Expr {
   378  	switch block := stmt.(type) {
   379  	case *DefStmt:
   380  		return &block.Body
   381  	case *ForStmt:
   382  		return &block.Body
   383  	case *IfStmt:
   384  		if len(block.False) == 0 {
   385  			return &block.True
   386  		} else if len(block.False) == 1 {
   387  			if next, ok := block.False[0].(*IfStmt); ok {
   388  				// Recursively find the last block of the chain
   389  				return getLastBody(next)
   390  			}
   391  		}
   392  		return &block.False
   393  	}
   394  	return nil
   395  }
   396  
   397  //line yacctab:1
   398  var yyExca = [...]int16{
   399  	-1, 1,
   400  	1, -1,
   401  	-2, 0,
   402  	-1, 79,
   403  	6, 55,
   404  	-2, 128,
   405  	-1, 169,
   406  	20, 125,
   407  	-2, 126,
   408  }
   409  
   410  const yyPrivate = 57344
   411  
   412  const yyLast = 1052
   413  
   414  var yyAct = [...]int16{
   415  	20, 31, 234, 250, 146, 2, 29, 108, 186, 106,
   416  	7, 147, 195, 95, 160, 43, 152, 9, 23, 187,
   417  	159, 105, 240, 220, 174, 40, 87, 88, 89, 90,
   418  	44, 84, 39, 36, 93, 98, 101, 49, 209, 54,
   419  	131, 173, 53, 57, 83, 58, 103, 55, 113, 218,
   420  	114, 39, 110, 36, 118, 119, 120, 121, 122, 123,
   421  	124, 125, 126, 127, 128, 129, 130, 200, 132, 133,
   422  	134, 135, 136, 137, 138, 139, 140, 35, 217, 56,
   423  	238, 219, 189, 38, 51, 52, 143, 110, 92, 33,
   424  	36, 34, 155, 156, 54, 85, 157, 53, 13, 164,
   425  	76, 94, 55, 162, 36, 37, 163, 36, 39, 168,
   426  	263, 171, 32, 48, 167, 109, 165, 212, 190, 116,
   427  	36, 77, 39, 175, 100, 207, 181, 162, 213, 179,
   428  	166, 86, 182, 47, 56, 54, 97, 162, 53, 57,
   429  	117, 58, 201, 55, 111, 112, 248, 196, 188, 115,
   430  	193, 247, 191, 197, 158, 205, 79, 194, 261, 206,
   431  	84, 227, 78, 154, 211, 231, 47, 154, 80, 211,
   432  	221, 214, 216, 204, 208, 56, 72, 73, 210, 149,
   433  	208, 44, 47, 47, 223, 215, 102, 180, 45, 47,
   434  	222, 245, 244, 142, 202, 196, 228, 229, 46, 232,
   435  	233, 197, 225, 235, 151, 42, 260, 230, 178, 148,
   436  	237, 226, 200, 47, 169, 153, 264, 224, 236, 192,
   437  	172, 141, 91, 239, 104, 177, 1, 10, 243, 18,
   438  	249, 241, 246, 188, 176, 242, 99, 96, 251, 253,
   439  	41, 50, 19, 252, 12, 256, 257, 7, 8, 235,
   440  	203, 258, 4, 30, 259, 161, 262, 150, 184, 185,
   441  	81, 82, 251, 266, 265, 35, 144, 252, 27, 145,
   442  	26, 38, 0, 0, 0, 0, 0, 33, 0, 34,
   443  	0, 0, 0, 0, 28, 0, 0, 6, 0, 0,
   444  	11, 0, 36, 37, 22, 0, 0, 0, 0, 24,
   445  	32, 0, 0, 0, 0, 0, 0, 0, 25, 0,
   446  	39, 21, 14, 15, 16, 17, 0, 254, 35, 5,
   447  	0, 27, 0, 26, 38, 0, 0, 0, 0, 0,
   448  	33, 0, 34, 0, 0, 0, 0, 28, 0, 0,
   449  	6, 3, 0, 11, 0, 36, 37, 22, 0, 0,
   450  	0, 54, 24, 32, 53, 57, 0, 58, 0, 55,
   451  	0, 25, 0, 39, 21, 14, 15, 16, 17, 70,
   452  	35, 0, 5, 27, 0, 26, 38, 0, 0, 0,
   453  	0, 0, 33, 0, 34, 0, 0, 0, 0, 28,
   454  	0, 56, 72, 73, 0, 0, 0, 36, 37, 0,
   455  	0, 0, 0, 0, 24, 32, 0, 0, 0, 0,
   456  	0, 0, 0, 25, 0, 39, 0, 14, 15, 16,
   457  	17, 0, 54, 0, 107, 53, 57, 0, 58, 0,
   458  	55, 0, 59, 255, 60, 0, 0, 0, 0, 69,
   459  	70, 71, 0, 0, 68, 0, 0, 61, 0, 64,
   460  	0, 0, 75, 0, 0, 65, 74, 0, 0, 62,
   461  	63, 0, 56, 72, 73, 54, 66, 67, 53, 57,
   462  	0, 58, 0, 55, 170, 59, 0, 60, 0, 0,
   463  	0, 0, 69, 70, 71, 0, 0, 68, 0, 0,
   464  	61, 0, 64, 0, 0, 75, 0, 0, 65, 74,
   465  	0, 0, 62, 63, 0, 56, 72, 73, 54, 66,
   466  	67, 53, 57, 0, 58, 0, 55, 0, 59, 0,
   467  	60, 0, 0, 0, 0, 69, 70, 71, 0, 0,
   468  	68, 0, 0, 61, 0, 64, 0, 0, 75, 183,
   469  	0, 65, 74, 0, 0, 62, 63, 0, 56, 72,
   470  	73, 54, 66, 67, 53, 57, 0, 58, 0, 55,
   471  	0, 59, 0, 60, 0, 0, 0, 0, 69, 70,
   472  	71, 0, 0, 68, 0, 0, 61, 162, 64, 0,
   473  	0, 75, 0, 0, 65, 74, 0, 0, 62, 63,
   474  	0, 56, 72, 73, 54, 66, 67, 53, 57, 0,
   475  	58, 0, 55, 0, 59, 0, 60, 0, 0, 0,
   476  	0, 69, 70, 71, 0, 0, 68, 0, 0, 61,
   477  	0, 64, 0, 0, 75, 0, 0, 65, 74, 0,
   478  	0, 62, 63, 0, 56, 72, 73, 35, 66, 67,
   479  	27, 0, 26, 38, 0, 0, 0, 0, 0, 33,
   480  	0, 34, 0, 0, 0, 0, 28, 0, 0, 0,
   481  	0, 0, 0, 0, 36, 37, 0, 0, 0, 0,
   482  	0, 24, 32, 0, 0, 0, 0, 0, 0, 0,
   483  	25, 0, 39, 0, 14, 15, 16, 17, 54, 0,
   484  	0, 53, 57, 0, 58, 0, 55, 0, 59, 0,
   485  	60, 0, 0, 0, 0, 69, 70, 71, 0, 0,
   486  	68, 0, 0, 61, 0, 64, 0, 0, 0, 0,
   487  	0, 65, 74, 0, 0, 62, 63, 0, 56, 72,
   488  	73, 54, 66, 67, 53, 57, 0, 58, 0, 55,
   489  	0, 59, 0, 60, 0, 0, 0, 0, 69, 70,
   490  	71, 0, 0, 68, 0, 0, 61, 0, 64, 0,
   491  	0, 0, 0, 0, 65, 0, 0, 0, 62, 63,
   492  	0, 56, 72, 73, 54, 66, 67, 53, 57, 0,
   493  	58, 0, 55, 0, 59, 0, 60, 0, 0, 0,
   494  	0, 69, 70, 71, 0, 0, 68, 0, 0, 61,
   495  	0, 64, 0, 0, 0, 0, 0, 65, 0, 0,
   496  	0, 62, 63, 0, 56, 72, 73, 54, 66, 0,
   497  	53, 57, 0, 58, 0, 55, 0, 59, 0, 60,
   498  	0, 0, 0, 0, 69, 70, 71, 0, 0, 0,
   499  	0, 0, 61, 0, 64, 0, 0, 0, 0, 0,
   500  	65, 0, 0, 0, 62, 63, 0, 56, 72, 73,
   501  	35, 66, 198, 27, 200, 26, 38, 0, 0, 0,
   502  	0, 0, 33, 0, 34, 0, 0, 0, 0, 28,
   503  	0, 0, 0, 0, 0, 0, 0, 36, 37, 0,
   504  	0, 0, 0, 54, 24, 32, 53, 57, 199, 58,
   505  	0, 55, 0, 25, 35, 39, 198, 27, 0, 26,
   506  	38, 70, 71, 0, 0, 0, 33, 0, 34, 0,
   507  	0, 0, 0, 28, 0, 0, 0, 0, 0, 0,
   508  	0, 36, 37, 56, 72, 73, 0, 0, 24, 32,
   509  	35, 0, 199, 27, 200, 26, 38, 25, 0, 39,
   510  	0, 0, 33, 0, 34, 0, 0, 0, 0, 28,
   511  	0, 0, 0, 0, 0, 0, 0, 36, 37, 0,
   512  	0, 0, 0, 0, 24, 32, 35, 0, 0, 27,
   513  	0, 26, 38, 25, 0, 39, 0, 0, 33, 0,
   514  	34, 0, 0, 0, 0, 28, 0, 0, 0, 0,
   515  	0, 0, 0, 36, 37, 0, 0, 0, 0, 54,
   516  	24, 32, 53, 57, 0, 58, 0, 55, 0, 25,
   517  	0, 39, 0, 0, 0, 0, 69, 70, 71, 0,
   518  	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   519  	0, 0, 0, 0, 0, 0, 0, 0, 0, 56,
   520  	72, 73,
   521  }
   522  
   523  var yyPact = [...]int16{
   524  	-1000, -1000, 313, -1000, -1000, -1000, -34, -1000, -1000, -1000,
   525  	192, 72, -1000, 173, 971, -1000, -1000, -1000, -10, 49,
   526  	590, 68, 971, 151, 88, 971, 971, 971, 971, -1000,
   527  	-1000, -1000, 217, 971, 971, 971, -1000, 175, 13, -1000,
   528  	-1000, -41, 365, 78, 151, 971, 971, 971, 204, 971,
   529  	971, 106, -1000, 971, 971, 971, 971, 971, 971, 971,
   530  	971, 971, 971, 971, 971, 971, 3, 971, 971, 971,
   531  	971, 971, 971, 971, 971, 971, 216, 180, 54, 200,
   532  	971, 191, 206, -1000, 152, 21, 21, -1000, -1000, -1000,
   533  	-1000, 200, 136, 547, 200, 73, 110, 205, 461, 200,
   534  	214, 590, 8, -1000, -35, 632, -1000, -1000, -1000, 971,
   535  	72, 204, 204, 684, 590, 174, 365, -1000, -1000, -1000,
   536  	-1000, -1000, 90, 90, 1005, 1005, 1005, 1005, 1005, 1005,
   537  	1005, 971, 770, 813, 889, 131, 347, 35, 35, 727,
   538  	504, 75, 365, -1000, 213, 200, 899, 203, -1000, 124,
   539  	181, 971, -1000, 88, 971, -1000, -1000, -18, -1000, 107,
   540  	4, -1000, 72, 935, -1000, 97, -1000, 108, 935, -1000,
   541  	971, 935, -1000, -1000, -1000, -1000, 22, -36, 157, 151,
   542  	365, -1000, 1005, 971, 211, 202, -1000, -1000, 148, 21,
   543  	21, -1000, -1000, -1000, 855, -1000, 590, 150, 971, 971,
   544  	-1000, -1000, 971, -1000, -1000, 590, 200, -1000, 4, 971,
   545  	43, 590, -1000, -1000, 590, -1000, 461, -1000, -37, -1000,
   546  	-1000, 365, -1000, 684, -1000, -1000, 75, 971, 179, 178,
   547  	-1000, 971, 590, 590, 133, 590, 58, 684, 971, 260,
   548  	-1000, -1000, -1000, 418, 971, 971, 590, -1000, 971, 197,
   549  	-1000, -1000, 143, 684, -1000, 971, 590, 590, 92, 210,
   550  	1, -18, 590, -1000, -1000, -1000, -1000,
   551  }
   552  
   553  var yyPgo = [...]int16{
   554  	0, 16, 11, 4, 12, 269, 266, 19, 261, 260,
   555  	8, 259, 258, 0, 2, 88, 18, 98, 257, 101,
   556  	15, 255, 14, 20, 6, 253, 5, 252, 248, 244,
   557  	242, 241, 7, 17, 240, 13, 237, 236, 1, 9,
   558  	234, 3, 230, 229, 227, 226, 225, 224,
   559  }
   560  
   561  var yyR1 = [...]int8{
   562  	0, 45, 39, 39, 46, 46, 40, 40, 40, 26,
   563  	26, 26, 26, 27, 27, 43, 44, 44, 28, 28,
   564  	28, 30, 30, 29, 29, 31, 31, 32, 34, 34,
   565  	33, 33, 33, 33, 33, 33, 33, 33, 47, 47,
   566  	16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
   567  	16, 16, 16, 16, 16, 6, 6, 5, 5, 4,
   568  	4, 4, 4, 42, 42, 41, 41, 9, 9, 12,
   569  	12, 8, 8, 11, 11, 7, 7, 7, 7, 7,
   570  	10, 10, 10, 10, 10, 17, 17, 18, 18, 13,
   571  	13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
   572  	13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
   573  	13, 13, 13, 13, 13, 13, 13, 13, 19, 19,
   574  	14, 14, 15, 15, 1, 1, 2, 2, 3, 3,
   575  	35, 37, 37, 36, 36, 36, 20, 20, 38, 24,
   576  	25, 25, 25, 25, 21, 22, 22, 23, 23,
   577  }
   578  
   579  var yyR2 = [...]int8{
   580  	0, 2, 5, 2, 0, 2, 0, 3, 2, 0,
   581  	2, 2, 3, 1, 1, 5, 1, 3, 3, 6,
   582  	1, 4, 5, 1, 4, 2, 1, 4, 0, 3,
   583  	1, 2, 1, 3, 3, 1, 1, 1, 0, 1,
   584  	1, 1, 1, 3, 8, 4, 4, 6, 8, 3,
   585  	4, 4, 3, 4, 3, 0, 2, 2, 3, 1,
   586  	3, 2, 2, 1, 3, 1, 3, 0, 2, 0,
   587  	2, 1, 3, 1, 3, 1, 3, 2, 1, 2,
   588  	1, 3, 5, 4, 4, 1, 3, 0, 1, 1,
   589  	4, 2, 2, 2, 2, 3, 3, 3, 3, 3,
   590  	3, 3, 3, 3, 3, 3, 3, 3, 4, 3,
   591  	3, 3, 3, 3, 3, 3, 3, 5, 1, 3,
   592  	0, 1, 0, 2, 0, 1, 1, 2, 0, 1,
   593  	3, 1, 3, 0, 1, 2, 1, 3, 1, 1,
   594  	3, 2, 2, 1, 4, 1, 3, 1, 2,
   595  }
   596  
   597  var yyChk = [...]int16{
   598  	-1000, -45, -26, 28, -27, 59, 27, -32, -28, -33,
   599  	-44, 30, -29, -17, 52, 53, 54, 55, -43, -30,
   600  	-13, 51, 34, -16, 39, 48, 10, 8, 24, -24,
   601  	-25, -38, 40, 17, 19, 5, 32, 33, 11, 50,
   602  	59, -34, 13, -20, -16, 15, 25, 9, -17, 47,
   603  	-31, 35, 36, 7, 4, 12, 44, 8, 10, 14,
   604  	16, 29, 41, 42, 31, 37, 48, 49, 26, 21,
   605  	22, 23, 45, 46, 38, 34, 32, -17, 11, 5,
   606  	17, -9, -8, -7, -24, 7, 43, -13, -13, -13,
   607  	-13, 5, -15, -13, -19, -35, -36, -19, -13, -37,
   608  	-15, -13, 11, 33, -47, 62, -39, 59, -32, 37,
   609  	9, -17, -17, -13, -13, -17, 13, 34, -13, -13,
   610  	-13, -13, -13, -13, -13, -13, -13, -13, -13, -13,
   611  	-13, 37, -13, -13, -13, -13, -13, -13, -13, -13,
   612  	-13, 5, 13, 32, -6, -5, -3, -2, 9, -17,
   613  	-18, 13, -1, 9, 15, -24, -24, -3, 18, -23,
   614  	-22, -21, 30, -2, -3, -23, 20, -1, -2, 9,
   615  	13, -2, 6, 33, 59, -33, -40, -46, -17, -16,
   616  	13, -39, -13, 35, -12, -11, -10, -7, -24, 7,
   617  	43, -39, 6, -3, -2, -4, -13, -24, 7, 43,
   618  	9, 18, 13, -17, -7, -13, -38, 18, -22, 34,
   619  	-20, -13, 20, 20, -13, -35, -13, 56, 27, 59,
   620  	59, 13, -39, -13, 6, -1, 9, 13, -24, -24,
   621  	-4, 15, -13, -13, -14, -13, -2, -13, 37, -26,
   622  	59, -39, -10, -13, 13, 13, -13, 18, 13, -42,
   623  	-41, -38, -24, -13, 57, 15, -13, -13, -14, -3,
   624  	9, 15, -13, 18, 6, -41, -38,
   625  }
   626  
   627  var yyDef = [...]int16{
   628  	9, -2, 0, 1, 10, 11, 0, 13, 14, 28,
   629  	0, 0, 20, 30, 32, 35, 36, 37, 16, 23,
   630  	85, 0, 0, 89, 67, 0, 0, 0, 0, 40,
   631  	41, 42, 0, 122, 133, 122, 139, 143, 0, 138,
   632  	12, 38, 0, 0, 136, 0, 0, 0, 31, 0,
   633  	0, 0, 26, 0, 0, 0, 0, 0, 0, 0,
   634  	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   635  	0, 0, 0, 0, 0, 0, 0, 0, 0, -2,
   636  	87, 0, 124, 71, 75, 78, 0, 91, 92, 93,
   637  	94, 128, 0, 118, 128, 131, 0, 124, 118, 134,
   638  	0, 118, 141, 142, 0, 39, 18, 6, 4, 0,
   639  	0, 33, 34, 86, 17, 0, 0, 25, 95, 96,
   640  	97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
   641  	107, 0, 109, 110, 111, 112, 113, 114, 115, 116,
   642  	0, 69, 0, 43, 0, 128, 0, 129, 126, 88,
   643  	0, 0, 68, 125, 0, 77, 79, 0, 49, 0,
   644  	147, 145, 0, 129, 123, 0, 52, 0, 0, -2,
   645  	0, 135, 54, 140, 27, 29, 0, 3, 0, 137,
   646  	0, 24, 108, 0, 0, 124, 73, 80, 75, 78,
   647  	0, 21, 45, 56, 129, 57, 59, 40, 0, 0,
   648  	127, 46, 120, 90, 72, 76, 0, 50, 148, 0,
   649  	0, 119, 51, 53, 130, 132, 0, 9, 0, 8,
   650  	5, 0, 22, 117, 15, 70, 125, 0, 77, 79,
   651  	58, 0, 61, 62, 0, 121, 0, 146, 0, 0,
   652  	7, 19, 74, 81, 0, 0, 60, 47, 120, 128,
   653  	63, 65, 0, 144, 2, 0, 83, 84, 0, 0,
   654  	126, 0, 82, 48, 44, 64, 66,
   655  }
   656  
   657  var yyTok1 = [...]int8{
   658  	1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   659  	59, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   660  	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   661  	3, 3, 3, 3, 3, 3, 3, 4, 22, 3,
   662  	5, 6, 7, 8, 9, 10, 11, 12, 3, 3,
   663  	3, 3, 3, 3, 3, 3, 3, 3, 13, 62,
   664  	14, 15, 16, 3, 3, 3, 3, 3, 3, 3,
   665  	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   666  	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   667  	3, 17, 3, 18, 23, 3, 3, 3, 3, 3,
   668  	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   669  	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   670  	3, 3, 3, 19, 21, 20, 24,
   671  }
   672  
   673  var yyTok2 = [...]int8{
   674  	2, 3, 25, 26, 27, 28, 29, 30, 31, 32,
   675  	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
   676  	43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
   677  	53, 54, 55, 56, 57, 58, 60, 61,
   678  }
   679  
   680  var yyTok3 = [...]int8{
   681  	0,
   682  }
   683  
   684  var yyErrorMessages = [...]struct {
   685  	state int
   686  	token int
   687  	msg   string
   688  }{}
   689  
   690  //line yaccpar:1
   691  
   692  /*	parser for yacc output	*/
   693  
   694  var (
   695  	yyDebug        = 0
   696  	yyErrorVerbose = false
   697  )
   698  
   699  type yyLexer interface {
   700  	Lex(lval *yySymType) int
   701  	Error(s string)
   702  }
   703  
   704  type yyParser interface {
   705  	Parse(yyLexer) int
   706  	Lookahead() int
   707  }
   708  
   709  type yyParserImpl struct {
   710  	lval  yySymType
   711  	stack [yyInitialStackSize]yySymType
   712  	char  int
   713  }
   714  
   715  func (p *yyParserImpl) Lookahead() int {
   716  	return p.char
   717  }
   718  
   719  func yyNewParser() yyParser {
   720  	return &yyParserImpl{}
   721  }
   722  
   723  const yyFlag = -1000
   724  
   725  func yyTokname(c int) string {
   726  	if c >= 1 && c-1 < len(yyToknames) {
   727  		if yyToknames[c-1] != "" {
   728  			return yyToknames[c-1]
   729  		}
   730  	}
   731  	return __yyfmt__.Sprintf("tok-%v", c)
   732  }
   733  
   734  func yyStatname(s int) string {
   735  	if s >= 0 && s < len(yyStatenames) {
   736  		if yyStatenames[s] != "" {
   737  			return yyStatenames[s]
   738  		}
   739  	}
   740  	return __yyfmt__.Sprintf("state-%v", s)
   741  }
   742  
   743  func yyErrorMessage(state, lookAhead int) string {
   744  	const TOKSTART = 4
   745  
   746  	if !yyErrorVerbose {
   747  		return "syntax error"
   748  	}
   749  
   750  	for _, e := range yyErrorMessages {
   751  		if e.state == state && e.token == lookAhead {
   752  			return "syntax error: " + e.msg
   753  		}
   754  	}
   755  
   756  	res := "syntax error: unexpected " + yyTokname(lookAhead)
   757  
   758  	// To match Bison, suggest at most four expected tokens.
   759  	expected := make([]int, 0, 4)
   760  
   761  	// Look for shiftable tokens.
   762  	base := int(yyPact[state])
   763  	for tok := TOKSTART; tok-1 < len(yyToknames); tok++ {
   764  		if n := base + tok; n >= 0 && n < yyLast && int(yyChk[int(yyAct[n])]) == tok {
   765  			if len(expected) == cap(expected) {
   766  				return res
   767  			}
   768  			expected = append(expected, tok)
   769  		}
   770  	}
   771  
   772  	if yyDef[state] == -2 {
   773  		i := 0
   774  		for yyExca[i] != -1 || int(yyExca[i+1]) != state {
   775  			i += 2
   776  		}
   777  
   778  		// Look for tokens that we accept or reduce.
   779  		for i += 2; yyExca[i] >= 0; i += 2 {
   780  			tok := int(yyExca[i])
   781  			if tok < TOKSTART || yyExca[i+1] == 0 {
   782  				continue
   783  			}
   784  			if len(expected) == cap(expected) {
   785  				return res
   786  			}
   787  			expected = append(expected, tok)
   788  		}
   789  
   790  		// If the default action is to accept or reduce, give up.
   791  		if yyExca[i+1] != 0 {
   792  			return res
   793  		}
   794  	}
   795  
   796  	for i, tok := range expected {
   797  		if i == 0 {
   798  			res += ", expecting "
   799  		} else {
   800  			res += " or "
   801  		}
   802  		res += yyTokname(tok)
   803  	}
   804  	return res
   805  }
   806  
   807  func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
   808  	token = 0
   809  	char = lex.Lex(lval)
   810  	if char <= 0 {
   811  		token = int(yyTok1[0])
   812  		goto out
   813  	}
   814  	if char < len(yyTok1) {
   815  		token = int(yyTok1[char])
   816  		goto out
   817  	}
   818  	if char >= yyPrivate {
   819  		if char < yyPrivate+len(yyTok2) {
   820  			token = int(yyTok2[char-yyPrivate])
   821  			goto out
   822  		}
   823  	}
   824  	for i := 0; i < len(yyTok3); i += 2 {
   825  		token = int(yyTok3[i+0])
   826  		if token == char {
   827  			token = int(yyTok3[i+1])
   828  			goto out
   829  		}
   830  	}
   831  
   832  out:
   833  	if token == 0 {
   834  		token = int(yyTok2[1]) /* unknown char */
   835  	}
   836  	if yyDebug >= 3 {
   837  		__yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
   838  	}
   839  	return char, token
   840  }
   841  
   842  func yyParse(yylex yyLexer) int {
   843  	return yyNewParser().Parse(yylex)
   844  }
   845  
   846  func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int {
   847  	var yyn int
   848  	var yyVAL yySymType
   849  	var yyDollar []yySymType
   850  	_ = yyDollar // silence set and not used
   851  	yyS := yyrcvr.stack[:]
   852  
   853  	Nerrs := 0   /* number of errors */
   854  	Errflag := 0 /* error recovery flag */
   855  	yystate := 0
   856  	yyrcvr.char = -1
   857  	yytoken := -1 // yyrcvr.char translated into internal numbering
   858  	defer func() {
   859  		// Make sure we report no lookahead when not parsing.
   860  		yystate = -1
   861  		yyrcvr.char = -1
   862  		yytoken = -1
   863  	}()
   864  	yyp := -1
   865  	goto yystack
   866  
   867  ret0:
   868  	return 0
   869  
   870  ret1:
   871  	return 1
   872  
   873  yystack:
   874  	/* put a state and value onto the stack */
   875  	if yyDebug >= 4 {
   876  		__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
   877  	}
   878  
   879  	yyp++
   880  	if yyp >= len(yyS) {
   881  		nyys := make([]yySymType, len(yyS)*2)
   882  		copy(nyys, yyS)
   883  		yyS = nyys
   884  	}
   885  	yyS[yyp] = yyVAL
   886  	yyS[yyp].yys = yystate
   887  
   888  yynewstate:
   889  	yyn = int(yyPact[yystate])
   890  	if yyn <= yyFlag {
   891  		goto yydefault /* simple state */
   892  	}
   893  	if yyrcvr.char < 0 {
   894  		yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
   895  	}
   896  	yyn += yytoken
   897  	if yyn < 0 || yyn >= yyLast {
   898  		goto yydefault
   899  	}
   900  	yyn = int(yyAct[yyn])
   901  	if int(yyChk[yyn]) == yytoken { /* valid shift */
   902  		yyrcvr.char = -1
   903  		yytoken = -1
   904  		yyVAL = yyrcvr.lval
   905  		yystate = yyn
   906  		if Errflag > 0 {
   907  			Errflag--
   908  		}
   909  		goto yystack
   910  	}
   911  
   912  yydefault:
   913  	/* default state action */
   914  	yyn = int(yyDef[yystate])
   915  	if yyn == -2 {
   916  		if yyrcvr.char < 0 {
   917  			yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
   918  		}
   919  
   920  		/* look through exception table */
   921  		xi := 0
   922  		for {
   923  			if yyExca[xi+0] == -1 && int(yyExca[xi+1]) == yystate {
   924  				break
   925  			}
   926  			xi += 2
   927  		}
   928  		for xi += 2; ; xi += 2 {
   929  			yyn = int(yyExca[xi+0])
   930  			if yyn < 0 || yyn == yytoken {
   931  				break
   932  			}
   933  		}
   934  		yyn = int(yyExca[xi+1])
   935  		if yyn < 0 {
   936  			goto ret0
   937  		}
   938  	}
   939  	if yyn == 0 {
   940  		/* error ... attempt to resume parsing */
   941  		switch Errflag {
   942  		case 0: /* brand new error */
   943  			yylex.Error(yyErrorMessage(yystate, yytoken))
   944  			Nerrs++
   945  			if yyDebug >= 1 {
   946  				__yyfmt__.Printf("%s", yyStatname(yystate))
   947  				__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
   948  			}
   949  			fallthrough
   950  
   951  		case 1, 2: /* incompletely recovered error ... try again */
   952  			Errflag = 3
   953  
   954  			/* find a state where "error" is a legal shift action */
   955  			for yyp >= 0 {
   956  				yyn = int(yyPact[yyS[yyp].yys]) + yyErrCode
   957  				if yyn >= 0 && yyn < yyLast {
   958  					yystate = int(yyAct[yyn]) /* simulate a shift of "error" */
   959  					if int(yyChk[yystate]) == yyErrCode {
   960  						goto yystack
   961  					}
   962  				}
   963  
   964  				/* the current p has no shift on "error", pop stack */
   965  				if yyDebug >= 2 {
   966  					__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
   967  				}
   968  				yyp--
   969  			}
   970  			/* there is no state on the stack with an error shift ... abort */
   971  			goto ret1
   972  
   973  		case 3: /* no shift yet; clobber input char */
   974  			if yyDebug >= 2 {
   975  				__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
   976  			}
   977  			if yytoken == yyEofCode {
   978  				goto ret1
   979  			}
   980  			yyrcvr.char = -1
   981  			yytoken = -1
   982  			goto yynewstate /* try again in the same state */
   983  		}
   984  	}
   985  
   986  	/* reduction by production yyn */
   987  	if yyDebug >= 2 {
   988  		__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
   989  	}
   990  
   991  	yynt := yyn
   992  	yypt := yyp
   993  	_ = yypt // guard against "declared and not used"
   994  
   995  	yyp -= int(yyR2[yyn])
   996  	// yyp is now the index of $0. Perform the default action. Iff the
   997  	// reduced production is ε, $1 is possibly out of range.
   998  	if yyp+1 >= len(yyS) {
   999  		nyys := make([]yySymType, len(yyS)*2)
  1000  		copy(nyys, yyS)
  1001  		yyS = nyys
  1002  	}
  1003  	yyVAL = yyS[yyp+1]
  1004  
  1005  	/* consult goto table to find next state */
  1006  	yyn = int(yyR1[yyn])
  1007  	yyg := int(yyPgo[yyn])
  1008  	yyj := yyg + yyS[yyp].yys + 1
  1009  
  1010  	if yyj >= yyLast {
  1011  		yystate = int(yyAct[yyg])
  1012  	} else {
  1013  		yystate = int(yyAct[yyj])
  1014  		if int(yyChk[yystate]) != -yyn {
  1015  			yystate = int(yyAct[yyg])
  1016  		}
  1017  	}
  1018  	// dummy call; replaced with literal code
  1019  	switch yynt {
  1020  
  1021  	case 1:
  1022  		yyDollar = yyS[yypt-2 : yypt+1]
  1023  //line build/parse.y:218
  1024  		{
  1025  			yylex.(*input).file = &File{Stmt: yyDollar[1].exprs}
  1026  			return 0
  1027  		}
  1028  	case 2:
  1029  		yyDollar = yyS[yypt-5 : yypt+1]
  1030  //line build/parse.y:225
  1031  		{
  1032  			statements := yyDollar[4].exprs
  1033  			if yyDollar[2].exprs != nil {
  1034  				// $2 can only contain *CommentBlock objects, each of them contains a non-empty After slice
  1035  				cb := yyDollar[2].exprs[len(yyDollar[2].exprs)-1].(*CommentBlock)
  1036  				// $4 can't be empty and can't start with a comment
  1037  				stmt := yyDollar[4].exprs[0]
  1038  				start, _ := stmt.Span()
  1039  				if start.Line-cb.After[len(cb.After)-1].Start.Line == 1 {
  1040  					// The first statement of $4 starts on the next line after the last comment of $2.
  1041  					// Attach the last comment to the first statement
  1042  					stmt.Comment().Before = cb.After
  1043  					yyDollar[2].exprs = yyDollar[2].exprs[:len(yyDollar[2].exprs)-1]
  1044  				}
  1045  				statements = append(yyDollar[2].exprs, yyDollar[4].exprs...)
  1046  			}
  1047  			yyVAL.exprs = statements
  1048  			yyVAL.lastStmt = yyDollar[4].lastStmt
  1049  		}
  1050  	case 3:
  1051  		yyDollar = yyS[yypt-2 : yypt+1]
  1052  //line build/parse.y:245
  1053  		{
  1054  			yyVAL.exprs = yyDollar[1].exprs
  1055  		}
  1056  	case 6:
  1057  		yyDollar = yyS[yypt-0 : yypt+1]
  1058  //line build/parse.y:253
  1059  		{
  1060  			yyVAL.exprs = nil
  1061  			yyVAL.lastStmt = nil
  1062  		}
  1063  	case 7:
  1064  		yyDollar = yyS[yypt-3 : yypt+1]
  1065  //line build/parse.y:258
  1066  		{
  1067  			yyVAL.exprs = yyDollar[1].exprs
  1068  			yyVAL.lastStmt = yyDollar[1].lastStmt
  1069  			if yyVAL.lastStmt == nil {
  1070  				cb := &CommentBlock{Start: yyDollar[2].pos}
  1071  				yyVAL.exprs = append(yyVAL.exprs, cb)
  1072  				yyVAL.lastStmt = cb
  1073  			}
  1074  			com := yyVAL.lastStmt.Comment()
  1075  			com.After = append(com.After, Comment{Start: yyDollar[2].pos, Token: yyDollar[2].tok})
  1076  		}
  1077  	case 8:
  1078  		yyDollar = yyS[yypt-2 : yypt+1]
  1079  //line build/parse.y:270
  1080  		{
  1081  			yyVAL.exprs = yyDollar[1].exprs
  1082  			yyVAL.lastStmt = nil
  1083  		}
  1084  	case 9:
  1085  		yyDollar = yyS[yypt-0 : yypt+1]
  1086  //line build/parse.y:276
  1087  		{
  1088  			yyVAL.exprs = nil
  1089  			yyVAL.lastStmt = nil
  1090  		}
  1091  	case 10:
  1092  		yyDollar = yyS[yypt-2 : yypt+1]
  1093  //line build/parse.y:281
  1094  		{
  1095  			// If this statement follows a comment block,
  1096  			// attach the comments to the statement.
  1097  			if cb, ok := yyDollar[1].lastStmt.(*CommentBlock); ok {
  1098  				yyVAL.exprs = append(yyDollar[1].exprs[:len(yyDollar[1].exprs)-1], yyDollar[2].exprs...)
  1099  				yyDollar[2].exprs[0].Comment().Before = cb.After
  1100  				yyVAL.lastStmt = yyDollar[2].lastStmt
  1101  				break
  1102  			}
  1103  
  1104  			// Otherwise add to list.
  1105  			yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[2].exprs...)
  1106  			yyVAL.lastStmt = yyDollar[2].lastStmt
  1107  
  1108  			// Consider this input:
  1109  			//
  1110  			//	foo()
  1111  			//	# bar
  1112  			//	baz()
  1113  			//
  1114  			// If we've just parsed baz(), the # bar is attached to
  1115  			// foo() as an After comment. Make it a Before comment
  1116  			// for baz() instead.
  1117  			if x := yyDollar[1].lastStmt; x != nil {
  1118  				com := x.Comment()
  1119  				// stmt is never empty
  1120  				yyDollar[2].exprs[0].Comment().Before = com.After
  1121  				com.After = nil
  1122  			}
  1123  		}
  1124  	case 11:
  1125  		yyDollar = yyS[yypt-2 : yypt+1]
  1126  //line build/parse.y:312
  1127  		{
  1128  			// Blank line; sever last rule from future comments.
  1129  			yyVAL.exprs = yyDollar[1].exprs
  1130  			yyVAL.lastStmt = nil
  1131  		}
  1132  	case 12:
  1133  		yyDollar = yyS[yypt-3 : yypt+1]
  1134  //line build/parse.y:318
  1135  		{
  1136  			yyVAL.exprs = yyDollar[1].exprs
  1137  			yyVAL.lastStmt = yyDollar[1].lastStmt
  1138  			if yyVAL.lastStmt == nil {
  1139  				cb := &CommentBlock{Start: yyDollar[2].pos}
  1140  				yyVAL.exprs = append(yyVAL.exprs, cb)
  1141  				yyVAL.lastStmt = cb
  1142  			}
  1143  			com := yyVAL.lastStmt.Comment()
  1144  			com.After = append(com.After, Comment{Start: yyDollar[2].pos, Token: yyDollar[2].tok})
  1145  		}
  1146  	case 13:
  1147  		yyDollar = yyS[yypt-1 : yypt+1]
  1148  //line build/parse.y:332
  1149  		{
  1150  			yyVAL.exprs = yyDollar[1].exprs
  1151  			yyVAL.lastStmt = yyDollar[1].exprs[len(yyDollar[1].exprs)-1]
  1152  		}
  1153  	case 14:
  1154  		yyDollar = yyS[yypt-1 : yypt+1]
  1155  //line build/parse.y:337
  1156  		{
  1157  			yyVAL.exprs = []Expr{yyDollar[1].expr}
  1158  			yyVAL.lastStmt = yyDollar[1].expr
  1159  			if cbs := extractTrailingComments(yyDollar[1].expr); len(cbs) > 0 {
  1160  				yyVAL.exprs = append(yyVAL.exprs, cbs...)
  1161  				yyVAL.lastStmt = cbs[len(cbs)-1]
  1162  				if yyDollar[1].lastStmt == nil {
  1163  					yyVAL.lastStmt = nil
  1164  				}
  1165  			}
  1166  		}
  1167  	case 15:
  1168  		yyDollar = yyS[yypt-5 : yypt+1]
  1169  //line build/parse.y:351
  1170  		{
  1171  			yyVAL.def_header = &DefStmt{
  1172  				Function: Function{
  1173  					StartPos: yyDollar[1].pos,
  1174  					Params:   yyDollar[4].exprs,
  1175  				},
  1176  				Name:           yyDollar[2].tok,
  1177  				ForceCompact:   forceCompact(yyDollar[3].pos, yyDollar[4].exprs, yyDollar[5].pos),
  1178  				ForceMultiLine: forceMultiLine(yyDollar[3].pos, yyDollar[4].exprs, yyDollar[5].pos),
  1179  			}
  1180  		}
  1181  	case 17:
  1182  		yyDollar = yyS[yypt-3 : yypt+1]
  1183  //line build/parse.y:366
  1184  		{
  1185  			yyDollar[1].def_header.Type = yyDollar[3].expr
  1186  			yyVAL.def_header = yyDollar[1].def_header
  1187  		}
  1188  	case 18:
  1189  		yyDollar = yyS[yypt-3 : yypt+1]
  1190  //line build/parse.y:373
  1191  		{
  1192  			yyDollar[1].def_header.Function.Body = yyDollar[3].exprs
  1193  			yyDollar[1].def_header.ColonPos = yyDollar[2].pos
  1194  			yyVAL.expr = yyDollar[1].def_header
  1195  			yyVAL.lastStmt = yyDollar[3].lastStmt
  1196  		}
  1197  	case 19:
  1198  		yyDollar = yyS[yypt-6 : yypt+1]
  1199  //line build/parse.y:380
  1200  		{
  1201  			yyVAL.expr = &ForStmt{
  1202  				For:  yyDollar[1].pos,
  1203  				Vars: yyDollar[2].expr,
  1204  				X:    yyDollar[4].expr,
  1205  				Body: yyDollar[6].exprs,
  1206  			}
  1207  			yyVAL.lastStmt = yyDollar[6].lastStmt
  1208  		}
  1209  	case 20:
  1210  		yyDollar = yyS[yypt-1 : yypt+1]
  1211  //line build/parse.y:390
  1212  		{
  1213  			yyVAL.expr = yyDollar[1].ifstmt
  1214  			yyVAL.lastStmt = yyDollar[1].lastStmt
  1215  		}
  1216  	case 21:
  1217  		yyDollar = yyS[yypt-4 : yypt+1]
  1218  //line build/parse.y:398
  1219  		{
  1220  			yyVAL.ifstmt = &IfStmt{
  1221  				If:   yyDollar[1].pos,
  1222  				Cond: yyDollar[2].expr,
  1223  				True: yyDollar[4].exprs,
  1224  			}
  1225  			yyVAL.lastStmt = yyDollar[4].lastStmt
  1226  		}
  1227  	case 22:
  1228  		yyDollar = yyS[yypt-5 : yypt+1]
  1229  //line build/parse.y:407
  1230  		{
  1231  			yyVAL.ifstmt = yyDollar[1].ifstmt
  1232  			inner := yyDollar[1].ifstmt
  1233  			for len(inner.False) == 1 {
  1234  				inner = inner.False[0].(*IfStmt)
  1235  			}
  1236  			inner.ElsePos = End{Pos: yyDollar[2].pos}
  1237  			inner.False = []Expr{
  1238  				&IfStmt{
  1239  					If:   yyDollar[2].pos,
  1240  					Cond: yyDollar[3].expr,
  1241  					True: yyDollar[5].exprs,
  1242  				},
  1243  			}
  1244  			yyVAL.lastStmt = yyDollar[5].lastStmt
  1245  		}
  1246  	case 24:
  1247  		yyDollar = yyS[yypt-4 : yypt+1]
  1248  //line build/parse.y:428
  1249  		{
  1250  			yyVAL.ifstmt = yyDollar[1].ifstmt
  1251  			inner := yyDollar[1].ifstmt
  1252  			for len(inner.False) == 1 {
  1253  				inner = inner.False[0].(*IfStmt)
  1254  			}
  1255  			inner.ElsePos = End{Pos: yyDollar[2].pos}
  1256  			inner.False = yyDollar[4].exprs
  1257  			yyVAL.lastStmt = yyDollar[4].lastStmt
  1258  		}
  1259  	case 27:
  1260  		yyDollar = yyS[yypt-4 : yypt+1]
  1261  //line build/parse.y:445
  1262  		{
  1263  			yyVAL.exprs = append([]Expr{yyDollar[1].expr}, yyDollar[2].exprs...)
  1264  			yyVAL.lastStmt = yyVAL.exprs[len(yyVAL.exprs)-1]
  1265  		}
  1266  	case 28:
  1267  		yyDollar = yyS[yypt-0 : yypt+1]
  1268  //line build/parse.y:451
  1269  		{
  1270  			yyVAL.exprs = []Expr{}
  1271  		}
  1272  	case 29:
  1273  		yyDollar = yyS[yypt-3 : yypt+1]
  1274  //line build/parse.y:455
  1275  		{
  1276  			yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr)
  1277  		}
  1278  	case 31:
  1279  		yyDollar = yyS[yypt-2 : yypt+1]
  1280  //line build/parse.y:462
  1281  		{
  1282  			yyVAL.expr = &ReturnStmt{
  1283  				Return: yyDollar[1].pos,
  1284  				Result: yyDollar[2].expr,
  1285  			}
  1286  		}
  1287  	case 32:
  1288  		yyDollar = yyS[yypt-1 : yypt+1]
  1289  //line build/parse.y:469
  1290  		{
  1291  			yyVAL.expr = &ReturnStmt{
  1292  				Return: yyDollar[1].pos,
  1293  			}
  1294  		}
  1295  	case 33:
  1296  		yyDollar = yyS[yypt-3 : yypt+1]
  1297  //line build/parse.y:474
  1298  		{
  1299  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1300  		}
  1301  	case 34:
  1302  		yyDollar = yyS[yypt-3 : yypt+1]
  1303  //line build/parse.y:475
  1304  		{
  1305  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1306  		}
  1307  	case 35:
  1308  		yyDollar = yyS[yypt-1 : yypt+1]
  1309  //line build/parse.y:477
  1310  		{
  1311  			yyVAL.expr = &BranchStmt{
  1312  				Token:    yyDollar[1].tok,
  1313  				TokenPos: yyDollar[1].pos,
  1314  			}
  1315  		}
  1316  	case 36:
  1317  		yyDollar = yyS[yypt-1 : yypt+1]
  1318  //line build/parse.y:484
  1319  		{
  1320  			yyVAL.expr = &BranchStmt{
  1321  				Token:    yyDollar[1].tok,
  1322  				TokenPos: yyDollar[1].pos,
  1323  			}
  1324  		}
  1325  	case 37:
  1326  		yyDollar = yyS[yypt-1 : yypt+1]
  1327  //line build/parse.y:491
  1328  		{
  1329  			yyVAL.expr = &BranchStmt{
  1330  				Token:    yyDollar[1].tok,
  1331  				TokenPos: yyDollar[1].pos,
  1332  			}
  1333  		}
  1334  	case 42:
  1335  		yyDollar = yyS[yypt-1 : yypt+1]
  1336  //line build/parse.y:505
  1337  		{
  1338  			yyVAL.expr = yyDollar[1].string
  1339  		}
  1340  	case 43:
  1341  		yyDollar = yyS[yypt-3 : yypt+1]
  1342  //line build/parse.y:509
  1343  		{
  1344  			yyVAL.expr = &DotExpr{
  1345  				X:       yyDollar[1].expr,
  1346  				Dot:     yyDollar[2].pos,
  1347  				NamePos: yyDollar[3].pos,
  1348  				Name:    yyDollar[3].tok,
  1349  			}
  1350  		}
  1351  	case 44:
  1352  		yyDollar = yyS[yypt-8 : yypt+1]
  1353  //line build/parse.y:518
  1354  		{
  1355  			load := &LoadStmt{
  1356  				Load:         yyDollar[1].pos,
  1357  				Module:       yyDollar[4].string,
  1358  				Rparen:       End{Pos: yyDollar[8].pos},
  1359  				ForceCompact: yyDollar[2].pos.Line == yyDollar[8].pos.Line,
  1360  			}
  1361  			for _, arg := range yyDollar[6].loadargs {
  1362  				load.From = append(load.From, &arg.from)
  1363  				load.To = append(load.To, &arg.to)
  1364  			}
  1365  			yyVAL.expr = load
  1366  		}
  1367  	case 45:
  1368  		yyDollar = yyS[yypt-4 : yypt+1]
  1369  //line build/parse.y:532
  1370  		{
  1371  			yyVAL.expr = &CallExpr{
  1372  				X:              yyDollar[1].expr,
  1373  				ListStart:      yyDollar[2].pos,
  1374  				List:           yyDollar[3].exprs,
  1375  				End:            End{Pos: yyDollar[4].pos},
  1376  				ForceCompact:   forceCompact(yyDollar[2].pos, yyDollar[3].exprs, yyDollar[4].pos),
  1377  				ForceMultiLine: forceMultiLine(yyDollar[2].pos, yyDollar[3].exprs, yyDollar[4].pos),
  1378  			}
  1379  		}
  1380  	case 46:
  1381  		yyDollar = yyS[yypt-4 : yypt+1]
  1382  //line build/parse.y:543
  1383  		{
  1384  			yyVAL.expr = &IndexExpr{
  1385  				X:          yyDollar[1].expr,
  1386  				IndexStart: yyDollar[2].pos,
  1387  				Y:          yyDollar[3].expr,
  1388  				End:        yyDollar[4].pos,
  1389  			}
  1390  		}
  1391  	case 47:
  1392  		yyDollar = yyS[yypt-6 : yypt+1]
  1393  //line build/parse.y:552
  1394  		{
  1395  			yyVAL.expr = &SliceExpr{
  1396  				X:          yyDollar[1].expr,
  1397  				SliceStart: yyDollar[2].pos,
  1398  				From:       yyDollar[3].expr,
  1399  				FirstColon: yyDollar[4].pos,
  1400  				To:         yyDollar[5].expr,
  1401  				End:        yyDollar[6].pos,
  1402  			}
  1403  		}
  1404  	case 48:
  1405  		yyDollar = yyS[yypt-8 : yypt+1]
  1406  //line build/parse.y:563
  1407  		{
  1408  			yyVAL.expr = &SliceExpr{
  1409  				X:           yyDollar[1].expr,
  1410  				SliceStart:  yyDollar[2].pos,
  1411  				From:        yyDollar[3].expr,
  1412  				FirstColon:  yyDollar[4].pos,
  1413  				To:          yyDollar[5].expr,
  1414  				SecondColon: yyDollar[6].pos,
  1415  				Step:        yyDollar[7].expr,
  1416  				End:         yyDollar[8].pos,
  1417  			}
  1418  		}
  1419  	case 49:
  1420  		yyDollar = yyS[yypt-3 : yypt+1]
  1421  //line build/parse.y:576
  1422  		{
  1423  			yyVAL.expr = &ListExpr{
  1424  				Start:          yyDollar[1].pos,
  1425  				List:           yyDollar[2].exprs,
  1426  				End:            End{Pos: yyDollar[3].pos},
  1427  				ForceMultiLine: forceMultiLine(yyDollar[1].pos, yyDollar[2].exprs, yyDollar[3].pos),
  1428  			}
  1429  		}
  1430  	case 50:
  1431  		yyDollar = yyS[yypt-4 : yypt+1]
  1432  //line build/parse.y:585
  1433  		{
  1434  			yyVAL.expr = &Comprehension{
  1435  				Curly:          false,
  1436  				Lbrack:         yyDollar[1].pos,
  1437  				Body:           yyDollar[2].expr,
  1438  				Clauses:        yyDollar[3].exprs,
  1439  				End:            End{Pos: yyDollar[4].pos},
  1440  				ForceMultiLine: forceMultiLineComprehension(yyDollar[1].pos, yyDollar[2].expr, yyDollar[3].exprs, yyDollar[4].pos),
  1441  			}
  1442  		}
  1443  	case 51:
  1444  		yyDollar = yyS[yypt-4 : yypt+1]
  1445  //line build/parse.y:596
  1446  		{
  1447  			yyVAL.expr = &Comprehension{
  1448  				Curly:          true,
  1449  				Lbrack:         yyDollar[1].pos,
  1450  				Body:           yyDollar[2].kv,
  1451  				Clauses:        yyDollar[3].exprs,
  1452  				End:            End{Pos: yyDollar[4].pos},
  1453  				ForceMultiLine: forceMultiLineComprehension(yyDollar[1].pos, yyDollar[2].kv, yyDollar[3].exprs, yyDollar[4].pos),
  1454  			}
  1455  		}
  1456  	case 52:
  1457  		yyDollar = yyS[yypt-3 : yypt+1]
  1458  //line build/parse.y:607
  1459  		{
  1460  			exprValues := make([]Expr, 0, len(yyDollar[2].kvs))
  1461  			for _, kv := range yyDollar[2].kvs {
  1462  				exprValues = append(exprValues, Expr(kv))
  1463  			}
  1464  			yyVAL.expr = &DictExpr{
  1465  				Start:          yyDollar[1].pos,
  1466  				List:           yyDollar[2].kvs,
  1467  				End:            End{Pos: yyDollar[3].pos},
  1468  				ForceMultiLine: forceMultiLine(yyDollar[1].pos, exprValues, yyDollar[3].pos),
  1469  			}
  1470  		}
  1471  	case 53:
  1472  		yyDollar = yyS[yypt-4 : yypt+1]
  1473  //line build/parse.y:620
  1474  		{
  1475  			yyVAL.expr = &SetExpr{
  1476  				Start:          yyDollar[1].pos,
  1477  				List:           yyDollar[2].exprs,
  1478  				End:            End{Pos: yyDollar[4].pos},
  1479  				ForceMultiLine: forceMultiLine(yyDollar[1].pos, yyDollar[2].exprs, yyDollar[4].pos),
  1480  			}
  1481  		}
  1482  	case 54:
  1483  		yyDollar = yyS[yypt-3 : yypt+1]
  1484  //line build/parse.y:629
  1485  		{
  1486  			if len(yyDollar[2].exprs) == 1 && yyDollar[2].comma.Line == 0 {
  1487  				// Just a parenthesized expression, not a tuple.
  1488  				yyVAL.expr = &ParenExpr{
  1489  					Start:          yyDollar[1].pos,
  1490  					X:              yyDollar[2].exprs[0],
  1491  					End:            End{Pos: yyDollar[3].pos},
  1492  					ForceMultiLine: forceMultiLine(yyDollar[1].pos, yyDollar[2].exprs, yyDollar[3].pos),
  1493  				}
  1494  			} else {
  1495  				yyVAL.expr = &TupleExpr{
  1496  					Start:          yyDollar[1].pos,
  1497  					List:           yyDollar[2].exprs,
  1498  					End:            End{Pos: yyDollar[3].pos},
  1499  					ForceCompact:   forceCompact(yyDollar[1].pos, yyDollar[2].exprs, yyDollar[3].pos),
  1500  					ForceMultiLine: forceMultiLine(yyDollar[1].pos, yyDollar[2].exprs, yyDollar[3].pos),
  1501  				}
  1502  			}
  1503  		}
  1504  	case 55:
  1505  		yyDollar = yyS[yypt-0 : yypt+1]
  1506  //line build/parse.y:650
  1507  		{
  1508  			yyVAL.exprs = nil
  1509  		}
  1510  	case 56:
  1511  		yyDollar = yyS[yypt-2 : yypt+1]
  1512  //line build/parse.y:654
  1513  		{
  1514  			yyVAL.exprs = yyDollar[1].exprs
  1515  		}
  1516  	case 57:
  1517  		yyDollar = yyS[yypt-2 : yypt+1]
  1518  //line build/parse.y:660
  1519  		{
  1520  			yyVAL.exprs = []Expr{yyDollar[2].expr}
  1521  		}
  1522  	case 58:
  1523  		yyDollar = yyS[yypt-3 : yypt+1]
  1524  //line build/parse.y:664
  1525  		{
  1526  			yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr)
  1527  		}
  1528  	case 60:
  1529  		yyDollar = yyS[yypt-3 : yypt+1]
  1530  //line build/parse.y:671
  1531  		{
  1532  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1533  		}
  1534  	case 61:
  1535  		yyDollar = yyS[yypt-2 : yypt+1]
  1536  //line build/parse.y:675
  1537  		{
  1538  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1539  		}
  1540  	case 62:
  1541  		yyDollar = yyS[yypt-2 : yypt+1]
  1542  //line build/parse.y:679
  1543  		{
  1544  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1545  		}
  1546  	case 63:
  1547  		yyDollar = yyS[yypt-1 : yypt+1]
  1548  //line build/parse.y:684
  1549  		{
  1550  			yyVAL.loadargs = []*struct {
  1551  				from Ident
  1552  				to   Ident
  1553  			}{yyDollar[1].loadarg}
  1554  		}
  1555  	case 64:
  1556  		yyDollar = yyS[yypt-3 : yypt+1]
  1557  //line build/parse.y:688
  1558  		{
  1559  			yyDollar[1].loadargs = append(yyDollar[1].loadargs, yyDollar[3].loadarg)
  1560  			yyVAL.loadargs = yyDollar[1].loadargs
  1561  		}
  1562  	case 65:
  1563  		yyDollar = yyS[yypt-1 : yypt+1]
  1564  //line build/parse.y:694
  1565  		{
  1566  			start := yyDollar[1].string.Start.add("'")
  1567  			if yyDollar[1].string.TripleQuote {
  1568  				start = start.add("''")
  1569  			}
  1570  			yyVAL.loadarg = &struct {
  1571  				from Ident
  1572  				to   Ident
  1573  			}{
  1574  				from: Ident{
  1575  					Name:    yyDollar[1].string.Value,
  1576  					NamePos: start,
  1577  				},
  1578  				to: Ident{
  1579  					Name:    yyDollar[1].string.Value,
  1580  					NamePos: start,
  1581  				},
  1582  			}
  1583  		}
  1584  	case 66:
  1585  		yyDollar = yyS[yypt-3 : yypt+1]
  1586  //line build/parse.y:711
  1587  		{
  1588  			start := yyDollar[3].string.Start.add("'")
  1589  			if yyDollar[3].string.TripleQuote {
  1590  				start = start.add("''")
  1591  			}
  1592  			yyVAL.loadarg = &struct {
  1593  				from Ident
  1594  				to   Ident
  1595  			}{
  1596  				from: Ident{
  1597  					Name:    yyDollar[3].string.Value,
  1598  					NamePos: start,
  1599  				},
  1600  				to: *yyDollar[1].expr.(*Ident),
  1601  			}
  1602  		}
  1603  	case 67:
  1604  		yyDollar = yyS[yypt-0 : yypt+1]
  1605  //line build/parse.y:726
  1606  		{
  1607  			yyVAL.exprs = nil
  1608  		}
  1609  	case 68:
  1610  		yyDollar = yyS[yypt-2 : yypt+1]
  1611  //line build/parse.y:730
  1612  		{
  1613  			yyVAL.exprs = yyDollar[1].exprs
  1614  		}
  1615  	case 69:
  1616  		yyDollar = yyS[yypt-0 : yypt+1]
  1617  //line build/parse.y:735
  1618  		{
  1619  			yyVAL.exprs = nil
  1620  		}
  1621  	case 70:
  1622  		yyDollar = yyS[yypt-2 : yypt+1]
  1623  //line build/parse.y:739
  1624  		{
  1625  			yyVAL.exprs = yyDollar[1].exprs
  1626  		}
  1627  	case 71:
  1628  		yyDollar = yyS[yypt-1 : yypt+1]
  1629  //line build/parse.y:745
  1630  		{
  1631  			yyVAL.exprs = []Expr{yyDollar[1].expr}
  1632  		}
  1633  	case 72:
  1634  		yyDollar = yyS[yypt-3 : yypt+1]
  1635  //line build/parse.y:749
  1636  		{
  1637  			yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr)
  1638  		}
  1639  	case 73:
  1640  		yyDollar = yyS[yypt-1 : yypt+1]
  1641  //line build/parse.y:756
  1642  		{
  1643  			yyVAL.exprs = []Expr{yyDollar[1].expr}
  1644  		}
  1645  	case 74:
  1646  		yyDollar = yyS[yypt-3 : yypt+1]
  1647  //line build/parse.y:760
  1648  		{
  1649  			yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr)
  1650  		}
  1651  	case 76:
  1652  		yyDollar = yyS[yypt-3 : yypt+1]
  1653  //line build/parse.y:767
  1654  		{
  1655  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1656  		}
  1657  	case 77:
  1658  		yyDollar = yyS[yypt-2 : yypt+1]
  1659  //line build/parse.y:771
  1660  		{
  1661  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1662  		}
  1663  	case 78:
  1664  		yyDollar = yyS[yypt-1 : yypt+1]
  1665  //line build/parse.y:775
  1666  		{
  1667  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, nil)
  1668  		}
  1669  	case 79:
  1670  		yyDollar = yyS[yypt-2 : yypt+1]
  1671  //line build/parse.y:779
  1672  		{
  1673  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1674  		}
  1675  	case 81:
  1676  		yyDollar = yyS[yypt-3 : yypt+1]
  1677  //line build/parse.y:788
  1678  		{
  1679  			yyVAL.expr = typed(yyDollar[1].expr, yyDollar[3].expr)
  1680  		}
  1681  	case 82:
  1682  		yyDollar = yyS[yypt-5 : yypt+1]
  1683  //line build/parse.y:792
  1684  		{
  1685  			yyVAL.expr = binary(typed(yyDollar[1].expr, yyDollar[3].expr), yyDollar[4].pos, yyDollar[4].tok, yyDollar[5].expr)
  1686  		}
  1687  	case 83:
  1688  		yyDollar = yyS[yypt-4 : yypt+1]
  1689  //line build/parse.y:796
  1690  		{
  1691  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, typed(yyDollar[2].expr, yyDollar[4].expr))
  1692  		}
  1693  	case 84:
  1694  		yyDollar = yyS[yypt-4 : yypt+1]
  1695  //line build/parse.y:800
  1696  		{
  1697  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, typed(yyDollar[2].expr, yyDollar[4].expr))
  1698  		}
  1699  	case 86:
  1700  		yyDollar = yyS[yypt-3 : yypt+1]
  1701  //line build/parse.y:807
  1702  		{
  1703  			tuple, ok := yyDollar[1].expr.(*TupleExpr)
  1704  			if !ok || !tuple.NoBrackets {
  1705  				tuple = &TupleExpr{
  1706  					List:           []Expr{yyDollar[1].expr},
  1707  					NoBrackets:     true,
  1708  					ForceCompact:   true,
  1709  					ForceMultiLine: false,
  1710  				}
  1711  			}
  1712  			tuple.List = append(tuple.List, yyDollar[3].expr)
  1713  			yyVAL.expr = tuple
  1714  		}
  1715  	case 87:
  1716  		yyDollar = yyS[yypt-0 : yypt+1]
  1717  //line build/parse.y:822
  1718  		{
  1719  			yyVAL.expr = nil
  1720  		}
  1721  	case 90:
  1722  		yyDollar = yyS[yypt-4 : yypt+1]
  1723  //line build/parse.y:830
  1724  		{
  1725  			yyVAL.expr = &LambdaExpr{
  1726  				Function: Function{
  1727  					StartPos: yyDollar[1].pos,
  1728  					Params:   yyDollar[2].exprs,
  1729  					Body:     []Expr{yyDollar[4].expr},
  1730  				},
  1731  			}
  1732  		}
  1733  	case 91:
  1734  		yyDollar = yyS[yypt-2 : yypt+1]
  1735  //line build/parse.y:839
  1736  		{
  1737  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1738  		}
  1739  	case 92:
  1740  		yyDollar = yyS[yypt-2 : yypt+1]
  1741  //line build/parse.y:840
  1742  		{
  1743  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1744  		}
  1745  	case 93:
  1746  		yyDollar = yyS[yypt-2 : yypt+1]
  1747  //line build/parse.y:841
  1748  		{
  1749  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1750  		}
  1751  	case 94:
  1752  		yyDollar = yyS[yypt-2 : yypt+1]
  1753  //line build/parse.y:842
  1754  		{
  1755  			yyVAL.expr = unary(yyDollar[1].pos, yyDollar[1].tok, yyDollar[2].expr)
  1756  		}
  1757  	case 95:
  1758  		yyDollar = yyS[yypt-3 : yypt+1]
  1759  //line build/parse.y:843
  1760  		{
  1761  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1762  		}
  1763  	case 96:
  1764  		yyDollar = yyS[yypt-3 : yypt+1]
  1765  //line build/parse.y:844
  1766  		{
  1767  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1768  		}
  1769  	case 97:
  1770  		yyDollar = yyS[yypt-3 : yypt+1]
  1771  //line build/parse.y:845
  1772  		{
  1773  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1774  		}
  1775  	case 98:
  1776  		yyDollar = yyS[yypt-3 : yypt+1]
  1777  //line build/parse.y:846
  1778  		{
  1779  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1780  		}
  1781  	case 99:
  1782  		yyDollar = yyS[yypt-3 : yypt+1]
  1783  //line build/parse.y:847
  1784  		{
  1785  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1786  		}
  1787  	case 100:
  1788  		yyDollar = yyS[yypt-3 : yypt+1]
  1789  //line build/parse.y:848
  1790  		{
  1791  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1792  		}
  1793  	case 101:
  1794  		yyDollar = yyS[yypt-3 : yypt+1]
  1795  //line build/parse.y:849
  1796  		{
  1797  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1798  		}
  1799  	case 102:
  1800  		yyDollar = yyS[yypt-3 : yypt+1]
  1801  //line build/parse.y:850
  1802  		{
  1803  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1804  		}
  1805  	case 103:
  1806  		yyDollar = yyS[yypt-3 : yypt+1]
  1807  //line build/parse.y:851
  1808  		{
  1809  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1810  		}
  1811  	case 104:
  1812  		yyDollar = yyS[yypt-3 : yypt+1]
  1813  //line build/parse.y:852
  1814  		{
  1815  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1816  		}
  1817  	case 105:
  1818  		yyDollar = yyS[yypt-3 : yypt+1]
  1819  //line build/parse.y:853
  1820  		{
  1821  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1822  		}
  1823  	case 106:
  1824  		yyDollar = yyS[yypt-3 : yypt+1]
  1825  //line build/parse.y:854
  1826  		{
  1827  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1828  		}
  1829  	case 107:
  1830  		yyDollar = yyS[yypt-3 : yypt+1]
  1831  //line build/parse.y:855
  1832  		{
  1833  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1834  		}
  1835  	case 108:
  1836  		yyDollar = yyS[yypt-4 : yypt+1]
  1837  //line build/parse.y:856
  1838  		{
  1839  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, "not in", yyDollar[4].expr)
  1840  		}
  1841  	case 109:
  1842  		yyDollar = yyS[yypt-3 : yypt+1]
  1843  //line build/parse.y:857
  1844  		{
  1845  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1846  		}
  1847  	case 110:
  1848  		yyDollar = yyS[yypt-3 : yypt+1]
  1849  //line build/parse.y:858
  1850  		{
  1851  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1852  		}
  1853  	case 111:
  1854  		yyDollar = yyS[yypt-3 : yypt+1]
  1855  //line build/parse.y:859
  1856  		{
  1857  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1858  		}
  1859  	case 112:
  1860  		yyDollar = yyS[yypt-3 : yypt+1]
  1861  //line build/parse.y:860
  1862  		{
  1863  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1864  		}
  1865  	case 113:
  1866  		yyDollar = yyS[yypt-3 : yypt+1]
  1867  //line build/parse.y:861
  1868  		{
  1869  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1870  		}
  1871  	case 114:
  1872  		yyDollar = yyS[yypt-3 : yypt+1]
  1873  //line build/parse.y:862
  1874  		{
  1875  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1876  		}
  1877  	case 115:
  1878  		yyDollar = yyS[yypt-3 : yypt+1]
  1879  //line build/parse.y:863
  1880  		{
  1881  			yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1882  		}
  1883  	case 116:
  1884  		yyDollar = yyS[yypt-3 : yypt+1]
  1885  //line build/parse.y:865
  1886  		{
  1887  			if b, ok := yyDollar[3].expr.(*UnaryExpr); ok && b.Op == "not" {
  1888  				yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, "is not", b.X)
  1889  			} else {
  1890  				yyVAL.expr = binary(yyDollar[1].expr, yyDollar[2].pos, yyDollar[2].tok, yyDollar[3].expr)
  1891  			}
  1892  		}
  1893  	case 117:
  1894  		yyDollar = yyS[yypt-5 : yypt+1]
  1895  //line build/parse.y:873
  1896  		{
  1897  			yyVAL.expr = &ConditionalExpr{
  1898  				Then:      yyDollar[1].expr,
  1899  				IfStart:   yyDollar[2].pos,
  1900  				Test:      yyDollar[3].expr,
  1901  				ElseStart: yyDollar[4].pos,
  1902  				Else:      yyDollar[5].expr,
  1903  			}
  1904  		}
  1905  	case 118:
  1906  		yyDollar = yyS[yypt-1 : yypt+1]
  1907  //line build/parse.y:885
  1908  		{
  1909  			yyVAL.exprs = []Expr{yyDollar[1].expr}
  1910  		}
  1911  	case 119:
  1912  		yyDollar = yyS[yypt-3 : yypt+1]
  1913  //line build/parse.y:889
  1914  		{
  1915  			yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr)
  1916  		}
  1917  	case 120:
  1918  		yyDollar = yyS[yypt-0 : yypt+1]
  1919  //line build/parse.y:894
  1920  		{
  1921  			yyVAL.expr = nil
  1922  		}
  1923  	case 122:
  1924  		yyDollar = yyS[yypt-0 : yypt+1]
  1925  //line build/parse.y:900
  1926  		{
  1927  			yyVAL.exprs, yyVAL.comma = nil, Position{}
  1928  		}
  1929  	case 123:
  1930  		yyDollar = yyS[yypt-2 : yypt+1]
  1931  //line build/parse.y:904
  1932  		{
  1933  			yyVAL.exprs, yyVAL.comma = yyDollar[1].exprs, yyDollar[2].pos
  1934  		}
  1935  	case 124:
  1936  		yyDollar = yyS[yypt-0 : yypt+1]
  1937  //line build/parse.y:914
  1938  		{
  1939  			yyVAL.pos = Position{}
  1940  		}
  1941  	case 127:
  1942  		yyDollar = yyS[yypt-2 : yypt+1]
  1943  //line build/parse.y:925
  1944  		{
  1945  			yyVAL.pos = yyDollar[1].pos
  1946  		}
  1947  	case 128:
  1948  		yyDollar = yyS[yypt-0 : yypt+1]
  1949  //line build/parse.y:933
  1950  		{
  1951  			yyVAL.pos = Position{}
  1952  		}
  1953  	case 130:
  1954  		yyDollar = yyS[yypt-3 : yypt+1]
  1955  //line build/parse.y:940
  1956  		{
  1957  			yyVAL.kv = &KeyValueExpr{
  1958  				Key:   yyDollar[1].expr,
  1959  				Colon: yyDollar[2].pos,
  1960  				Value: yyDollar[3].expr,
  1961  			}
  1962  		}
  1963  	case 131:
  1964  		yyDollar = yyS[yypt-1 : yypt+1]
  1965  //line build/parse.y:950
  1966  		{
  1967  			yyVAL.kvs = []*KeyValueExpr{yyDollar[1].kv}
  1968  		}
  1969  	case 132:
  1970  		yyDollar = yyS[yypt-3 : yypt+1]
  1971  //line build/parse.y:954
  1972  		{
  1973  			yyVAL.kvs = append(yyDollar[1].kvs, yyDollar[3].kv)
  1974  		}
  1975  	case 133:
  1976  		yyDollar = yyS[yypt-0 : yypt+1]
  1977  //line build/parse.y:959
  1978  		{
  1979  			yyVAL.kvs = nil
  1980  		}
  1981  	case 134:
  1982  		yyDollar = yyS[yypt-1 : yypt+1]
  1983  //line build/parse.y:963
  1984  		{
  1985  			yyVAL.kvs = yyDollar[1].kvs
  1986  		}
  1987  	case 135:
  1988  		yyDollar = yyS[yypt-2 : yypt+1]
  1989  //line build/parse.y:967
  1990  		{
  1991  			yyVAL.kvs = yyDollar[1].kvs
  1992  		}
  1993  	case 137:
  1994  		yyDollar = yyS[yypt-3 : yypt+1]
  1995  //line build/parse.y:974
  1996  		{
  1997  			tuple, ok := yyDollar[1].expr.(*TupleExpr)
  1998  			if !ok || !tuple.NoBrackets {
  1999  				tuple = &TupleExpr{
  2000  					List:           []Expr{yyDollar[1].expr},
  2001  					NoBrackets:     true,
  2002  					ForceCompact:   true,
  2003  					ForceMultiLine: false,
  2004  				}
  2005  			}
  2006  			tuple.List = append(tuple.List, yyDollar[3].expr)
  2007  			yyVAL.expr = tuple
  2008  		}
  2009  	case 138:
  2010  		yyDollar = yyS[yypt-1 : yypt+1]
  2011  //line build/parse.y:990
  2012  		{
  2013  			yyVAL.string = &StringExpr{
  2014  				Start:       yyDollar[1].pos,
  2015  				Value:       yyDollar[1].str,
  2016  				TripleQuote: yyDollar[1].triple,
  2017  				End:         yyDollar[1].pos.add(yyDollar[1].tok),
  2018  				Token:       yyDollar[1].tok,
  2019  			}
  2020  		}
  2021  	case 139:
  2022  		yyDollar = yyS[yypt-1 : yypt+1]
  2023  //line build/parse.y:1002
  2024  		{
  2025  			yyVAL.expr = &Ident{NamePos: yyDollar[1].pos, Name: yyDollar[1].tok}
  2026  		}
  2027  	case 140:
  2028  		yyDollar = yyS[yypt-3 : yypt+1]
  2029  //line build/parse.y:1008
  2030  		{
  2031  			yyVAL.expr = &LiteralExpr{Start: yyDollar[1].pos, Token: yyDollar[1].tok + "." + yyDollar[3].tok}
  2032  		}
  2033  	case 141:
  2034  		yyDollar = yyS[yypt-2 : yypt+1]
  2035  //line build/parse.y:1012
  2036  		{
  2037  			yyVAL.expr = &LiteralExpr{Start: yyDollar[1].pos, Token: yyDollar[1].tok + "."}
  2038  		}
  2039  	case 142:
  2040  		yyDollar = yyS[yypt-2 : yypt+1]
  2041  //line build/parse.y:1016
  2042  		{
  2043  			yyVAL.expr = &LiteralExpr{Start: yyDollar[1].pos, Token: "." + yyDollar[2].tok}
  2044  		}
  2045  	case 143:
  2046  		yyDollar = yyS[yypt-1 : yypt+1]
  2047  //line build/parse.y:1020
  2048  		{
  2049  			yyVAL.expr = &LiteralExpr{Start: yyDollar[1].pos, Token: yyDollar[1].tok}
  2050  		}
  2051  	case 144:
  2052  		yyDollar = yyS[yypt-4 : yypt+1]
  2053  //line build/parse.y:1026
  2054  		{
  2055  			yyVAL.expr = &ForClause{
  2056  				For:  yyDollar[1].pos,
  2057  				Vars: yyDollar[2].expr,
  2058  				In:   yyDollar[3].pos,
  2059  				X:    yyDollar[4].expr,
  2060  			}
  2061  		}
  2062  	case 145:
  2063  		yyDollar = yyS[yypt-1 : yypt+1]
  2064  //line build/parse.y:1037
  2065  		{
  2066  			yyVAL.exprs = []Expr{yyDollar[1].expr}
  2067  		}
  2068  	case 146:
  2069  		yyDollar = yyS[yypt-3 : yypt+1]
  2070  //line build/parse.y:1041
  2071  		{
  2072  			yyVAL.exprs = append(yyDollar[1].exprs, &IfClause{
  2073  				If:   yyDollar[2].pos,
  2074  				Cond: yyDollar[3].expr,
  2075  			})
  2076  		}
  2077  	case 147:
  2078  		yyDollar = yyS[yypt-1 : yypt+1]
  2079  //line build/parse.y:1050
  2080  		{
  2081  			yyVAL.exprs = yyDollar[1].exprs
  2082  		}
  2083  	case 148:
  2084  		yyDollar = yyS[yypt-2 : yypt+1]
  2085  //line build/parse.y:1054
  2086  		{
  2087  			yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[2].exprs...)
  2088  		}
  2089  	}
  2090  	goto yystack /* stack new state and value */
  2091  }
  2092  

View as plain text