interval

package
v0.105.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 3, 2021 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var FluxTestPackages = []*ast.Package{&ast.Package{
	BaseNode: ast.BaseNode{
		Errors: nil,
		Loc:    nil,
	},
	Files: []*ast.File{&ast.File{
		BaseNode: ast.BaseNode{
			Errors: nil,
			Loc: &ast.SourceLocation{
				End: ast.Position{
					Column: 43,
					Line:   80,
				},
				File:   "interval_test.flux",
				Source: "package interval_test\n\nimport \"experimental\"\nimport \"interval\"\n\n// these test cases cannot pass CI, so they're skipped for now. Once we're able to test a non table stream test case,\n// we can unskip them\nexperimental.addDuration(d: 1d, to: 2020-01-01T00:00:00Z) == 2020-01-02T00:00:00Z or die(msg: \"day addition\")\nexperimental.addDuration(d: 1mo, to: 2020-01-01T00:00:00Z) == 2020-02-01T00:00:00Z or die(msg: \"month addition\")\nexperimental.addDuration(d: 1mo, to: 2020-01-31T00:00:00Z) == 2020-02-29T00:00:00Z or die(msg: \"month addition end of month\")\nexperimental.addDuration(d: 1mo, to: 2020-02-28T00:00:00Z) == 2020-03-28T00:00:00Z or die(msg: \"month addition ??\")\n\n// per minute intervals\ninterval.intervals(every: 1m, period: 1m, offset: 0s)(start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:10:00Z) == [\n    {start: 2020-10-30T00:09:00Z, stop: 2020-10-30T00:10:00Z},\n    {start: 2020-10-30T00:08:00Z, stop: 2020-10-30T00:09:00Z},\n    {start: 2020-10-30T00:07:00Z, stop: 2020-10-30T00:08:00Z},\n    {start: 2020-10-30T00:06:00Z, stop: 2020-10-30T00:07:00Z},\n    {start: 2020-10-30T00:05:00Z, stop: 2020-10-30T00:06:00Z},\n    {start: 2020-10-30T00:04:00Z, stop: 2020-10-30T00:05:00Z},\n    {start: 2020-10-30T00:03:00Z, stop: 2020-10-30T00:04:00Z},\n    {start: 2020-10-30T00:02:00Z, stop: 2020-10-30T00:03:00Z},\n    {start: 2020-10-30T00:01:00Z, stop: 2020-10-30T00:02:00Z},\n    {start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:01:00Z},\n] or die(msg: \"per minute intervals\")\n\n// daily\ninterval.intervals(every: 1d, period: 1d, offset: 11h)(start: 2020-10-30T11:00:00Z, stop: 2020-11-05T11:00:00Z) == [\n    {start: 2020-11-04T11:00:00Z, stop: 2020-11-05T11:00:00Z},\n    {start: 2020-11-03T11:00:00Z, stop: 2020-11-04T11:00:00Z},\n    {start: 2020-11-02T11:00:00Z, stop: 2020-11-03T11:00:00Z},\n    {start: 2020-11-01T11:00:00Z, stop: 2020-11-02T11:00:00Z},\n    {start: 2020-10-31T11:00:00Z, stop: 2020-11-01T11:00:00Z},\n    {start: 2020-10-30T11:00:00Z, stop: 2020-10-31T11:00:00Z},\n] or die(msg: \"per day intervals\")\n\n// daily 9-5\ninterval.intervals(every: 1d, period: 8h, offset: 9h)(start: 2020-10-30T00:00:00Z, stop: 2020-11-05T00:00:00Z) == [\n    {start: 2020-11-04T09:00:00Z, stop: 2020-11-04T17:00:00Z},\n    {start: 2020-11-03T09:00:00Z, stop: 2020-11-03T17:00:00Z},\n    {start: 2020-11-02T09:00:00Z, stop: 2020-11-02T17:00:00Z},\n    {start: 2020-11-01T09:00:00Z, stop: 2020-11-01T17:00:00Z},\n    {start: 2020-10-31T09:00:00Z, stop: 2020-10-31T17:00:00Z},\n    {start: 2020-10-30T09:00:00Z, stop: 2020-10-30T17:00:00Z},\n] or die(msg: \"per day 9AM-5PM intervals\")",
				Start: ast.Position{
					Column: 1,
					Line:   36,
				},
			},
		},
		Body: []ast.Statement{&ast.ExpressionStatement{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 110,
						Line:   43,
					},
					File:   "interval_test.flux",
					Source: "experimental.addDuration(d: 1d, to: 2020-01-01T00:00:00Z) == 2020-01-02T00:00:00Z or die(msg: \"day addition\")",
					Start: ast.Position{
						Column: 1,
						Line:   43,
					},
				},
			},
			Expression: &ast.LogicalExpression{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 110,
							Line:   43,
						},
						File:   "interval_test.flux",
						Source: "experimental.addDuration(d: 1d, to: 2020-01-01T00:00:00Z) == 2020-01-02T00:00:00Z or die(msg: \"day addition\")",
						Start: ast.Position{
							Column: 1,
							Line:   43,
						},
					},
				},
				Left: &ast.BinaryExpression{
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 82,
								Line:   43,
							},
							File:   "interval_test.flux",
							Source: "experimental.addDuration(d: 1d, to: 2020-01-01T00:00:00Z) == 2020-01-02T00:00:00Z",
							Start: ast.Position{
								Column: 1,
								Line:   43,
							},
						},
					},
					Left: &ast.CallExpression{
						Arguments: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 57,
										Line:   43,
									},
									File:   "interval_test.flux",
									Source: "d: 1d, to: 2020-01-01T00:00:00Z",
									Start: ast.Position{
										Column: 26,
										Line:   43,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 31,
											Line:   43,
										},
										File:   "interval_test.flux",
										Source: "d: 1d",
										Start: ast.Position{
											Column: 26,
											Line:   43,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 27,
												Line:   43,
											},
											File:   "interval_test.flux",
											Source: "d",
											Start: ast.Position{
												Column: 26,
												Line:   43,
											},
										},
									},
									Name: "d",
								},
								Value: &ast.DurationLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 31,
												Line:   43,
											},
											File:   "interval_test.flux",
											Source: "1d",
											Start: ast.Position{
												Column: 29,
												Line:   43,
											},
										},
									},
									Values: []ast.Duration{ast.Duration{
										Magnitude: int64(1),
										Unit:      "d",
									}},
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 57,
											Line:   43,
										},
										File:   "interval_test.flux",
										Source: "to: 2020-01-01T00:00:00Z",
										Start: ast.Position{
											Column: 33,
											Line:   43,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 35,
												Line:   43,
											},
											File:   "interval_test.flux",
											Source: "to",
											Start: ast.Position{
												Column: 33,
												Line:   43,
											},
										},
									},
									Name: "to",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 57,
												Line:   43,
											},
											File:   "interval_test.flux",
											Source: "2020-01-01T00:00:00Z",
											Start: ast.Position{
												Column: 37,
												Line:   43,
											},
										},
									},
									Value: parser.MustParseTime("2020-01-01T00:00:00Z"),
								},
							}},
							With: nil,
						}},
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 58,
									Line:   43,
								},
								File:   "interval_test.flux",
								Source: "experimental.addDuration(d: 1d, to: 2020-01-01T00:00:00Z)",
								Start: ast.Position{
									Column: 1,
									Line:   43,
								},
							},
						},
						Callee: &ast.MemberExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 25,
										Line:   43,
									},
									File:   "interval_test.flux",
									Source: "experimental.addDuration",
									Start: ast.Position{
										Column: 1,
										Line:   43,
									},
								},
							},
							Object: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 13,
											Line:   43,
										},
										File:   "interval_test.flux",
										Source: "experimental",
										Start: ast.Position{
											Column: 1,
											Line:   43,
										},
									},
								},
								Name: "experimental",
							},
							Property: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 25,
											Line:   43,
										},
										File:   "interval_test.flux",
										Source: "addDuration",
										Start: ast.Position{
											Column: 14,
											Line:   43,
										},
									},
								},
								Name: "addDuration",
							},
						},
					},
					Operator: 17,
					Right: &ast.DateTimeLiteral{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 82,
									Line:   43,
								},
								File:   "interval_test.flux",
								Source: "2020-01-02T00:00:00Z",
								Start: ast.Position{
									Column: 62,
									Line:   43,
								},
							},
						},
						Value: parser.MustParseTime("2020-01-02T00:00:00Z"),
					},
				},
				Operator: 2,
				Right: &ast.CallExpression{
					Arguments: []ast.Expression{&ast.ObjectExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 109,
									Line:   43,
								},
								File:   "interval_test.flux",
								Source: "msg: \"day addition\"",
								Start: ast.Position{
									Column: 90,
									Line:   43,
								},
							},
						},
						Properties: []*ast.Property{&ast.Property{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 109,
										Line:   43,
									},
									File:   "interval_test.flux",
									Source: "msg: \"day addition\"",
									Start: ast.Position{
										Column: 90,
										Line:   43,
									},
								},
							},
							Key: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 93,
											Line:   43,
										},
										File:   "interval_test.flux",
										Source: "msg",
										Start: ast.Position{
											Column: 90,
											Line:   43,
										},
									},
								},
								Name: "msg",
							},
							Value: &ast.StringLiteral{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 109,
											Line:   43,
										},
										File:   "interval_test.flux",
										Source: "\"day addition\"",
										Start: ast.Position{
											Column: 95,
											Line:   43,
										},
									},
								},
								Value: "day addition",
							},
						}},
						With: nil,
					}},
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 110,
								Line:   43,
							},
							File:   "interval_test.flux",
							Source: "die(msg: \"day addition\")",
							Start: ast.Position{
								Column: 86,
								Line:   43,
							},
						},
					},
					Callee: &ast.Identifier{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 89,
									Line:   43,
								},
								File:   "interval_test.flux",
								Source: "die",
								Start: ast.Position{
									Column: 86,
									Line:   43,
								},
							},
						},
						Name: "die",
					},
				},
			},
		}, &ast.ExpressionStatement{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 113,
						Line:   44,
					},
					File:   "interval_test.flux",
					Source: "experimental.addDuration(d: 1mo, to: 2020-01-01T00:00:00Z) == 2020-02-01T00:00:00Z or die(msg: \"month addition\")",
					Start: ast.Position{
						Column: 1,
						Line:   44,
					},
				},
			},
			Expression: &ast.LogicalExpression{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 113,
							Line:   44,
						},
						File:   "interval_test.flux",
						Source: "experimental.addDuration(d: 1mo, to: 2020-01-01T00:00:00Z) == 2020-02-01T00:00:00Z or die(msg: \"month addition\")",
						Start: ast.Position{
							Column: 1,
							Line:   44,
						},
					},
				},
				Left: &ast.BinaryExpression{
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 83,
								Line:   44,
							},
							File:   "interval_test.flux",
							Source: "experimental.addDuration(d: 1mo, to: 2020-01-01T00:00:00Z) == 2020-02-01T00:00:00Z",
							Start: ast.Position{
								Column: 1,
								Line:   44,
							},
						},
					},
					Left: &ast.CallExpression{
						Arguments: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 58,
										Line:   44,
									},
									File:   "interval_test.flux",
									Source: "d: 1mo, to: 2020-01-01T00:00:00Z",
									Start: ast.Position{
										Column: 26,
										Line:   44,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 32,
											Line:   44,
										},
										File:   "interval_test.flux",
										Source: "d: 1mo",
										Start: ast.Position{
											Column: 26,
											Line:   44,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 27,
												Line:   44,
											},
											File:   "interval_test.flux",
											Source: "d",
											Start: ast.Position{
												Column: 26,
												Line:   44,
											},
										},
									},
									Name: "d",
								},
								Value: &ast.DurationLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 32,
												Line:   44,
											},
											File:   "interval_test.flux",
											Source: "1mo",
											Start: ast.Position{
												Column: 29,
												Line:   44,
											},
										},
									},
									Values: []ast.Duration{ast.Duration{
										Magnitude: int64(1),
										Unit:      "mo",
									}},
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 58,
											Line:   44,
										},
										File:   "interval_test.flux",
										Source: "to: 2020-01-01T00:00:00Z",
										Start: ast.Position{
											Column: 34,
											Line:   44,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 36,
												Line:   44,
											},
											File:   "interval_test.flux",
											Source: "to",
											Start: ast.Position{
												Column: 34,
												Line:   44,
											},
										},
									},
									Name: "to",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 58,
												Line:   44,
											},
											File:   "interval_test.flux",
											Source: "2020-01-01T00:00:00Z",
											Start: ast.Position{
												Column: 38,
												Line:   44,
											},
										},
									},
									Value: parser.MustParseTime("2020-01-01T00:00:00Z"),
								},
							}},
							With: nil,
						}},
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 59,
									Line:   44,
								},
								File:   "interval_test.flux",
								Source: "experimental.addDuration(d: 1mo, to: 2020-01-01T00:00:00Z)",
								Start: ast.Position{
									Column: 1,
									Line:   44,
								},
							},
						},
						Callee: &ast.MemberExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 25,
										Line:   44,
									},
									File:   "interval_test.flux",
									Source: "experimental.addDuration",
									Start: ast.Position{
										Column: 1,
										Line:   44,
									},
								},
							},
							Object: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 13,
											Line:   44,
										},
										File:   "interval_test.flux",
										Source: "experimental",
										Start: ast.Position{
											Column: 1,
											Line:   44,
										},
									},
								},
								Name: "experimental",
							},
							Property: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 25,
											Line:   44,
										},
										File:   "interval_test.flux",
										Source: "addDuration",
										Start: ast.Position{
											Column: 14,
											Line:   44,
										},
									},
								},
								Name: "addDuration",
							},
						},
					},
					Operator: 17,
					Right: &ast.DateTimeLiteral{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 83,
									Line:   44,
								},
								File:   "interval_test.flux",
								Source: "2020-02-01T00:00:00Z",
								Start: ast.Position{
									Column: 63,
									Line:   44,
								},
							},
						},
						Value: parser.MustParseTime("2020-02-01T00:00:00Z"),
					},
				},
				Operator: 2,
				Right: &ast.CallExpression{
					Arguments: []ast.Expression{&ast.ObjectExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 112,
									Line:   44,
								},
								File:   "interval_test.flux",
								Source: "msg: \"month addition\"",
								Start: ast.Position{
									Column: 91,
									Line:   44,
								},
							},
						},
						Properties: []*ast.Property{&ast.Property{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 112,
										Line:   44,
									},
									File:   "interval_test.flux",
									Source: "msg: \"month addition\"",
									Start: ast.Position{
										Column: 91,
										Line:   44,
									},
								},
							},
							Key: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 94,
											Line:   44,
										},
										File:   "interval_test.flux",
										Source: "msg",
										Start: ast.Position{
											Column: 91,
											Line:   44,
										},
									},
								},
								Name: "msg",
							},
							Value: &ast.StringLiteral{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 112,
											Line:   44,
										},
										File:   "interval_test.flux",
										Source: "\"month addition\"",
										Start: ast.Position{
											Column: 96,
											Line:   44,
										},
									},
								},
								Value: "month addition",
							},
						}},
						With: nil,
					}},
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 113,
								Line:   44,
							},
							File:   "interval_test.flux",
							Source: "die(msg: \"month addition\")",
							Start: ast.Position{
								Column: 87,
								Line:   44,
							},
						},
					},
					Callee: &ast.Identifier{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 90,
									Line:   44,
								},
								File:   "interval_test.flux",
								Source: "die",
								Start: ast.Position{
									Column: 87,
									Line:   44,
								},
							},
						},
						Name: "die",
					},
				},
			},
		}, &ast.ExpressionStatement{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 126,
						Line:   45,
					},
					File:   "interval_test.flux",
					Source: "experimental.addDuration(d: 1mo, to: 2020-01-31T00:00:00Z) == 2020-02-29T00:00:00Z or die(msg: \"month addition end of month\")",
					Start: ast.Position{
						Column: 1,
						Line:   45,
					},
				},
			},
			Expression: &ast.LogicalExpression{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 126,
							Line:   45,
						},
						File:   "interval_test.flux",
						Source: "experimental.addDuration(d: 1mo, to: 2020-01-31T00:00:00Z) == 2020-02-29T00:00:00Z or die(msg: \"month addition end of month\")",
						Start: ast.Position{
							Column: 1,
							Line:   45,
						},
					},
				},
				Left: &ast.BinaryExpression{
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 83,
								Line:   45,
							},
							File:   "interval_test.flux",
							Source: "experimental.addDuration(d: 1mo, to: 2020-01-31T00:00:00Z) == 2020-02-29T00:00:00Z",
							Start: ast.Position{
								Column: 1,
								Line:   45,
							},
						},
					},
					Left: &ast.CallExpression{
						Arguments: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 58,
										Line:   45,
									},
									File:   "interval_test.flux",
									Source: "d: 1mo, to: 2020-01-31T00:00:00Z",
									Start: ast.Position{
										Column: 26,
										Line:   45,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 32,
											Line:   45,
										},
										File:   "interval_test.flux",
										Source: "d: 1mo",
										Start: ast.Position{
											Column: 26,
											Line:   45,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 27,
												Line:   45,
											},
											File:   "interval_test.flux",
											Source: "d",
											Start: ast.Position{
												Column: 26,
												Line:   45,
											},
										},
									},
									Name: "d",
								},
								Value: &ast.DurationLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 32,
												Line:   45,
											},
											File:   "interval_test.flux",
											Source: "1mo",
											Start: ast.Position{
												Column: 29,
												Line:   45,
											},
										},
									},
									Values: []ast.Duration{ast.Duration{
										Magnitude: int64(1),
										Unit:      "mo",
									}},
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 58,
											Line:   45,
										},
										File:   "interval_test.flux",
										Source: "to: 2020-01-31T00:00:00Z",
										Start: ast.Position{
											Column: 34,
											Line:   45,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 36,
												Line:   45,
											},
											File:   "interval_test.flux",
											Source: "to",
											Start: ast.Position{
												Column: 34,
												Line:   45,
											},
										},
									},
									Name: "to",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 58,
												Line:   45,
											},
											File:   "interval_test.flux",
											Source: "2020-01-31T00:00:00Z",
											Start: ast.Position{
												Column: 38,
												Line:   45,
											},
										},
									},
									Value: parser.MustParseTime("2020-01-31T00:00:00Z"),
								},
							}},
							With: nil,
						}},
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 59,
									Line:   45,
								},
								File:   "interval_test.flux",
								Source: "experimental.addDuration(d: 1mo, to: 2020-01-31T00:00:00Z)",
								Start: ast.Position{
									Column: 1,
									Line:   45,
								},
							},
						},
						Callee: &ast.MemberExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 25,
										Line:   45,
									},
									File:   "interval_test.flux",
									Source: "experimental.addDuration",
									Start: ast.Position{
										Column: 1,
										Line:   45,
									},
								},
							},
							Object: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 13,
											Line:   45,
										},
										File:   "interval_test.flux",
										Source: "experimental",
										Start: ast.Position{
											Column: 1,
											Line:   45,
										},
									},
								},
								Name: "experimental",
							},
							Property: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 25,
											Line:   45,
										},
										File:   "interval_test.flux",
										Source: "addDuration",
										Start: ast.Position{
											Column: 14,
											Line:   45,
										},
									},
								},
								Name: "addDuration",
							},
						},
					},
					Operator: 17,
					Right: &ast.DateTimeLiteral{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 83,
									Line:   45,
								},
								File:   "interval_test.flux",
								Source: "2020-02-29T00:00:00Z",
								Start: ast.Position{
									Column: 63,
									Line:   45,
								},
							},
						},
						Value: parser.MustParseTime("2020-02-29T00:00:00Z"),
					},
				},
				Operator: 2,
				Right: &ast.CallExpression{
					Arguments: []ast.Expression{&ast.ObjectExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 125,
									Line:   45,
								},
								File:   "interval_test.flux",
								Source: "msg: \"month addition end of month\"",
								Start: ast.Position{
									Column: 91,
									Line:   45,
								},
							},
						},
						Properties: []*ast.Property{&ast.Property{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 125,
										Line:   45,
									},
									File:   "interval_test.flux",
									Source: "msg: \"month addition end of month\"",
									Start: ast.Position{
										Column: 91,
										Line:   45,
									},
								},
							},
							Key: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 94,
											Line:   45,
										},
										File:   "interval_test.flux",
										Source: "msg",
										Start: ast.Position{
											Column: 91,
											Line:   45,
										},
									},
								},
								Name: "msg",
							},
							Value: &ast.StringLiteral{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 125,
											Line:   45,
										},
										File:   "interval_test.flux",
										Source: "\"month addition end of month\"",
										Start: ast.Position{
											Column: 96,
											Line:   45,
										},
									},
								},
								Value: "month addition end of month",
							},
						}},
						With: nil,
					}},
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 126,
								Line:   45,
							},
							File:   "interval_test.flux",
							Source: "die(msg: \"month addition end of month\")",
							Start: ast.Position{
								Column: 87,
								Line:   45,
							},
						},
					},
					Callee: &ast.Identifier{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 90,
									Line:   45,
								},
								File:   "interval_test.flux",
								Source: "die",
								Start: ast.Position{
									Column: 87,
									Line:   45,
								},
							},
						},
						Name: "die",
					},
				},
			},
		}, &ast.ExpressionStatement{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 116,
						Line:   46,
					},
					File:   "interval_test.flux",
					Source: "experimental.addDuration(d: 1mo, to: 2020-02-28T00:00:00Z) == 2020-03-28T00:00:00Z or die(msg: \"month addition ??\")",
					Start: ast.Position{
						Column: 1,
						Line:   46,
					},
				},
			},
			Expression: &ast.LogicalExpression{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 116,
							Line:   46,
						},
						File:   "interval_test.flux",
						Source: "experimental.addDuration(d: 1mo, to: 2020-02-28T00:00:00Z) == 2020-03-28T00:00:00Z or die(msg: \"month addition ??\")",
						Start: ast.Position{
							Column: 1,
							Line:   46,
						},
					},
				},
				Left: &ast.BinaryExpression{
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 83,
								Line:   46,
							},
							File:   "interval_test.flux",
							Source: "experimental.addDuration(d: 1mo, to: 2020-02-28T00:00:00Z) == 2020-03-28T00:00:00Z",
							Start: ast.Position{
								Column: 1,
								Line:   46,
							},
						},
					},
					Left: &ast.CallExpression{
						Arguments: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 58,
										Line:   46,
									},
									File:   "interval_test.flux",
									Source: "d: 1mo, to: 2020-02-28T00:00:00Z",
									Start: ast.Position{
										Column: 26,
										Line:   46,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 32,
											Line:   46,
										},
										File:   "interval_test.flux",
										Source: "d: 1mo",
										Start: ast.Position{
											Column: 26,
											Line:   46,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 27,
												Line:   46,
											},
											File:   "interval_test.flux",
											Source: "d",
											Start: ast.Position{
												Column: 26,
												Line:   46,
											},
										},
									},
									Name: "d",
								},
								Value: &ast.DurationLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 32,
												Line:   46,
											},
											File:   "interval_test.flux",
											Source: "1mo",
											Start: ast.Position{
												Column: 29,
												Line:   46,
											},
										},
									},
									Values: []ast.Duration{ast.Duration{
										Magnitude: int64(1),
										Unit:      "mo",
									}},
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 58,
											Line:   46,
										},
										File:   "interval_test.flux",
										Source: "to: 2020-02-28T00:00:00Z",
										Start: ast.Position{
											Column: 34,
											Line:   46,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 36,
												Line:   46,
											},
											File:   "interval_test.flux",
											Source: "to",
											Start: ast.Position{
												Column: 34,
												Line:   46,
											},
										},
									},
									Name: "to",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 58,
												Line:   46,
											},
											File:   "interval_test.flux",
											Source: "2020-02-28T00:00:00Z",
											Start: ast.Position{
												Column: 38,
												Line:   46,
											},
										},
									},
									Value: parser.MustParseTime("2020-02-28T00:00:00Z"),
								},
							}},
							With: nil,
						}},
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 59,
									Line:   46,
								},
								File:   "interval_test.flux",
								Source: "experimental.addDuration(d: 1mo, to: 2020-02-28T00:00:00Z)",
								Start: ast.Position{
									Column: 1,
									Line:   46,
								},
							},
						},
						Callee: &ast.MemberExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 25,
										Line:   46,
									},
									File:   "interval_test.flux",
									Source: "experimental.addDuration",
									Start: ast.Position{
										Column: 1,
										Line:   46,
									},
								},
							},
							Object: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 13,
											Line:   46,
										},
										File:   "interval_test.flux",
										Source: "experimental",
										Start: ast.Position{
											Column: 1,
											Line:   46,
										},
									},
								},
								Name: "experimental",
							},
							Property: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 25,
											Line:   46,
										},
										File:   "interval_test.flux",
										Source: "addDuration",
										Start: ast.Position{
											Column: 14,
											Line:   46,
										},
									},
								},
								Name: "addDuration",
							},
						},
					},
					Operator: 17,
					Right: &ast.DateTimeLiteral{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 83,
									Line:   46,
								},
								File:   "interval_test.flux",
								Source: "2020-03-28T00:00:00Z",
								Start: ast.Position{
									Column: 63,
									Line:   46,
								},
							},
						},
						Value: parser.MustParseTime("2020-03-28T00:00:00Z"),
					},
				},
				Operator: 2,
				Right: &ast.CallExpression{
					Arguments: []ast.Expression{&ast.ObjectExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 115,
									Line:   46,
								},
								File:   "interval_test.flux",
								Source: "msg: \"month addition ??\"",
								Start: ast.Position{
									Column: 91,
									Line:   46,
								},
							},
						},
						Properties: []*ast.Property{&ast.Property{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 115,
										Line:   46,
									},
									File:   "interval_test.flux",
									Source: "msg: \"month addition ??\"",
									Start: ast.Position{
										Column: 91,
										Line:   46,
									},
								},
							},
							Key: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 94,
											Line:   46,
										},
										File:   "interval_test.flux",
										Source: "msg",
										Start: ast.Position{
											Column: 91,
											Line:   46,
										},
									},
								},
								Name: "msg",
							},
							Value: &ast.StringLiteral{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 115,
											Line:   46,
										},
										File:   "interval_test.flux",
										Source: "\"month addition ??\"",
										Start: ast.Position{
											Column: 96,
											Line:   46,
										},
									},
								},
								Value: "month addition ??",
							},
						}},
						With: nil,
					}},
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 116,
								Line:   46,
							},
							File:   "interval_test.flux",
							Source: "die(msg: \"month addition ??\")",
							Start: ast.Position{
								Column: 87,
								Line:   46,
							},
						},
					},
					Callee: &ast.Identifier{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 90,
									Line:   46,
								},
								File:   "interval_test.flux",
								Source: "die",
								Start: ast.Position{
									Column: 87,
									Line:   46,
								},
							},
						},
						Name: "die",
					},
				},
			},
		}, &ast.ExpressionStatement{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 38,
						Line:   60,
					},
					File:   "interval_test.flux",
					Source: "interval.intervals(every: 1m, period: 1m, offset: 0s)(start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:10:00Z) == [\n    {start: 2020-10-30T00:09:00Z, stop: 2020-10-30T00:10:00Z},\n    {start: 2020-10-30T00:08:00Z, stop: 2020-10-30T00:09:00Z},\n    {start: 2020-10-30T00:07:00Z, stop: 2020-10-30T00:08:00Z},\n    {start: 2020-10-30T00:06:00Z, stop: 2020-10-30T00:07:00Z},\n    {start: 2020-10-30T00:05:00Z, stop: 2020-10-30T00:06:00Z},\n    {start: 2020-10-30T00:04:00Z, stop: 2020-10-30T00:05:00Z},\n    {start: 2020-10-30T00:03:00Z, stop: 2020-10-30T00:04:00Z},\n    {start: 2020-10-30T00:02:00Z, stop: 2020-10-30T00:03:00Z},\n    {start: 2020-10-30T00:01:00Z, stop: 2020-10-30T00:02:00Z},\n    {start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:01:00Z},\n] or die(msg: \"per minute intervals\")",
					Start: ast.Position{
						Column: 1,
						Line:   49,
					},
				},
			},
			Expression: &ast.LogicalExpression{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 38,
							Line:   60,
						},
						File:   "interval_test.flux",
						Source: "interval.intervals(every: 1m, period: 1m, offset: 0s)(start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:10:00Z) == [\n    {start: 2020-10-30T00:09:00Z, stop: 2020-10-30T00:10:00Z},\n    {start: 2020-10-30T00:08:00Z, stop: 2020-10-30T00:09:00Z},\n    {start: 2020-10-30T00:07:00Z, stop: 2020-10-30T00:08:00Z},\n    {start: 2020-10-30T00:06:00Z, stop: 2020-10-30T00:07:00Z},\n    {start: 2020-10-30T00:05:00Z, stop: 2020-10-30T00:06:00Z},\n    {start: 2020-10-30T00:04:00Z, stop: 2020-10-30T00:05:00Z},\n    {start: 2020-10-30T00:03:00Z, stop: 2020-10-30T00:04:00Z},\n    {start: 2020-10-30T00:02:00Z, stop: 2020-10-30T00:03:00Z},\n    {start: 2020-10-30T00:01:00Z, stop: 2020-10-30T00:02:00Z},\n    {start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:01:00Z},\n] or die(msg: \"per minute intervals\")",
						Start: ast.Position{
							Column: 1,
							Line:   49,
						},
					},
				},
				Left: &ast.BinaryExpression{
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 2,
								Line:   60,
							},
							File:   "interval_test.flux",
							Source: "interval.intervals(every: 1m, period: 1m, offset: 0s)(start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:10:00Z) == [\n    {start: 2020-10-30T00:09:00Z, stop: 2020-10-30T00:10:00Z},\n    {start: 2020-10-30T00:08:00Z, stop: 2020-10-30T00:09:00Z},\n    {start: 2020-10-30T00:07:00Z, stop: 2020-10-30T00:08:00Z},\n    {start: 2020-10-30T00:06:00Z, stop: 2020-10-30T00:07:00Z},\n    {start: 2020-10-30T00:05:00Z, stop: 2020-10-30T00:06:00Z},\n    {start: 2020-10-30T00:04:00Z, stop: 2020-10-30T00:05:00Z},\n    {start: 2020-10-30T00:03:00Z, stop: 2020-10-30T00:04:00Z},\n    {start: 2020-10-30T00:02:00Z, stop: 2020-10-30T00:03:00Z},\n    {start: 2020-10-30T00:01:00Z, stop: 2020-10-30T00:02:00Z},\n    {start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:01:00Z},\n]",
							Start: ast.Position{
								Column: 1,
								Line:   49,
							},
						},
					},
					Left: &ast.CallExpression{
						Arguments: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 110,
										Line:   49,
									},
									File:   "interval_test.flux",
									Source: "start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:10:00Z",
									Start: ast.Position{
										Column: 55,
										Line:   49,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 82,
											Line:   49,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:00:00Z",
										Start: ast.Position{
											Column: 55,
											Line:   49,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 60,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 55,
												Line:   49,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 82,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:00:00Z",
											Start: ast.Position{
												Column: 62,
												Line:   49,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 110,
											Line:   49,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:10:00Z",
										Start: ast.Position{
											Column: 84,
											Line:   49,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 88,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 84,
												Line:   49,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 110,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:10:00Z",
											Start: ast.Position{
												Column: 90,
												Line:   49,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:10:00Z"),
								},
							}},
							With: nil,
						}},
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 111,
									Line:   49,
								},
								File:   "interval_test.flux",
								Source: "interval.intervals(every: 1m, period: 1m, offset: 0s)(start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:10:00Z)",
								Start: ast.Position{
									Column: 1,
									Line:   49,
								},
							},
						},
						Callee: &ast.CallExpression{
							Arguments: []ast.Expression{&ast.ObjectExpression{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 53,
											Line:   49,
										},
										File:   "interval_test.flux",
										Source: "every: 1m, period: 1m, offset: 0s",
										Start: ast.Position{
											Column: 20,
											Line:   49,
										},
									},
								},
								Properties: []*ast.Property{&ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 29,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "every: 1m",
											Start: ast.Position{
												Column: 20,
												Line:   49,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 25,
													Line:   49,
												},
												File:   "interval_test.flux",
												Source: "every",
												Start: ast.Position{
													Column: 20,
													Line:   49,
												},
											},
										},
										Name: "every",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 29,
													Line:   49,
												},
												File:   "interval_test.flux",
												Source: "1m",
												Start: ast.Position{
													Column: 27,
													Line:   49,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(1),
											Unit:      "m",
										}},
									},
								}, &ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 41,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "period: 1m",
											Start: ast.Position{
												Column: 31,
												Line:   49,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 37,
													Line:   49,
												},
												File:   "interval_test.flux",
												Source: "period",
												Start: ast.Position{
													Column: 31,
													Line:   49,
												},
											},
										},
										Name: "period",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 41,
													Line:   49,
												},
												File:   "interval_test.flux",
												Source: "1m",
												Start: ast.Position{
													Column: 39,
													Line:   49,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(1),
											Unit:      "m",
										}},
									},
								}, &ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 53,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "offset: 0s",
											Start: ast.Position{
												Column: 43,
												Line:   49,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 49,
													Line:   49,
												},
												File:   "interval_test.flux",
												Source: "offset",
												Start: ast.Position{
													Column: 43,
													Line:   49,
												},
											},
										},
										Name: "offset",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 53,
													Line:   49,
												},
												File:   "interval_test.flux",
												Source: "0s",
												Start: ast.Position{
													Column: 51,
													Line:   49,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(0),
											Unit:      "s",
										}},
									},
								}},
								With: nil,
							}},
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 54,
										Line:   49,
									},
									File:   "interval_test.flux",
									Source: "interval.intervals(every: 1m, period: 1m, offset: 0s)",
									Start: ast.Position{
										Column: 1,
										Line:   49,
									},
								},
							},
							Callee: &ast.MemberExpression{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 19,
											Line:   49,
										},
										File:   "interval_test.flux",
										Source: "interval.intervals",
										Start: ast.Position{
											Column: 1,
											Line:   49,
										},
									},
								},
								Object: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 9,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "interval",
											Start: ast.Position{
												Column: 1,
												Line:   49,
											},
										},
									},
									Name: "interval",
								},
								Property: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 19,
												Line:   49,
											},
											File:   "interval_test.flux",
											Source: "intervals",
											Start: ast.Position{
												Column: 10,
												Line:   49,
											},
										},
									},
									Name: "intervals",
								},
							},
						},
					},
					Operator: 17,
					Right: &ast.ArrayExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 2,
									Line:   60,
								},
								File:   "interval_test.flux",
								Source: "[\n    {start: 2020-10-30T00:09:00Z, stop: 2020-10-30T00:10:00Z},\n    {start: 2020-10-30T00:08:00Z, stop: 2020-10-30T00:09:00Z},\n    {start: 2020-10-30T00:07:00Z, stop: 2020-10-30T00:08:00Z},\n    {start: 2020-10-30T00:06:00Z, stop: 2020-10-30T00:07:00Z},\n    {start: 2020-10-30T00:05:00Z, stop: 2020-10-30T00:06:00Z},\n    {start: 2020-10-30T00:04:00Z, stop: 2020-10-30T00:05:00Z},\n    {start: 2020-10-30T00:03:00Z, stop: 2020-10-30T00:04:00Z},\n    {start: 2020-10-30T00:02:00Z, stop: 2020-10-30T00:03:00Z},\n    {start: 2020-10-30T00:01:00Z, stop: 2020-10-30T00:02:00Z},\n    {start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:01:00Z},\n]",
								Start: ast.Position{
									Column: 115,
									Line:   49,
								},
							},
						},
						Elements: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   50,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:09:00Z, stop: 2020-10-30T00:10:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   50,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   50,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:09:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   50,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   50,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   50,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   50,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:09:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   50,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:09:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   50,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:10:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   50,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   50,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   50,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   50,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:10:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   50,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:10:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   51,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:08:00Z, stop: 2020-10-30T00:09:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   51,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   51,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:08:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   51,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   51,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   51,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   51,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:08:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   51,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:08:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   51,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:09:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   51,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   51,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   51,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   51,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:09:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   51,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:09:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   52,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:07:00Z, stop: 2020-10-30T00:08:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   52,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   52,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:07:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   52,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   52,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   52,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   52,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:07:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   52,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:07:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   52,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:08:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   52,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   52,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   52,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   52,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:08:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   52,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:08:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   53,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:06:00Z, stop: 2020-10-30T00:07:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   53,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   53,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:06:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   53,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   53,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   53,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   53,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:06:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   53,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:06:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   53,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:07:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   53,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   53,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   53,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   53,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:07:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   53,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:07:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   54,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:05:00Z, stop: 2020-10-30T00:06:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   54,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   54,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:05:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   54,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   54,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   54,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   54,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:05:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   54,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:05:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   54,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:06:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   54,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   54,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   54,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   54,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:06:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   54,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:06:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   55,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:04:00Z, stop: 2020-10-30T00:05:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   55,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   55,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:04:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   55,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   55,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   55,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   55,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:04:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   55,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:04:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   55,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:05:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   55,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   55,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   55,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   55,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:05:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   55,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:05:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   56,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:03:00Z, stop: 2020-10-30T00:04:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   56,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   56,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:03:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   56,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   56,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   56,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   56,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:03:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   56,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:03:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   56,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:04:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   56,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   56,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   56,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   56,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:04:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   56,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:04:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   57,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:02:00Z, stop: 2020-10-30T00:03:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   57,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   57,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:02:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   57,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   57,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   57,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   57,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:02:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   57,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:02:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   57,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:03:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   57,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   57,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   57,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   57,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:03:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   57,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:03:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   58,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:01:00Z, stop: 2020-10-30T00:02:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   58,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   58,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:01:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   58,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   58,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   58,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   58,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:01:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   58,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:01:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   58,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:02:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   58,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   58,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   58,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   58,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:02:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   58,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:02:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   59,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T00:00:00Z, stop: 2020-10-30T00:01:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   59,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   59,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   59,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   59,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   59,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   59,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   59,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   59,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T00:01:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   59,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   59,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   59,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   59,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:01:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   59,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:01:00Z"),
								},
							}},
							With: nil,
						}},
					},
				},
				Operator: 2,
				Right: &ast.CallExpression{
					Arguments: []ast.Expression{&ast.ObjectExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 37,
									Line:   60,
								},
								File:   "interval_test.flux",
								Source: "msg: \"per minute intervals\"",
								Start: ast.Position{
									Column: 10,
									Line:   60,
								},
							},
						},
						Properties: []*ast.Property{&ast.Property{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 37,
										Line:   60,
									},
									File:   "interval_test.flux",
									Source: "msg: \"per minute intervals\"",
									Start: ast.Position{
										Column: 10,
										Line:   60,
									},
								},
							},
							Key: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 13,
											Line:   60,
										},
										File:   "interval_test.flux",
										Source: "msg",
										Start: ast.Position{
											Column: 10,
											Line:   60,
										},
									},
								},
								Name: "msg",
							},
							Value: &ast.StringLiteral{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 37,
											Line:   60,
										},
										File:   "interval_test.flux",
										Source: "\"per minute intervals\"",
										Start: ast.Position{
											Column: 15,
											Line:   60,
										},
									},
								},
								Value: "per minute intervals",
							},
						}},
						With: nil,
					}},
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 38,
								Line:   60,
							},
							File:   "interval_test.flux",
							Source: "die(msg: \"per minute intervals\")",
							Start: ast.Position{
								Column: 6,
								Line:   60,
							},
						},
					},
					Callee: &ast.Identifier{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 9,
									Line:   60,
								},
								File:   "interval_test.flux",
								Source: "die",
								Start: ast.Position{
									Column: 6,
									Line:   60,
								},
							},
						},
						Name: "die",
					},
				},
			},
		}, &ast.ExpressionStatement{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 35,
						Line:   70,
					},
					File:   "interval_test.flux",
					Source: "interval.intervals(every: 1d, period: 1d, offset: 11h)(start: 2020-10-30T11:00:00Z, stop: 2020-11-05T11:00:00Z) == [\n    {start: 2020-11-04T11:00:00Z, stop: 2020-11-05T11:00:00Z},\n    {start: 2020-11-03T11:00:00Z, stop: 2020-11-04T11:00:00Z},\n    {start: 2020-11-02T11:00:00Z, stop: 2020-11-03T11:00:00Z},\n    {start: 2020-11-01T11:00:00Z, stop: 2020-11-02T11:00:00Z},\n    {start: 2020-10-31T11:00:00Z, stop: 2020-11-01T11:00:00Z},\n    {start: 2020-10-30T11:00:00Z, stop: 2020-10-31T11:00:00Z},\n] or die(msg: \"per day intervals\")",
					Start: ast.Position{
						Column: 1,
						Line:   63,
					},
				},
			},
			Expression: &ast.LogicalExpression{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 35,
							Line:   70,
						},
						File:   "interval_test.flux",
						Source: "interval.intervals(every: 1d, period: 1d, offset: 11h)(start: 2020-10-30T11:00:00Z, stop: 2020-11-05T11:00:00Z) == [\n    {start: 2020-11-04T11:00:00Z, stop: 2020-11-05T11:00:00Z},\n    {start: 2020-11-03T11:00:00Z, stop: 2020-11-04T11:00:00Z},\n    {start: 2020-11-02T11:00:00Z, stop: 2020-11-03T11:00:00Z},\n    {start: 2020-11-01T11:00:00Z, stop: 2020-11-02T11:00:00Z},\n    {start: 2020-10-31T11:00:00Z, stop: 2020-11-01T11:00:00Z},\n    {start: 2020-10-30T11:00:00Z, stop: 2020-10-31T11:00:00Z},\n] or die(msg: \"per day intervals\")",
						Start: ast.Position{
							Column: 1,
							Line:   63,
						},
					},
				},
				Left: &ast.BinaryExpression{
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 2,
								Line:   70,
							},
							File:   "interval_test.flux",
							Source: "interval.intervals(every: 1d, period: 1d, offset: 11h)(start: 2020-10-30T11:00:00Z, stop: 2020-11-05T11:00:00Z) == [\n    {start: 2020-11-04T11:00:00Z, stop: 2020-11-05T11:00:00Z},\n    {start: 2020-11-03T11:00:00Z, stop: 2020-11-04T11:00:00Z},\n    {start: 2020-11-02T11:00:00Z, stop: 2020-11-03T11:00:00Z},\n    {start: 2020-11-01T11:00:00Z, stop: 2020-11-02T11:00:00Z},\n    {start: 2020-10-31T11:00:00Z, stop: 2020-11-01T11:00:00Z},\n    {start: 2020-10-30T11:00:00Z, stop: 2020-10-31T11:00:00Z},\n]",
							Start: ast.Position{
								Column: 1,
								Line:   63,
							},
						},
					},
					Left: &ast.CallExpression{
						Arguments: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 111,
										Line:   63,
									},
									File:   "interval_test.flux",
									Source: "start: 2020-10-30T11:00:00Z, stop: 2020-11-05T11:00:00Z",
									Start: ast.Position{
										Column: 56,
										Line:   63,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 83,
											Line:   63,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T11:00:00Z",
										Start: ast.Position{
											Column: 56,
											Line:   63,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 56,
												Line:   63,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 83,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T11:00:00Z",
											Start: ast.Position{
												Column: 63,
												Line:   63,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T11:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 111,
											Line:   63,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-05T11:00:00Z",
										Start: ast.Position{
											Column: 85,
											Line:   63,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 89,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 85,
												Line:   63,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 111,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "2020-11-05T11:00:00Z",
											Start: ast.Position{
												Column: 91,
												Line:   63,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-05T11:00:00Z"),
								},
							}},
							With: nil,
						}},
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 112,
									Line:   63,
								},
								File:   "interval_test.flux",
								Source: "interval.intervals(every: 1d, period: 1d, offset: 11h)(start: 2020-10-30T11:00:00Z, stop: 2020-11-05T11:00:00Z)",
								Start: ast.Position{
									Column: 1,
									Line:   63,
								},
							},
						},
						Callee: &ast.CallExpression{
							Arguments: []ast.Expression{&ast.ObjectExpression{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 54,
											Line:   63,
										},
										File:   "interval_test.flux",
										Source: "every: 1d, period: 1d, offset: 11h",
										Start: ast.Position{
											Column: 20,
											Line:   63,
										},
									},
								},
								Properties: []*ast.Property{&ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 29,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "every: 1d",
											Start: ast.Position{
												Column: 20,
												Line:   63,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 25,
													Line:   63,
												},
												File:   "interval_test.flux",
												Source: "every",
												Start: ast.Position{
													Column: 20,
													Line:   63,
												},
											},
										},
										Name: "every",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 29,
													Line:   63,
												},
												File:   "interval_test.flux",
												Source: "1d",
												Start: ast.Position{
													Column: 27,
													Line:   63,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(1),
											Unit:      "d",
										}},
									},
								}, &ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 41,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "period: 1d",
											Start: ast.Position{
												Column: 31,
												Line:   63,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 37,
													Line:   63,
												},
												File:   "interval_test.flux",
												Source: "period",
												Start: ast.Position{
													Column: 31,
													Line:   63,
												},
											},
										},
										Name: "period",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 41,
													Line:   63,
												},
												File:   "interval_test.flux",
												Source: "1d",
												Start: ast.Position{
													Column: 39,
													Line:   63,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(1),
											Unit:      "d",
										}},
									},
								}, &ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 54,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "offset: 11h",
											Start: ast.Position{
												Column: 43,
												Line:   63,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 49,
													Line:   63,
												},
												File:   "interval_test.flux",
												Source: "offset",
												Start: ast.Position{
													Column: 43,
													Line:   63,
												},
											},
										},
										Name: "offset",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 54,
													Line:   63,
												},
												File:   "interval_test.flux",
												Source: "11h",
												Start: ast.Position{
													Column: 51,
													Line:   63,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(11),
											Unit:      "h",
										}},
									},
								}},
								With: nil,
							}},
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 55,
										Line:   63,
									},
									File:   "interval_test.flux",
									Source: "interval.intervals(every: 1d, period: 1d, offset: 11h)",
									Start: ast.Position{
										Column: 1,
										Line:   63,
									},
								},
							},
							Callee: &ast.MemberExpression{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 19,
											Line:   63,
										},
										File:   "interval_test.flux",
										Source: "interval.intervals",
										Start: ast.Position{
											Column: 1,
											Line:   63,
										},
									},
								},
								Object: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 9,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "interval",
											Start: ast.Position{
												Column: 1,
												Line:   63,
											},
										},
									},
									Name: "interval",
								},
								Property: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 19,
												Line:   63,
											},
											File:   "interval_test.flux",
											Source: "intervals",
											Start: ast.Position{
												Column: 10,
												Line:   63,
											},
										},
									},
									Name: "intervals",
								},
							},
						},
					},
					Operator: 17,
					Right: &ast.ArrayExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 2,
									Line:   70,
								},
								File:   "interval_test.flux",
								Source: "[\n    {start: 2020-11-04T11:00:00Z, stop: 2020-11-05T11:00:00Z},\n    {start: 2020-11-03T11:00:00Z, stop: 2020-11-04T11:00:00Z},\n    {start: 2020-11-02T11:00:00Z, stop: 2020-11-03T11:00:00Z},\n    {start: 2020-11-01T11:00:00Z, stop: 2020-11-02T11:00:00Z},\n    {start: 2020-10-31T11:00:00Z, stop: 2020-11-01T11:00:00Z},\n    {start: 2020-10-30T11:00:00Z, stop: 2020-10-31T11:00:00Z},\n]",
								Start: ast.Position{
									Column: 116,
									Line:   63,
								},
							},
						},
						Elements: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   64,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-04T11:00:00Z, stop: 2020-11-05T11:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   64,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   64,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-04T11:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   64,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   64,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   64,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   64,
											},
											File:   "interval_test.flux",
											Source: "2020-11-04T11:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   64,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-04T11:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   64,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-05T11:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   64,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   64,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   64,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   64,
											},
											File:   "interval_test.flux",
											Source: "2020-11-05T11:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   64,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-05T11:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   65,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-03T11:00:00Z, stop: 2020-11-04T11:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   65,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   65,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-03T11:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   65,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   65,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   65,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   65,
											},
											File:   "interval_test.flux",
											Source: "2020-11-03T11:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   65,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-03T11:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   65,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-04T11:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   65,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   65,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   65,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   65,
											},
											File:   "interval_test.flux",
											Source: "2020-11-04T11:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   65,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-04T11:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   66,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-02T11:00:00Z, stop: 2020-11-03T11:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   66,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   66,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-02T11:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   66,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   66,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   66,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   66,
											},
											File:   "interval_test.flux",
											Source: "2020-11-02T11:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   66,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-02T11:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   66,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-03T11:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   66,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   66,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   66,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   66,
											},
											File:   "interval_test.flux",
											Source: "2020-11-03T11:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   66,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-03T11:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   67,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-01T11:00:00Z, stop: 2020-11-02T11:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   67,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   67,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-01T11:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   67,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   67,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   67,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   67,
											},
											File:   "interval_test.flux",
											Source: "2020-11-01T11:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   67,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-01T11:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   67,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-02T11:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   67,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   67,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   67,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   67,
											},
											File:   "interval_test.flux",
											Source: "2020-11-02T11:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   67,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-02T11:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   68,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-31T11:00:00Z, stop: 2020-11-01T11:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   68,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   68,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-31T11:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   68,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   68,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   68,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   68,
											},
											File:   "interval_test.flux",
											Source: "2020-10-31T11:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   68,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-31T11:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   68,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-01T11:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   68,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   68,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   68,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   68,
											},
											File:   "interval_test.flux",
											Source: "2020-11-01T11:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   68,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-01T11:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   69,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T11:00:00Z, stop: 2020-10-31T11:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   69,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   69,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T11:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   69,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   69,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   69,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   69,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T11:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   69,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T11:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   69,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-31T11:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   69,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   69,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   69,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   69,
											},
											File:   "interval_test.flux",
											Source: "2020-10-31T11:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   69,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-31T11:00:00Z"),
								},
							}},
							With: nil,
						}},
					},
				},
				Operator: 2,
				Right: &ast.CallExpression{
					Arguments: []ast.Expression{&ast.ObjectExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 34,
									Line:   70,
								},
								File:   "interval_test.flux",
								Source: "msg: \"per day intervals\"",
								Start: ast.Position{
									Column: 10,
									Line:   70,
								},
							},
						},
						Properties: []*ast.Property{&ast.Property{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 34,
										Line:   70,
									},
									File:   "interval_test.flux",
									Source: "msg: \"per day intervals\"",
									Start: ast.Position{
										Column: 10,
										Line:   70,
									},
								},
							},
							Key: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 13,
											Line:   70,
										},
										File:   "interval_test.flux",
										Source: "msg",
										Start: ast.Position{
											Column: 10,
											Line:   70,
										},
									},
								},
								Name: "msg",
							},
							Value: &ast.StringLiteral{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 34,
											Line:   70,
										},
										File:   "interval_test.flux",
										Source: "\"per day intervals\"",
										Start: ast.Position{
											Column: 15,
											Line:   70,
										},
									},
								},
								Value: "per day intervals",
							},
						}},
						With: nil,
					}},
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 35,
								Line:   70,
							},
							File:   "interval_test.flux",
							Source: "die(msg: \"per day intervals\")",
							Start: ast.Position{
								Column: 6,
								Line:   70,
							},
						},
					},
					Callee: &ast.Identifier{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 9,
									Line:   70,
								},
								File:   "interval_test.flux",
								Source: "die",
								Start: ast.Position{
									Column: 6,
									Line:   70,
								},
							},
						},
						Name: "die",
					},
				},
			},
		}, &ast.ExpressionStatement{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 43,
						Line:   80,
					},
					File:   "interval_test.flux",
					Source: "interval.intervals(every: 1d, period: 8h, offset: 9h)(start: 2020-10-30T00:00:00Z, stop: 2020-11-05T00:00:00Z) == [\n    {start: 2020-11-04T09:00:00Z, stop: 2020-11-04T17:00:00Z},\n    {start: 2020-11-03T09:00:00Z, stop: 2020-11-03T17:00:00Z},\n    {start: 2020-11-02T09:00:00Z, stop: 2020-11-02T17:00:00Z},\n    {start: 2020-11-01T09:00:00Z, stop: 2020-11-01T17:00:00Z},\n    {start: 2020-10-31T09:00:00Z, stop: 2020-10-31T17:00:00Z},\n    {start: 2020-10-30T09:00:00Z, stop: 2020-10-30T17:00:00Z},\n] or die(msg: \"per day 9AM-5PM intervals\")",
					Start: ast.Position{
						Column: 1,
						Line:   73,
					},
				},
			},
			Expression: &ast.LogicalExpression{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 43,
							Line:   80,
						},
						File:   "interval_test.flux",
						Source: "interval.intervals(every: 1d, period: 8h, offset: 9h)(start: 2020-10-30T00:00:00Z, stop: 2020-11-05T00:00:00Z) == [\n    {start: 2020-11-04T09:00:00Z, stop: 2020-11-04T17:00:00Z},\n    {start: 2020-11-03T09:00:00Z, stop: 2020-11-03T17:00:00Z},\n    {start: 2020-11-02T09:00:00Z, stop: 2020-11-02T17:00:00Z},\n    {start: 2020-11-01T09:00:00Z, stop: 2020-11-01T17:00:00Z},\n    {start: 2020-10-31T09:00:00Z, stop: 2020-10-31T17:00:00Z},\n    {start: 2020-10-30T09:00:00Z, stop: 2020-10-30T17:00:00Z},\n] or die(msg: \"per day 9AM-5PM intervals\")",
						Start: ast.Position{
							Column: 1,
							Line:   73,
						},
					},
				},
				Left: &ast.BinaryExpression{
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 2,
								Line:   80,
							},
							File:   "interval_test.flux",
							Source: "interval.intervals(every: 1d, period: 8h, offset: 9h)(start: 2020-10-30T00:00:00Z, stop: 2020-11-05T00:00:00Z) == [\n    {start: 2020-11-04T09:00:00Z, stop: 2020-11-04T17:00:00Z},\n    {start: 2020-11-03T09:00:00Z, stop: 2020-11-03T17:00:00Z},\n    {start: 2020-11-02T09:00:00Z, stop: 2020-11-02T17:00:00Z},\n    {start: 2020-11-01T09:00:00Z, stop: 2020-11-01T17:00:00Z},\n    {start: 2020-10-31T09:00:00Z, stop: 2020-10-31T17:00:00Z},\n    {start: 2020-10-30T09:00:00Z, stop: 2020-10-30T17:00:00Z},\n]",
							Start: ast.Position{
								Column: 1,
								Line:   73,
							},
						},
					},
					Left: &ast.CallExpression{
						Arguments: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 110,
										Line:   73,
									},
									File:   "interval_test.flux",
									Source: "start: 2020-10-30T00:00:00Z, stop: 2020-11-05T00:00:00Z",
									Start: ast.Position{
										Column: 55,
										Line:   73,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 82,
											Line:   73,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T00:00:00Z",
										Start: ast.Position{
											Column: 55,
											Line:   73,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 60,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 55,
												Line:   73,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 82,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T00:00:00Z",
											Start: ast.Position{
												Column: 62,
												Line:   73,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T00:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 110,
											Line:   73,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-05T00:00:00Z",
										Start: ast.Position{
											Column: 84,
											Line:   73,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 88,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 84,
												Line:   73,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 110,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "2020-11-05T00:00:00Z",
											Start: ast.Position{
												Column: 90,
												Line:   73,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-05T00:00:00Z"),
								},
							}},
							With: nil,
						}},
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 111,
									Line:   73,
								},
								File:   "interval_test.flux",
								Source: "interval.intervals(every: 1d, period: 8h, offset: 9h)(start: 2020-10-30T00:00:00Z, stop: 2020-11-05T00:00:00Z)",
								Start: ast.Position{
									Column: 1,
									Line:   73,
								},
							},
						},
						Callee: &ast.CallExpression{
							Arguments: []ast.Expression{&ast.ObjectExpression{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 53,
											Line:   73,
										},
										File:   "interval_test.flux",
										Source: "every: 1d, period: 8h, offset: 9h",
										Start: ast.Position{
											Column: 20,
											Line:   73,
										},
									},
								},
								Properties: []*ast.Property{&ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 29,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "every: 1d",
											Start: ast.Position{
												Column: 20,
												Line:   73,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 25,
													Line:   73,
												},
												File:   "interval_test.flux",
												Source: "every",
												Start: ast.Position{
													Column: 20,
													Line:   73,
												},
											},
										},
										Name: "every",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 29,
													Line:   73,
												},
												File:   "interval_test.flux",
												Source: "1d",
												Start: ast.Position{
													Column: 27,
													Line:   73,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(1),
											Unit:      "d",
										}},
									},
								}, &ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 41,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "period: 8h",
											Start: ast.Position{
												Column: 31,
												Line:   73,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 37,
													Line:   73,
												},
												File:   "interval_test.flux",
												Source: "period",
												Start: ast.Position{
													Column: 31,
													Line:   73,
												},
											},
										},
										Name: "period",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 41,
													Line:   73,
												},
												File:   "interval_test.flux",
												Source: "8h",
												Start: ast.Position{
													Column: 39,
													Line:   73,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(8),
											Unit:      "h",
										}},
									},
								}, &ast.Property{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 53,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "offset: 9h",
											Start: ast.Position{
												Column: 43,
												Line:   73,
											},
										},
									},
									Key: &ast.Identifier{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 49,
													Line:   73,
												},
												File:   "interval_test.flux",
												Source: "offset",
												Start: ast.Position{
													Column: 43,
													Line:   73,
												},
											},
										},
										Name: "offset",
									},
									Value: &ast.DurationLiteral{
										BaseNode: ast.BaseNode{
											Errors: nil,
											Loc: &ast.SourceLocation{
												End: ast.Position{
													Column: 53,
													Line:   73,
												},
												File:   "interval_test.flux",
												Source: "9h",
												Start: ast.Position{
													Column: 51,
													Line:   73,
												},
											},
										},
										Values: []ast.Duration{ast.Duration{
											Magnitude: int64(9),
											Unit:      "h",
										}},
									},
								}},
								With: nil,
							}},
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 54,
										Line:   73,
									},
									File:   "interval_test.flux",
									Source: "interval.intervals(every: 1d, period: 8h, offset: 9h)",
									Start: ast.Position{
										Column: 1,
										Line:   73,
									},
								},
							},
							Callee: &ast.MemberExpression{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 19,
											Line:   73,
										},
										File:   "interval_test.flux",
										Source: "interval.intervals",
										Start: ast.Position{
											Column: 1,
											Line:   73,
										},
									},
								},
								Object: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 9,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "interval",
											Start: ast.Position{
												Column: 1,
												Line:   73,
											},
										},
									},
									Name: "interval",
								},
								Property: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 19,
												Line:   73,
											},
											File:   "interval_test.flux",
											Source: "intervals",
											Start: ast.Position{
												Column: 10,
												Line:   73,
											},
										},
									},
									Name: "intervals",
								},
							},
						},
					},
					Operator: 17,
					Right: &ast.ArrayExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 2,
									Line:   80,
								},
								File:   "interval_test.flux",
								Source: "[\n    {start: 2020-11-04T09:00:00Z, stop: 2020-11-04T17:00:00Z},\n    {start: 2020-11-03T09:00:00Z, stop: 2020-11-03T17:00:00Z},\n    {start: 2020-11-02T09:00:00Z, stop: 2020-11-02T17:00:00Z},\n    {start: 2020-11-01T09:00:00Z, stop: 2020-11-01T17:00:00Z},\n    {start: 2020-10-31T09:00:00Z, stop: 2020-10-31T17:00:00Z},\n    {start: 2020-10-30T09:00:00Z, stop: 2020-10-30T17:00:00Z},\n]",
								Start: ast.Position{
									Column: 115,
									Line:   73,
								},
							},
						},
						Elements: []ast.Expression{&ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   74,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-04T09:00:00Z, stop: 2020-11-04T17:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   74,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   74,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-04T09:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   74,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   74,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   74,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   74,
											},
											File:   "interval_test.flux",
											Source: "2020-11-04T09:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   74,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-04T09:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   74,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-04T17:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   74,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   74,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   74,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   74,
											},
											File:   "interval_test.flux",
											Source: "2020-11-04T17:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   74,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-04T17:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   75,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-03T09:00:00Z, stop: 2020-11-03T17:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   75,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   75,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-03T09:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   75,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   75,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   75,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   75,
											},
											File:   "interval_test.flux",
											Source: "2020-11-03T09:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   75,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-03T09:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   75,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-03T17:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   75,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   75,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   75,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   75,
											},
											File:   "interval_test.flux",
											Source: "2020-11-03T17:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   75,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-03T17:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   76,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-02T09:00:00Z, stop: 2020-11-02T17:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   76,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   76,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-02T09:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   76,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   76,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   76,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   76,
											},
											File:   "interval_test.flux",
											Source: "2020-11-02T09:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   76,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-02T09:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   76,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-02T17:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   76,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   76,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   76,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   76,
											},
											File:   "interval_test.flux",
											Source: "2020-11-02T17:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   76,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-02T17:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   77,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-11-01T09:00:00Z, stop: 2020-11-01T17:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   77,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   77,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-11-01T09:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   77,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   77,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   77,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   77,
											},
											File:   "interval_test.flux",
											Source: "2020-11-01T09:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   77,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-01T09:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   77,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-11-01T17:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   77,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   77,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   77,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   77,
											},
											File:   "interval_test.flux",
											Source: "2020-11-01T17:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   77,
											},
										},
									},
									Value: parser.MustParseTime("2020-11-01T17:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   78,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-31T09:00:00Z, stop: 2020-10-31T17:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   78,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   78,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-31T09:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   78,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   78,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   78,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   78,
											},
											File:   "interval_test.flux",
											Source: "2020-10-31T09:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   78,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-31T09:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   78,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-31T17:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   78,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   78,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   78,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   78,
											},
											File:   "interval_test.flux",
											Source: "2020-10-31T17:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   78,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-31T17:00:00Z"),
								},
							}},
							With: nil,
						}, &ast.ObjectExpression{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 62,
										Line:   79,
									},
									File:   "interval_test.flux",
									Source: "{start: 2020-10-30T09:00:00Z, stop: 2020-10-30T17:00:00Z}",
									Start: ast.Position{
										Column: 5,
										Line:   79,
									},
								},
							},
							Properties: []*ast.Property{&ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 33,
											Line:   79,
										},
										File:   "interval_test.flux",
										Source: "start: 2020-10-30T09:00:00Z",
										Start: ast.Position{
											Column: 6,
											Line:   79,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 11,
												Line:   79,
											},
											File:   "interval_test.flux",
											Source: "start",
											Start: ast.Position{
												Column: 6,
												Line:   79,
											},
										},
									},
									Name: "start",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 33,
												Line:   79,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T09:00:00Z",
											Start: ast.Position{
												Column: 13,
												Line:   79,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T09:00:00Z"),
								},
							}, &ast.Property{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 61,
											Line:   79,
										},
										File:   "interval_test.flux",
										Source: "stop: 2020-10-30T17:00:00Z",
										Start: ast.Position{
											Column: 35,
											Line:   79,
										},
									},
								},
								Key: &ast.Identifier{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 39,
												Line:   79,
											},
											File:   "interval_test.flux",
											Source: "stop",
											Start: ast.Position{
												Column: 35,
												Line:   79,
											},
										},
									},
									Name: "stop",
								},
								Value: &ast.DateTimeLiteral{
									BaseNode: ast.BaseNode{
										Errors: nil,
										Loc: &ast.SourceLocation{
											End: ast.Position{
												Column: 61,
												Line:   79,
											},
											File:   "interval_test.flux",
											Source: "2020-10-30T17:00:00Z",
											Start: ast.Position{
												Column: 41,
												Line:   79,
											},
										},
									},
									Value: parser.MustParseTime("2020-10-30T17:00:00Z"),
								},
							}},
							With: nil,
						}},
					},
				},
				Operator: 2,
				Right: &ast.CallExpression{
					Arguments: []ast.Expression{&ast.ObjectExpression{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 42,
									Line:   80,
								},
								File:   "interval_test.flux",
								Source: "msg: \"per day 9AM-5PM intervals\"",
								Start: ast.Position{
									Column: 10,
									Line:   80,
								},
							},
						},
						Properties: []*ast.Property{&ast.Property{
							BaseNode: ast.BaseNode{
								Errors: nil,
								Loc: &ast.SourceLocation{
									End: ast.Position{
										Column: 42,
										Line:   80,
									},
									File:   "interval_test.flux",
									Source: "msg: \"per day 9AM-5PM intervals\"",
									Start: ast.Position{
										Column: 10,
										Line:   80,
									},
								},
							},
							Key: &ast.Identifier{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 13,
											Line:   80,
										},
										File:   "interval_test.flux",
										Source: "msg",
										Start: ast.Position{
											Column: 10,
											Line:   80,
										},
									},
								},
								Name: "msg",
							},
							Value: &ast.StringLiteral{
								BaseNode: ast.BaseNode{
									Errors: nil,
									Loc: &ast.SourceLocation{
										End: ast.Position{
											Column: 42,
											Line:   80,
										},
										File:   "interval_test.flux",
										Source: "\"per day 9AM-5PM intervals\"",
										Start: ast.Position{
											Column: 15,
											Line:   80,
										},
									},
								},
								Value: "per day 9AM-5PM intervals",
							},
						}},
						With: nil,
					}},
					BaseNode: ast.BaseNode{
						Errors: nil,
						Loc: &ast.SourceLocation{
							End: ast.Position{
								Column: 43,
								Line:   80,
							},
							File:   "interval_test.flux",
							Source: "die(msg: \"per day 9AM-5PM intervals\")",
							Start: ast.Position{
								Column: 6,
								Line:   80,
							},
						},
					},
					Callee: &ast.Identifier{
						BaseNode: ast.BaseNode{
							Errors: nil,
							Loc: &ast.SourceLocation{
								End: ast.Position{
									Column: 9,
									Line:   80,
								},
								File:   "interval_test.flux",
								Source: "die",
								Start: ast.Position{
									Column: 6,
									Line:   80,
								},
							},
						},
						Name: "die",
					},
				},
			},
		}},
		Imports: []*ast.ImportDeclaration{&ast.ImportDeclaration{
			As: nil,
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 22,
						Line:   38,
					},
					File:   "interval_test.flux",
					Source: "import \"experimental\"",
					Start: ast.Position{
						Column: 1,
						Line:   38,
					},
				},
			},
			Path: &ast.StringLiteral{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 22,
							Line:   38,
						},
						File:   "interval_test.flux",
						Source: "\"experimental\"",
						Start: ast.Position{
							Column: 8,
							Line:   38,
						},
					},
				},
				Value: "experimental",
			},
		}, &ast.ImportDeclaration{
			As: nil,
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 18,
						Line:   39,
					},
					File:   "interval_test.flux",
					Source: "import \"interval\"",
					Start: ast.Position{
						Column: 1,
						Line:   39,
					},
				},
			},
			Path: &ast.StringLiteral{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 18,
							Line:   39,
						},
						File:   "interval_test.flux",
						Source: "\"interval\"",
						Start: ast.Position{
							Column: 8,
							Line:   39,
						},
					},
				},
				Value: "interval",
			},
		}},
		Metadata: "parser-type=rust",
		Name:     "interval_test.flux",
		Package: &ast.PackageClause{
			BaseNode: ast.BaseNode{
				Errors: nil,
				Loc: &ast.SourceLocation{
					End: ast.Position{
						Column: 22,
						Line:   36,
					},
					File:   "interval_test.flux",
					Source: "package interval_test",
					Start: ast.Position{
						Column: 1,
						Line:   36,
					},
				},
			},
			Name: &ast.Identifier{
				BaseNode: ast.BaseNode{
					Errors: nil,
					Loc: &ast.SourceLocation{
						End: ast.Position{
							Column: 22,
							Line:   36,
						},
						File:   "interval_test.flux",
						Source: "interval_test",
						Start: ast.Position{
							Column: 9,
							Line:   36,
						},
					},
				},
				Name: "interval_test",
			},
		},
	}},
	Package: "interval_test",
	Path:    "interval",
}}

Functions

This section is empty.

Types

This section is empty.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL