Upgrade to 0.12

13 files changed, 2369 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go
new file mode 100644
index 0000000..0904165
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go
@@ -0,0 +1,121 @@
+package hclwrite
+
+import (
+        "bytes"
+        "io"
+)
+
+type File struct {
+        inTree
+
+        srcBytes []byte
+        body     *node
+}
+
+// NewEmptyFile constructs a new file with no content, ready to be mutated
+// by other calls that append to its body.
+func NewEmptyFile() *File {
+        f := &File{
+                inTree: newInTree(),
+        }
+        body := newBody()
+        f.body = f.children.Append(body)
+        return f
+}
+
+// Body returns the root body of the file, which contains the top-level
+// attributes and blocks.
+func (f *File) Body() *Body {
+        return f.body.content.(*Body)
+}
+
+// WriteTo writes the tokens underlying the receiving file to the given writer.
+//
+// The tokens first have a simple formatting pass applied that adjusts only
+// the spaces between them.
+func (f *File) WriteTo(wr io.Writer) (int64, error) {
+        tokens := f.inTree.children.BuildTokens(nil)
+        format(tokens)
+        return tokens.WriteTo(wr)
+}
+
+// Bytes returns a buffer containing the source code resulting from the
+// tokens underlying the receiving file. If any updates have been made via
+// the AST API, these will be reflected in the result.
+func (f *File) Bytes() []byte {
+        buf := &bytes.Buffer{}
+        f.WriteTo(buf)
+        return buf.Bytes()
+}
+
+type comments struct {
+        leafNode
+
+        parent *node
+        tokens Tokens
+}
+
+func newComments(tokens Tokens) *comments {
+        return &comments{
+                tokens: tokens,
+        }
+}
+
+func (c *comments) BuildTokens(to Tokens) Tokens {
+        return c.tokens.BuildTokens(to)
+}
+
+type identifier struct {
+        leafNode
+
+        parent *node
+        token  *Token
+}
+
+func newIdentifier(token *Token) *identifier {
+        return &identifier{
+                token: token,
+        }
+}
+
+func (i *identifier) BuildTokens(to Tokens) Tokens {
+        return append(to, i.token)
+}
+
+func (i *identifier) hasName(name string) bool {
+        return name == string(i.token.Bytes)
+}
+
+type number struct {
+        leafNode
+
+        parent *node
+        token  *Token
+}
+
+func newNumber(token *Token) *number {
+        return &number{
+                token: token,
+        }
+}
+
+func (n *number) BuildTokens(to Tokens) Tokens {
+        return append(to, n.token)
+}
+
+type quoted struct {
+        leafNode
+
+        parent *node
+        tokens Tokens
+}
+
+func newQuoted(tokens Tokens) *quoted {
+        return &quoted{
+                tokens: tokens,
+        }
+}
+
+func (q *quoted) BuildTokens(to Tokens) Tokens {
+        return q.tokens.BuildTokens(to)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_attribute.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_attribute.go
new file mode 100644
index 0000000..975fa74
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_attribute.go
@@ -0,0 +1,48 @@
+package hclwrite
+
+import (
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+)
+
+type Attribute struct {
+        inTree
+
+        leadComments *node
+        name         *node
+        expr         *node
+        lineComments *node
+}
+
+func newAttribute() *Attribute {
+        return &Attribute{
+                inTree: newInTree(),
+        }
+}
+
+func (a *Attribute) init(name string, expr *Expression) {
+        expr.assertUnattached()
+
+        nameTok := newIdentToken(name)
+        nameObj := newIdentifier(nameTok)
+        a.leadComments = a.children.Append(newComments(nil))
+        a.name = a.children.Append(nameObj)
+        a.children.AppendUnstructuredTokens(Tokens{
+                {
+                        Type:  hclsyntax.TokenEqual,
+                        Bytes: []byte{'='},
+                },
+        })
+        a.expr = a.children.Append(expr)
+        a.expr.list = a.children
+        a.lineComments = a.children.Append(newComments(nil))
+        a.children.AppendUnstructuredTokens(Tokens{
+                {
+                        Type:  hclsyntax.TokenNewline,
+                        Bytes: []byte{'\n'},
+                },
+        })
+}
+
+func (a *Attribute) Expr() *Expression {
+        return a.expr.content.(*Expression)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_block.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_block.go
new file mode 100644
index 0000000..d5fd32b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_block.go
@@ -0,0 +1,74 @@
+package hclwrite
+
+import (
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+)
+
+type Block struct {
+        inTree
+
+        leadComments *node
+        typeName     *node
+        labels       nodeSet
+        open         *node
+        body         *node
+        close        *node
+}
+
+func newBlock() *Block {
+        return &Block{
+                inTree: newInTree(),
+                labels: newNodeSet(),
+        }
+}
+
+// NewBlock constructs a new, empty block with the given type name and labels.
+func NewBlock(typeName string, labels []string) *Block {
+        block := newBlock()
+        block.init(typeName, labels)
+        return block
+}
+
+func (b *Block) init(typeName string, labels []string) {
+        nameTok := newIdentToken(typeName)
+        nameObj := newIdentifier(nameTok)
+        b.leadComments = b.children.Append(newComments(nil))
+        b.typeName = b.children.Append(nameObj)
+        for _, label := range labels {
+                labelToks := TokensForValue(cty.StringVal(label))
+                labelObj := newQuoted(labelToks)
+                labelNode := b.children.Append(labelObj)
+                b.labels.Add(labelNode)
+        }
+        b.open = b.children.AppendUnstructuredTokens(Tokens{
+                {
+                        Type:  hclsyntax.TokenOBrace,
+                        Bytes: []byte{'{'},
+                },
+                {
+                        Type:  hclsyntax.TokenNewline,
+                        Bytes: []byte{'\n'},
+                },
+        })
+        body := newBody() // initially totally empty; caller can append to it subsequently
+        b.body = b.children.Append(body)
+        b.close = b.children.AppendUnstructuredTokens(Tokens{
+                {
+                        Type:  hclsyntax.TokenCBrace,
+                        Bytes: []byte{'}'},
+                },
+                {
+                        Type:  hclsyntax.TokenNewline,
+                        Bytes: []byte{'\n'},
+                },
+        })
+}
+
+// Body returns the body that represents the content of the receiving block.
+//
+// Appending to or otherwise modifying this body will make changes to the
+// tokens that are generated between the blocks open and close braces.
+func (b *Block) Body() *Body {
+        return b.body.content.(*Body)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_body.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_body.go
new file mode 100644
index 0000000..cf69fee
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_body.go
@@ -0,0 +1,153 @@
+package hclwrite
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+)
+
+type Body struct {
+        inTree
+
+        items nodeSet
+}
+
+func newBody() *Body {
+        return &Body{
+                inTree: newInTree(),
+                items:  newNodeSet(),
+        }
+}
+
+func (b *Body) appendItem(c nodeContent) *node {
+        nn := b.children.Append(c)
+        b.items.Add(nn)
+        return nn
+}
+
+func (b *Body) appendItemNode(nn *node) *node {
+        nn.assertUnattached()
+        b.children.AppendNode(nn)
+        b.items.Add(nn)
+        return nn
+}
+
+// Clear removes all of the items from the body, making it empty.
+func (b *Body) Clear() {
+        b.children.Clear()
+}
+
+func (b *Body) AppendUnstructuredTokens(ts Tokens) {
+        b.inTree.children.Append(ts)
+}
+
+// Attributes returns a new map of all of the attributes in the body, with
+// the attribute names as the keys.
+func (b *Body) Attributes() map[string]*Attribute {
+        ret := make(map[string]*Attribute)
+        for n := range b.items {
+                if attr, isAttr := n.content.(*Attribute); isAttr {
+                        nameObj := attr.name.content.(*identifier)
+                        name := string(nameObj.token.Bytes)
+                        ret[name] = attr
+                }
+        }
+        return ret
+}
+
+// Blocks returns a new slice of all the blocks in the body.
+func (b *Body) Blocks() []*Block {
+        ret := make([]*Block, 0, len(b.items))
+        for n := range b.items {
+                if block, isBlock := n.content.(*Block); isBlock {
+                        ret = append(ret, block)
+                }
+        }
+        return ret
+}
+
+// GetAttribute returns the attribute from the body that has the given name,
+// or returns nil if there is currently no matching attribute.
+func (b *Body) GetAttribute(name string) *Attribute {
+        for n := range b.items {
+                if attr, isAttr := n.content.(*Attribute); isAttr {
+                        nameObj := attr.name.content.(*identifier)
+                        if nameObj.hasName(name) {
+                                // We've found it!
+                                return attr
+                        }
+                }
+        }
+
+        return nil
+}
+
+// SetAttributeValue either replaces the expression of an existing attribute
+// of the given name or adds a new attribute definition to the end of the block.
+//
+// The value is given as a cty.Value, and must therefore be a literal. To set
+// a variable reference or other traversal, use SetAttributeTraversal.
+//
+// The return value is the attribute that was either modified in-place or
+// created.
+func (b *Body) SetAttributeValue(name string, val cty.Value) *Attribute {
+        attr := b.GetAttribute(name)
+        expr := NewExpressionLiteral(val)
+        if attr != nil {
+                attr.expr = attr.expr.ReplaceWith(expr)
+        } else {
+                attr := newAttribute()
+                attr.init(name, expr)
+                b.appendItem(attr)
+        }
+        return attr
+}
+
+// SetAttributeTraversal either replaces the expression of an existing attribute
+// of the given name or adds a new attribute definition to the end of the body.
+//
+// The new expression is given as a hcl.Traversal, which must be an absolute
+// traversal. To set a literal value, use SetAttributeValue.
+//
+// The return value is the attribute that was either modified in-place or
+// created.
+func (b *Body) SetAttributeTraversal(name string, traversal hcl.Traversal) *Attribute {
+        attr := b.GetAttribute(name)
+        expr := NewExpressionAbsTraversal(traversal)
+        if attr != nil {
+                attr.expr = attr.expr.ReplaceWith(expr)
+        } else {
+                attr := newAttribute()
+                attr.init(name, expr)
+                b.appendItem(attr)
+        }
+        return attr
+}
+
+// AppendBlock appends an existing block (which must not be already attached
+// to a body) to the end of the receiving body.
+func (b *Body) AppendBlock(block *Block) *Block {
+        b.appendItem(block)
+        return block
+}
+
+// AppendNewBlock appends a new nested block to the end of the receiving body
+// with the given type name and labels.
+func (b *Body) AppendNewBlock(typeName string, labels []string) *Block {
+        block := newBlock()
+        block.init(typeName, labels)
+        b.appendItem(block)
+        return block
+}
+
+// AppendNewline appends a newline token to th end of the receiving body,
+// which generally serves as a separator between different sets of body
+// contents.
+func (b *Body) AppendNewline() {
+        b.AppendUnstructuredTokens(Tokens{
+                {
+                        Type:  hclsyntax.TokenNewline,
+                        Bytes: []byte{'\n'},
+                },
+        })
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_expression.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_expression.go
new file mode 100644
index 0000000..62d89fb
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_expression.go
@@ -0,0 +1,201 @@
+package hclwrite
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+)
+
+type Expression struct {
+        inTree
+
+        absTraversals nodeSet
+}
+
+func newExpression() *Expression {
+        return &Expression{
+                inTree:        newInTree(),
+                absTraversals: newNodeSet(),
+        }
+}
+
+// NewExpressionLiteral constructs an an expression that represents the given
+// literal value.
+//
+// Since an unknown value cannot be represented in source code, this function
+// will panic if the given value is unknown or contains a nested unknown value.
+// Use val.IsWhollyKnown before calling to be sure.
+//
+// HCL native syntax does not directly represent lists, maps, and sets, and
+// instead relies on the automatic conversions to those collection types from
+// either list or tuple constructor syntax. Therefore converting collection
+// values to source code and re-reading them will lose type information, and
+// the reader must provide a suitable type at decode time to recover the
+// original value.
+func NewExpressionLiteral(val cty.Value) *Expression {
+        toks := TokensForValue(val)
+        expr := newExpression()
+        expr.children.AppendUnstructuredTokens(toks)
+        return expr
+}
+
+// NewExpressionAbsTraversal constructs an expression that represents the
+// given traversal, which must be absolute or this function will panic.
+func NewExpressionAbsTraversal(traversal hcl.Traversal) *Expression {
+        if traversal.IsRelative() {
+                panic("can't construct expression from relative traversal")
+        }
+
+        physT := newTraversal()
+        rootName := traversal.RootName()
+        steps := traversal[1:]
+
+        {
+                tn := newTraverseName()
+                tn.name = tn.children.Append(newIdentifier(&Token{
+                        Type:  hclsyntax.TokenIdent,
+                        Bytes: []byte(rootName),
+                }))
+                physT.steps.Add(physT.children.Append(tn))
+        }
+
+        for _, step := range steps {
+                switch ts := step.(type) {
+                case hcl.TraverseAttr:
+                        tn := newTraverseName()
+                        tn.children.AppendUnstructuredTokens(Tokens{
+                                {
+                                        Type:  hclsyntax.TokenDot,
+                                        Bytes: []byte{'.'},
+                                },
+                        })
+                        tn.name = tn.children.Append(newIdentifier(&Token{
+                                Type:  hclsyntax.TokenIdent,
+                                Bytes: []byte(ts.Name),
+                        }))
+                        physT.steps.Add(physT.children.Append(tn))
+                case hcl.TraverseIndex:
+                        ti := newTraverseIndex()
+                        ti.children.AppendUnstructuredTokens(Tokens{
+                                {
+                                        Type:  hclsyntax.TokenOBrack,
+                                        Bytes: []byte{'['},
+                                },
+                        })
+                        indexExpr := NewExpressionLiteral(ts.Key)
+                        ti.key = ti.children.Append(indexExpr)
+                        ti.children.AppendUnstructuredTokens(Tokens{
+                                {
+                                        Type:  hclsyntax.TokenCBrack,
+                                        Bytes: []byte{']'},
+                                },
+                        })
+                        physT.steps.Add(physT.children.Append(ti))
+                }
+        }
+
+        expr := newExpression()
+        expr.absTraversals.Add(expr.children.Append(physT))
+        return expr
+}
+
+// Variables returns the absolute traversals that exist within the receiving
+// expression.
+func (e *Expression) Variables() []*Traversal {
+        nodes := e.absTraversals.List()
+        ret := make([]*Traversal, len(nodes))
+        for i, node := range nodes {
+                ret[i] = node.content.(*Traversal)
+        }
+        return ret
+}
+
+// RenameVariablePrefix examines each of the absolute traversals in the
+// receiving expression to see if they have the given sequence of names as
+// a prefix prefix. If so, they are updated in place to have the given
+// replacement names instead of that prefix.
+//
+// This can be used to implement symbol renaming. The calling application can
+// visit all relevant expressions in its input and apply the same renaming
+// to implement a global symbol rename.
+//
+// The search and replacement traversals must be the same length, or this
+// method will panic. Only attribute access operations can be matched and
+// replaced. Index steps never match the prefix.
+func (e *Expression) RenameVariablePrefix(search, replacement []string) {
+        if len(search) != len(replacement) {
+                panic(fmt.Sprintf("search and replacement length mismatch (%d and %d)", len(search), len(replacement)))
+        }
+Traversals:
+        for node := range e.absTraversals {
+                traversal := node.content.(*Traversal)
+                if len(traversal.steps) < len(search) {
+                        // If it's shorter then it can't have our prefix
+                        continue
+                }
+
+                stepNodes := traversal.steps.List()
+                for i, name := range search {
+                        step, isName := stepNodes[i].content.(*TraverseName)
+                        if !isName {
+                                continue Traversals // only name nodes can match
+                        }
+                        foundNameBytes := step.name.content.(*identifier).token.Bytes
+                        if len(foundNameBytes) != len(name) {
+                                continue Traversals
+                        }
+                        if string(foundNameBytes) != name {
+                                continue Traversals
+                        }
+                }
+
+                // If we get here then the prefix matched, so now we'll swap in
+                // the replacement strings.
+                for i, name := range replacement {
+                        step := stepNodes[i].content.(*TraverseName)
+                        token := step.name.content.(*identifier).token
+                        token.Bytes = []byte(name)
+                }
+        }
+}
+
+// Traversal represents a sequence of variable, attribute, and/or index
+// operations.
+type Traversal struct {
+        inTree
+
+        steps nodeSet
+}
+
+func newTraversal() *Traversal {
+        return &Traversal{
+                inTree: newInTree(),
+                steps:  newNodeSet(),
+        }
+}
+
+type TraverseName struct {
+        inTree
+
+        name *node
+}
+
+func newTraverseName() *TraverseName {
+        return &TraverseName{
+                inTree: newInTree(),
+        }
+}
+
+type TraverseIndex struct {
+        inTree
+
+        key *node
+}
+
+func newTraverseIndex() *TraverseIndex {
+        return &TraverseIndex{
+                inTree: newInTree(),
+        }
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/doc.go b/vendor/github.com/hashicorp/hcl2/hclwrite/doc.go
new file mode 100644
index 0000000..56d5b77
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/doc.go
@@ -0,0 +1,11 @@
+// Package hclwrite deals with the problem of generating HCL configuration
+// and of making specific surgical changes to existing HCL configurations.
+//
+// It operates at a different level of abstraction than the main HCL parser
+// and AST, since details such as the placement of comments and newlines
+// are preserved when unchanged.
+//
+// The hclwrite API follows a similar principle to XML/HTML DOM, allowing nodes
+// to be read out, created and inserted, etc. Nodes represent syntax constructs
+// rather than semantic concepts.
+package hclwrite
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
new file mode 100644
index 0000000..f20ae23
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
@@ -0,0 +1,492 @@
+package hclwrite
+
+import (
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+)
+
+var inKeyword = hclsyntax.Keyword([]byte{'i', 'n'})
+
+// placeholder token used when we don't have a token but we don't want
+// to pass a real "nil" and complicate things with nil pointer checks
+var nilToken = &Token{
+        Type:         hclsyntax.TokenNil,
+        Bytes:        []byte{},
+        SpacesBefore: 0,
+}
+
+// format rewrites tokens within the given sequence, in-place, to adjust the
+// whitespace around their content to achieve canonical formatting.
+func format(tokens Tokens) {
+        // Formatting is a multi-pass process. More details on the passes below,
+        // but this is the overview:
+        // - adjust the leading space on each line to create appropriate
+        //   indentation
+        // - adjust spaces between tokens in a single cell using a set of rules
+        // - adjust the leading space in the "assign" and "comment" cells on each
+        //   line to vertically align with neighboring lines.
+        // All of these steps operate in-place on the given tokens, so a caller
+        // may collect a flat sequence of all of the tokens underlying an AST
+        // and pass it here and we will then indirectly modify the AST itself.
+        // Formatting must change only whitespace. Specifically, that means
+        // changing the SpacesBefore attribute on a token while leaving the
+        // other token attributes unchanged.
+
+        lines := linesForFormat(tokens)
+        formatIndent(lines)
+        formatSpaces(lines)
+        formatCells(lines)
+}
+
+func formatIndent(lines []formatLine) {
+        // Our methodology for indents is to take the input one line at a time
+        // and count the bracketing delimiters on each line. If a line has a net
+        // increase in open brackets, we increase the indent level by one and
+        // remember how many new openers we had. If the line has a net _decrease_,
+        // we'll compare it to the most recent number of openers and decrease the
+        // dedent level by one each time we pass an indent level remembered
+        // earlier.
+        // The "indent stack" used here allows for us to recognize degenerate
+        // input where brackets are not symmetrical within lines and avoid
+        // pushing things too far left or right, creating confusion.
+
+        // We'll start our indent stack at a reasonable capacity to minimize the
+        // chance of us needing to grow it; 10 here means 10 levels of indent,
+        // which should be more than enough for reasonable HCL uses.
+        indents := make([]int, 0, 10)
+
+        inHeredoc := false
+        for i := range lines {
+                line := &lines[i]
+                if len(line.lead) == 0 {
+                        continue
+                }
+
+                if inHeredoc {
+                        for _, token := range line.lead {
+                                if token.Type == hclsyntax.TokenCHeredoc {
+                                        inHeredoc = false
+                                }
+                        }
+                        continue // don't touch indentation inside heredocs
+                }
+
+                if line.lead[0].Type == hclsyntax.TokenNewline {
+                        // Never place spaces before a newline
+                        line.lead[0].SpacesBefore = 0
+                        continue
+                }
+
+                netBrackets := 0
+                for _, token := range line.lead {
+                        netBrackets += tokenBracketChange(token)
+                        if token.Type == hclsyntax.TokenOHeredoc {
+                                inHeredoc = true
+                        }
+                }
+                for _, token := range line.assign {
+                        netBrackets += tokenBracketChange(token)
+                }
+
+                switch {
+                case netBrackets > 0:
+                        line.lead[0].SpacesBefore = 2 * len(indents)
+                        indents = append(indents, netBrackets)
+                case netBrackets < 0:
+                        closed := -netBrackets
+                        for closed > 0 && len(indents) > 0 {
+                                switch {
+
+                                case closed > indents[len(indents)-1]:
+                                        closed -= indents[len(indents)-1]
+                                        indents = indents[:len(indents)-1]
+
+                                case closed < indents[len(indents)-1]:
+                                        indents[len(indents)-1] -= closed
+                                        closed = 0
+
+                                default:
+                                        indents = indents[:len(indents)-1]
+                                        closed = 0
+                                }
+                        }
+                        line.lead[0].SpacesBefore = 2 * len(indents)
+                default:
+                        line.lead[0].SpacesBefore = 2 * len(indents)
+                }
+        }
+}
+
+func formatSpaces(lines []formatLine) {
+        for _, line := range lines {
+                for i, token := range line.lead {
+                        var before, after *Token
+                        if i > 0 {
+                                before = line.lead[i-1]
+                        } else {
+                                before = nilToken
+                        }
+                        if i < (len(line.lead) - 1) {
+                                after = line.lead[i+1]
+                        } else {
+                                after = nilToken
+                        }
+                        if spaceAfterToken(token, before, after) {
+                                after.SpacesBefore = 1
+                        } else {
+                                after.SpacesBefore = 0
+                        }
+                }
+                for i, token := range line.assign {
+                        if i == 0 {
+                                // first token in "assign" always has one space before to
+                                // separate the equals sign from what it's assigning.
+                                token.SpacesBefore = 1
+                        }
+
+                        var before, after *Token
+                        if i > 0 {
+                                before = line.assign[i-1]
+                        } else {
+                                before = nilToken
+                        }
+                        if i < (len(line.assign) - 1) {
+                                after = line.assign[i+1]
+                        } else {
+                                after = nilToken
+                        }
+                        if spaceAfterToken(token, before, after) {
+                                after.SpacesBefore = 1
+                        } else {
+                                after.SpacesBefore = 0
+                        }
+                }
+
+        }
+}
+
+func formatCells(lines []formatLine) {
+
+        chainStart := -1
+        maxColumns := 0
+
+        // We'll deal with the "assign" cell first, since moving that will
+        // also impact the "comment" cell.
+        closeAssignChain := func(i int) {
+                for _, chainLine := range lines[chainStart:i] {
+                        columns := chainLine.lead.Columns()
+                        spaces := (maxColumns - columns) + 1
+                        chainLine.assign[0].SpacesBefore = spaces
+                }
+                chainStart = -1
+                maxColumns = 0
+        }
+        for i, line := range lines {
+                if line.assign == nil {
+                        if chainStart != -1 {
+                                closeAssignChain(i)
+                        }
+                } else {
+                        if chainStart == -1 {
+                                chainStart = i
+                        }
+                        columns := line.lead.Columns()
+                        if columns > maxColumns {
+                                maxColumns = columns
+                        }
+                }
+        }
+        if chainStart != -1 {
+                closeAssignChain(len(lines))
+        }
+
+        // Now we'll deal with the comments
+        closeCommentChain := func(i int) {
+                for _, chainLine := range lines[chainStart:i] {
+                        columns := chainLine.lead.Columns() + chainLine.assign.Columns()
+                        spaces := (maxColumns - columns) + 1
+                        chainLine.comment[0].SpacesBefore = spaces
+                }
+                chainStart = -1
+                maxColumns = 0
+        }
+        for i, line := range lines {
+                if line.comment == nil {
+                        if chainStart != -1 {
+                                closeCommentChain(i)
+                        }
+                } else {
+                        if chainStart == -1 {
+                                chainStart = i
+                        }
+                        columns := line.lead.Columns() + line.assign.Columns()
+                        if columns > maxColumns {
+                                maxColumns = columns
+                        }
+                }
+        }
+        if chainStart != -1 {
+                closeCommentChain(len(lines))
+        }
+
+}
+
+// spaceAfterToken decides whether a particular subject token should have a
+// space after it when surrounded by the given before and after tokens.
+// "before" can be TokenNil, if the subject token is at the start of a sequence.
+func spaceAfterToken(subject, before, after *Token) bool {
+        switch {
+
+        case after.Type == hclsyntax.TokenNewline || after.Type == hclsyntax.TokenNil:
+                // Never add spaces before a newline
+                return false
+
+        case subject.Type == hclsyntax.TokenIdent && after.Type == hclsyntax.TokenOParen:
+                // Don't split a function name from open paren in a call
+                return false
+
+        case subject.Type == hclsyntax.TokenDot || after.Type == hclsyntax.TokenDot:
+                // Don't use spaces around attribute access dots
+                return false
+
+        case after.Type == hclsyntax.TokenComma || after.Type == hclsyntax.TokenEllipsis:
+                // No space right before a comma or ... in an argument list
+                return false
+
+        case subject.Type == hclsyntax.TokenComma:
+                // Always a space after a comma
+                return true
+
+        case subject.Type == hclsyntax.TokenQuotedLit || subject.Type == hclsyntax.TokenStringLit || subject.Type == hclsyntax.TokenOQuote || subject.Type == hclsyntax.TokenOHeredoc || after.Type == hclsyntax.TokenQuotedLit || after.Type == hclsyntax.TokenStringLit || after.Type == hclsyntax.TokenCQuote || after.Type == hclsyntax.TokenCHeredoc:
+                // No extra spaces within templates
+                return false
+
+        case inKeyword.TokenMatches(subject.asHCLSyntax()) && before.Type == hclsyntax.TokenIdent:
+                // This is a special case for inside for expressions where a user
+                // might want to use a literal tuple constructor:
+                // [for x in [foo]: x]
+                // ... in that case, we would normally produce in[foo] thinking that
+                // in is a reference, but we'll recognize it as a keyword here instead
+                // to make the result less confusing.
+                return true
+
+        case after.Type == hclsyntax.TokenOBrack && (subject.Type == hclsyntax.TokenIdent || subject.Type == hclsyntax.TokenNumberLit || tokenBracketChange(subject) < 0):
+                return false
+
+        case subject.Type == hclsyntax.TokenMinus:
+                // Since a minus can either be subtraction or negation, and the latter
+                // should _not_ have a space after it, we need to use some heuristics
+                // to decide which case this is.
+                // We guess that we have a negation if the token before doesn't look
+                // like it could be the end of an expression.
+
+                switch before.Type {
+
+                case hclsyntax.TokenNil:
+                        // Minus at the start of input must be a negation
+                        return false
+
+                case hclsyntax.TokenOParen, hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenEqual, hclsyntax.TokenColon, hclsyntax.TokenComma, hclsyntax.TokenQuestion:
+                        // Minus immediately after an opening bracket or separator must be a negation.
+                        return false
+
+                case hclsyntax.TokenPlus, hclsyntax.TokenStar, hclsyntax.TokenSlash, hclsyntax.TokenPercent, hclsyntax.TokenMinus:
+                        // Minus immediately after another arithmetic operator must be negation.
+                        return false
+
+                case hclsyntax.TokenEqualOp, hclsyntax.TokenNotEqual, hclsyntax.TokenGreaterThan, hclsyntax.TokenGreaterThanEq, hclsyntax.TokenLessThan, hclsyntax.TokenLessThanEq:
+                        // Minus immediately after another comparison operator must be negation.
+                        return false
+
+                case hclsyntax.TokenAnd, hclsyntax.TokenOr, hclsyntax.TokenBang:
+                        // Minus immediately after logical operator doesn't make sense but probably intended as negation.
+                        return false
+
+                default:
+                        return true
+                }
+
+        case subject.Type == hclsyntax.TokenOBrace || after.Type == hclsyntax.TokenCBrace:
+                // Unlike other bracket types, braces have spaces on both sides of them,
+                // both in single-line nested blocks foo { bar = baz } and in object
+                // constructor expressions foo = { bar = baz }.
+                if subject.Type == hclsyntax.TokenOBrace && after.Type == hclsyntax.TokenCBrace {
+                        // An open brace followed by a close brace is an exception, however.
+                        // e.g. foo {} rather than foo { }
+                        return false
+                }
+                return true
+
+        // In the unlikely event that an interpolation expression is just
+        // a single object constructor, we'll put a space between the ${ and
+        // the following { to make this more obvious, and then the same
+        // thing for the two braces at the end.
+        case (subject.Type == hclsyntax.TokenTemplateInterp || subject.Type == hclsyntax.TokenTemplateControl) && after.Type == hclsyntax.TokenOBrace:
+                return true
+        case subject.Type == hclsyntax.TokenCBrace && after.Type == hclsyntax.TokenTemplateSeqEnd:
+                return true
+
+        // Don't add spaces between interpolated items
+        case subject.Type == hclsyntax.TokenTemplateSeqEnd && after.Type == hclsyntax.TokenTemplateInterp:
+                return false
+
+        case tokenBracketChange(subject) > 0:
+                // No spaces after open brackets
+                return false
+
+        case tokenBracketChange(after) < 0:
+                // No spaces before close brackets
+                return false
+
+        default:
+                // Most tokens are space-separated
+                return true
+
+        }
+}
+
+func linesForFormat(tokens Tokens) []formatLine {
+        if len(tokens) == 0 {
+                return make([]formatLine, 0)
+        }
+
+        // first we'll count our lines, so we can allocate the array for them in
+        // a single block. (We want to minimize memory pressure in this codepath,
+        // so it can be run somewhat-frequently by editor integrations.)
+        lineCount := 1 // if there are zero newlines then there is one line
+        for _, tok := range tokens {
+                if tokenIsNewline(tok) {
+                        lineCount++
+                }
+        }
+
+        // To start, we'll just put everything in the "lead" cell on each line,
+        // and then do another pass over the lines afterwards to adjust.
+        lines := make([]formatLine, lineCount)
+        li := 0
+        lineStart := 0
+        for i, tok := range tokens {
+                if tok.Type == hclsyntax.TokenEOF {
+                        // The EOF token doesn't belong to any line, and terminates the
+                        // token sequence.
+                        lines[li].lead = tokens[lineStart:i]
+                        break
+                }
+
+                if tokenIsNewline(tok) {
+                        lines[li].lead = tokens[lineStart : i+1]
+                        lineStart = i + 1
+                        li++
+                }
+        }
+
+        // If a set of tokens doesn't end in TokenEOF (e.g. because it's a
+        // fragment of tokens from the middle of a file) then we might fall
+        // out here with a line still pending.
+        if lineStart < len(tokens) {
+                lines[li].lead = tokens[lineStart:]
+                if lines[li].lead[len(lines[li].lead)-1].Type == hclsyntax.TokenEOF {
+                        lines[li].lead = lines[li].lead[:len(lines[li].lead)-1]
+                }
+        }
+
+        // Now we'll pick off any trailing comments and attribute assignments
+        // to shuffle off into the "comment" and "assign" cells.
+        inHeredoc := false
+        for i := range lines {
+                line := &lines[i]
+                if len(line.lead) == 0 {
+                        // if the line is empty then there's nothing for us to do
+                        // (this should happen only for the final line, because all other
+                        // lines would have a newline token of some kind)
+                        continue
+                }
+
+                if inHeredoc {
+                        for _, tok := range line.lead {
+                                if tok.Type == hclsyntax.TokenCHeredoc {
+                                        inHeredoc = false
+                                        break
+                                }
+                        }
+                        // Inside a heredoc everything is "lead", even if there's a
+                        // template interpolation embedded in there that might otherwise
+                        // confuse our logic below.
+                        continue
+                }
+
+                for _, tok := range line.lead {
+                        if tok.Type == hclsyntax.TokenOHeredoc {
+                                inHeredoc = true
+                                break
+                        }
+                }
+
+                if len(line.lead) > 1 && line.lead[len(line.lead)-1].Type == hclsyntax.TokenComment {
+                        line.comment = line.lead[len(line.lead)-1:]
+                        line.lead = line.lead[:len(line.lead)-1]
+                }
+
+                for i, tok := range line.lead {
+                        if i > 0 && tok.Type == hclsyntax.TokenEqual {
+                                // We only move the tokens into "assign" if the RHS seems to
+                                // be a whole expression, which we determine by counting
+                                // brackets. If there's a net positive number of brackets
+                                // then that suggests we're introducing a multi-line expression.
+                                netBrackets := 0
+                                for _, token := range line.lead[i:] {
+                                        netBrackets += tokenBracketChange(token)
+                                }
+
+                                if netBrackets == 0 {
+                                        line.assign = line.lead[i:]
+                                        line.lead = line.lead[:i]
+                                }
+                                break
+                        }
+                }
+        }
+
+        return lines
+}
+
+func tokenIsNewline(tok *Token) bool {
+        if tok.Type == hclsyntax.TokenNewline {
+                return true
+        } else if tok.Type == hclsyntax.TokenComment {
+                // Single line tokens (# and //) consume their terminating newline,
+                // so we need to treat them as newline tokens as well.
+                if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+                        return true
+                }
+        }
+        return false
+}
+
+func tokenBracketChange(tok *Token) int {
+        switch tok.Type {
+        case hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenOParen, hclsyntax.TokenTemplateControl, hclsyntax.TokenTemplateInterp:
+                return 1
+        case hclsyntax.TokenCBrace, hclsyntax.TokenCBrack, hclsyntax.TokenCParen, hclsyntax.TokenTemplateSeqEnd:
+                return -1
+        default:
+                return 0
+        }
+}
+
+// formatLine represents a single line of source code for formatting purposes,
+// splitting its tokens into up to three "cells":
+//
+// lead: always present, representing everything up to one of the others
+// assign: if line contains an attribute assignment, represents the tokens
+//    starting at (and including) the equals symbol
+// comment: if line contains any non-comment tokens and ends with a
+//    single-line comment token, represents the comment.
+//
+// When formatting, the leading spaces of the first tokens in each of these
+// cells is adjusted to align vertically their occurences on consecutive
+// rows.
+type formatLine struct {
+        lead    Tokens
+        assign  Tokens
+        comment Tokens
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/generate.go b/vendor/github.com/hashicorp/hcl2/hclwrite/generate.go
new file mode 100644
index 0000000..d249cfd
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/generate.go
@@ -0,0 +1,250 @@
+package hclwrite
+
+import (
+        "fmt"
+        "unicode"
+        "unicode/utf8"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// TokensForValue returns a sequence of tokens that represents the given
+// constant value.
+//
+// This function only supports types that are used by HCL. In particular, it
+// does not support capsule types and will panic if given one.
+//
+// It is not possible to express an unknown value in source code, so this
+// function will panic if the given value is unknown or contains any unknown
+// values. A caller can call the value's IsWhollyKnown method to verify that
+// no unknown values are present before calling TokensForValue.
+func TokensForValue(val cty.Value) Tokens {
+        toks := appendTokensForValue(val, nil)
+        format(toks) // fiddle with the SpacesBefore field to get canonical spacing
+        return toks
+}
+
+// TokensForTraversal returns a sequence of tokens that represents the given
+// traversal.
+//
+// If the traversal is absolute then the result is a self-contained, valid
+// reference expression. If the traversal is relative then the returned tokens
+// could be appended to some other expression tokens to traverse into the
+// represented expression.
+func TokensForTraversal(traversal hcl.Traversal) Tokens {
+        toks := appendTokensForTraversal(traversal, nil)
+        format(toks) // fiddle with the SpacesBefore field to get canonical spacing
+        return toks
+}
+
+func appendTokensForValue(val cty.Value, toks Tokens) Tokens {
+        switch {
+
+        case !val.IsKnown():
+                panic("cannot produce tokens for unknown value")
+
+        case val.IsNull():
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenIdent,
+                        Bytes: []byte(`null`),
+                })
+
+        case val.Type() == cty.Bool:
+                var src []byte
+                if val.True() {
+                        src = []byte(`true`)
+                } else {
+                        src = []byte(`false`)
+                }
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenIdent,
+                        Bytes: src,
+                })
+
+        case val.Type() == cty.Number:
+                bf := val.AsBigFloat()
+                srcStr := bf.Text('f', -1)
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenNumberLit,
+                        Bytes: []byte(srcStr),
+                })
+
+        case val.Type() == cty.String:
+                // TODO: If it's a multi-line string ending in a newline, format
+                // it as a HEREDOC instead.
+                src := escapeQuotedStringLit(val.AsString())
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenOQuote,
+                        Bytes: []byte{'"'},
+                })
+                if len(src) > 0 {
+                        toks = append(toks, &Token{
+                                Type:  hclsyntax.TokenQuotedLit,
+                                Bytes: src,
+                        })
+                }
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenCQuote,
+                        Bytes: []byte{'"'},
+                })
+
+        case val.Type().IsListType() || val.Type().IsSetType() || val.Type().IsTupleType():
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenOBrack,
+                        Bytes: []byte{'['},
+                })
+
+                i := 0
+                for it := val.ElementIterator(); it.Next(); {
+                        if i > 0 {
+                                toks = append(toks, &Token{
+                                        Type:  hclsyntax.TokenComma,
+                                        Bytes: []byte{','},
+                                })
+                        }
+                        _, eVal := it.Element()
+                        toks = appendTokensForValue(eVal, toks)
+                        i++
+                }
+
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenCBrack,
+                        Bytes: []byte{']'},
+                })
+
+        case val.Type().IsMapType() || val.Type().IsObjectType():
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenOBrace,
+                        Bytes: []byte{'{'},
+                })
+
+                i := 0
+                for it := val.ElementIterator(); it.Next(); {
+                        if i > 0 {
+                                toks = append(toks, &Token{
+                                        Type:  hclsyntax.TokenComma,
+                                        Bytes: []byte{','},
+                                })
+                        }
+                        eKey, eVal := it.Element()
+                        if hclsyntax.ValidIdentifier(eKey.AsString()) {
+                                toks = append(toks, &Token{
+                                        Type:  hclsyntax.TokenIdent,
+                                        Bytes: []byte(eKey.AsString()),
+                                })
+                        } else {
+                                toks = appendTokensForValue(eKey, toks)
+                        }
+                        toks = append(toks, &Token{
+                                Type:  hclsyntax.TokenEqual,
+                                Bytes: []byte{'='},
+                        })
+                        toks = appendTokensForValue(eVal, toks)
+                        i++
+                }
+
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenCBrace,
+                        Bytes: []byte{'}'},
+                })
+
+        default:
+                panic(fmt.Sprintf("cannot produce tokens for %#v", val))
+        }
+
+        return toks
+}
+
+func appendTokensForTraversal(traversal hcl.Traversal, toks Tokens) Tokens {
+        for _, step := range traversal {
+                appendTokensForTraversalStep(step, toks)
+        }
+        return toks
+}
+
+func appendTokensForTraversalStep(step hcl.Traverser, toks Tokens) {
+        switch ts := step.(type) {
+        case hcl.TraverseRoot:
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenIdent,
+                        Bytes: []byte(ts.Name),
+                })
+        case hcl.TraverseAttr:
+                toks = append(
+                        toks,
+                        &Token{
+                                Type:  hclsyntax.TokenDot,
+                                Bytes: []byte{'.'},
+                        },
+                        &Token{
+                                Type:  hclsyntax.TokenIdent,
+                                Bytes: []byte(ts.Name),
+                        },
+                )
+        case hcl.TraverseIndex:
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenOBrack,
+                        Bytes: []byte{'['},
+                })
+                appendTokensForValue(ts.Key, toks)
+                toks = append(toks, &Token{
+                        Type:  hclsyntax.TokenCBrack,
+                        Bytes: []byte{']'},
+                })
+        default:
+                panic(fmt.Sprintf("unsupported traversal step type %T", step))
+        }
+}
+
+func escapeQuotedStringLit(s string) []byte {
+        if len(s) == 0 {
+                return nil
+        }
+        buf := make([]byte, 0, len(s))
+        for i, r := range s {
+                switch r {
+                case '\n':
+                        buf = append(buf, '\\', 'n')
+                case '\r':
+                        buf = append(buf, '\\', 'r')
+                case '\t':
+                        buf = append(buf, '\\', 't')
+                case '"':
+                        buf = append(buf, '\\', '"')
+                case '\\':
+                        buf = append(buf, '\\', '\\')
+                case '$', '%':
+                        buf = appendRune(buf, r)
+                        remain := s[i+1:]
+                        if len(remain) > 0 && remain[0] == '{' {
+                                // Double up our template introducer symbol to escape it.
+                                buf = appendRune(buf, r)
+                        }
+                default:
+                        if !unicode.IsPrint(r) {
+                                var fmted string
+                                if r < 65536 {
+                                        fmted = fmt.Sprintf("\\u%04x", r)
+                                } else {
+                                        fmted = fmt.Sprintf("\\U%08x", r)
+                                }
+                                buf = append(buf, fmted...)
+                        } else {
+                                buf = appendRune(buf, r)
+                        }
+                }
+        }
+        return buf
+}
+
+func appendRune(b []byte, r rune) []byte {
+        l := utf8.RuneLen(r)
+        for i := 0; i < l; i++ {
+                b = append(b, 0) // make room at the end of our buffer
+        }
+        ch := b[len(b)-l:]
+        utf8.EncodeRune(ch, r)
+        return b
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/native_node_sorter.go b/vendor/github.com/hashicorp/hcl2/hclwrite/native_node_sorter.go
new file mode 100644
index 0000000..a13c0ec
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/native_node_sorter.go
@@ -0,0 +1,23 @@
+package hclwrite
+
+import (
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+)
+
+type nativeNodeSorter struct {
+        Nodes []hclsyntax.Node
+}
+
+func (s nativeNodeSorter) Len() int {
+        return len(s.Nodes)
+}
+
+func (s nativeNodeSorter) Less(i, j int) bool {
+        rangeI := s.Nodes[i].Range()
+        rangeJ := s.Nodes[j].Range()
+        return rangeI.Start.Byte < rangeJ.Start.Byte
+}
+
+func (s nativeNodeSorter) Swap(i, j int) {
+        s.Nodes[i], s.Nodes[j] = s.Nodes[j], s.Nodes[i]
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/node.go b/vendor/github.com/hashicorp/hcl2/hclwrite/node.go
new file mode 100644
index 0000000..71fd00f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/node.go
@@ -0,0 +1,236 @@
+package hclwrite
+
+import (
+        "fmt"
+
+        "github.com/google/go-cmp/cmp"
+)
+
+// node represents a node in the AST.
+type node struct {
+        content nodeContent
+
+        list          *nodes
+        before, after *node
+}
+
+func newNode(c nodeContent) *node {
+        return &node{
+                content: c,
+        }
+}
+
+func (n *node) Equal(other *node) bool {
+        return cmp.Equal(n.content, other.content)
+}
+
+func (n *node) BuildTokens(to Tokens) Tokens {
+        return n.content.BuildTokens(to)
+}
+
+// Detach removes the receiver from the list it currently belongs to. If the
+// node is not currently in a list, this is a no-op.
+func (n *node) Detach() {
+        if n.list == nil {
+                return
+        }
+        if n.before != nil {
+                n.before.after = n.after
+        }
+        if n.after != nil {
+                n.after.before = n.before
+        }
+        if n.list.first == n {
+                n.list.first = n.after
+        }
+        if n.list.last == n {
+                n.list.last = n.before
+        }
+        n.list = nil
+        n.before = nil
+        n.after = nil
+}
+
+// ReplaceWith removes the receiver from the list it currently belongs to and
+// inserts a new node with the given content in its place. If the node is not
+// currently in a list, this function will panic.
+//
+// The return value is the newly-constructed node, containing the given content.
+// After this function returns, the reciever is no longer attached to a list.
+func (n *node) ReplaceWith(c nodeContent) *node {
+        if n.list == nil {
+                panic("can't replace node that is not in a list")
+        }
+
+        before := n.before
+        after := n.after
+        list := n.list
+        n.before, n.after, n.list = nil, nil, nil
+
+        nn := newNode(c)
+        nn.before = before
+        nn.after = after
+        nn.list = list
+        if before != nil {
+                before.after = nn
+        }
+        if after != nil {
+                after.before = nn
+        }
+        return nn
+}
+
+func (n *node) assertUnattached() {
+        if n.list != nil {
+                panic(fmt.Sprintf("attempt to attach already-attached node %#v", n))
+        }
+}
+
+// nodeContent is the interface type implemented by all AST content types.
+type nodeContent interface {
+        walkChildNodes(w internalWalkFunc)
+        BuildTokens(to Tokens) Tokens
+}
+
+// nodes is a list of nodes.
+type nodes struct {
+        first, last *node
+}
+
+func (ns *nodes) BuildTokens(to Tokens) Tokens {
+        for n := ns.first; n != nil; n = n.after {
+                to = n.BuildTokens(to)
+        }
+        return to
+}
+
+func (ns *nodes) Clear() {
+        ns.first = nil
+        ns.last = nil
+}
+
+func (ns *nodes) Append(c nodeContent) *node {
+        n := &node{
+                content: c,
+        }
+        ns.AppendNode(n)
+        n.list = ns
+        return n
+}
+
+func (ns *nodes) AppendNode(n *node) {
+        if ns.last != nil {
+                n.before = ns.last
+                ns.last.after = n
+        }
+        n.list = ns
+        ns.last = n
+        if ns.first == nil {
+                ns.first = n
+        }
+}
+
+func (ns *nodes) AppendUnstructuredTokens(tokens Tokens) *node {
+        if len(tokens) == 0 {
+                return nil
+        }
+        n := newNode(tokens)
+        ns.AppendNode(n)
+        n.list = ns
+        return n
+}
+
+// nodeSet is an unordered set of nodes. It is used to describe a set of nodes
+// that all belong to the same list that have some role or characteristic
+// in common.
+type nodeSet map[*node]struct{}
+
+func newNodeSet() nodeSet {
+        return make(nodeSet)
+}
+
+func (ns nodeSet) Has(n *node) bool {
+        if ns == nil {
+                return false
+        }
+        _, exists := ns[n]
+        return exists
+}
+
+func (ns nodeSet) Add(n *node) {
+        ns[n] = struct{}{}
+}
+
+func (ns nodeSet) Remove(n *node) {
+        delete(ns, n)
+}
+
+func (ns nodeSet) List() []*node {
+        if len(ns) == 0 {
+                return nil
+        }
+
+        ret := make([]*node, 0, len(ns))
+
+        // Determine which list we are working with. We assume here that all of
+        // the nodes belong to the same list, since that is part of the contract
+        // for nodeSet.
+        var list *nodes
+        for n := range ns {
+                list = n.list
+                break
+        }
+
+        // We recover the order by iterating over the whole list. This is not
+        // the most efficient way to do it, but our node lists should always be
+        // small so not worth making things more complex.
+        for n := list.first; n != nil; n = n.after {
+                if ns.Has(n) {
+                        ret = append(ret, n)
+                }
+        }
+        return ret
+}
+
+type internalWalkFunc func(*node)
+
+// inTree can be embedded into a content struct that has child nodes to get
+// a standard implementation of the NodeContent interface and a record of
+// a potential parent node.
+type inTree struct {
+        parent   *node
+        children *nodes
+}
+
+func newInTree() inTree {
+        return inTree{
+                children: &nodes{},
+        }
+}
+
+func (it *inTree) assertUnattached() {
+        if it.parent != nil {
+                panic(fmt.Sprintf("node is already attached to %T", it.parent.content))
+        }
+}
+
+func (it *inTree) walkChildNodes(w internalWalkFunc) {
+        for n := it.children.first; n != nil; n = n.after {
+                w(n)
+        }
+}
+
+func (it *inTree) BuildTokens(to Tokens) Tokens {
+        for n := it.children.first; n != nil; n = n.after {
+                to = n.BuildTokens(to)
+        }
+        return to
+}
+
+// leafNode can be embedded into a content struct to give it a do-nothing
+// implementation of walkChildNodes
+type leafNode struct {
+}
+
+func (n *leafNode) walkChildNodes(w internalWalkFunc) {
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go b/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go
new file mode 100644
index 0000000..1876818
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go
@@ -0,0 +1,594 @@
+package hclwrite
+
+import (
+        "fmt"
+        "sort"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Our "parser" here is actually not doing any parsing of its own. Instead,
+// it leans on the native parser in hclsyntax, and then uses the source ranges
+// from the AST to partition the raw token sequence to match the raw tokens
+// up to AST nodes.
+//
+// This strategy feels somewhat counter-intuitive, since most of the work the
+// parser does is thrown away here, but this strategy is chosen because the
+// normal parsing work done by hclsyntax is considered to be the "main case",
+// while modifying and re-printing source is more of an edge case, used only
+// in ancillary tools, and so it's good to keep all the main parsing logic
+// with the main case but keep all of the extra complexity of token wrangling
+// out of the main parser, which is already rather complex just serving the
+// use-cases it already serves.
+//
+// If the parsing step produces any errors, the returned File is nil because
+// we can't reliably extract tokens from the partial AST produced by an
+// erroneous parse.
+func parse(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) {
+        file, diags := hclsyntax.ParseConfig(src, filename, start)
+        if diags.HasErrors() {
+                return nil, diags
+        }
+
+        // To do our work here, we use the "native" tokens (those from hclsyntax)
+        // to match against source ranges in the AST, but ultimately produce
+        // slices from our sequence of "writer" tokens, which contain only
+        // *relative* position information that is more appropriate for
+        // transformation/writing use-cases.
+        nativeTokens, diags := hclsyntax.LexConfig(src, filename, start)
+        if diags.HasErrors() {
+                // should never happen, since we would've caught these diags in
+                // the first call above.
+                return nil, diags
+        }
+        writerTokens := writerTokens(nativeTokens)
+
+        from := inputTokens{
+                nativeTokens: nativeTokens,
+                writerTokens: writerTokens,
+        }
+
+        before, root, after := parseBody(file.Body.(*hclsyntax.Body), from)
+        ret := &File{
+                inTree: newInTree(),
+
+                srcBytes: src,
+                body:     root,
+        }
+
+        nodes := ret.inTree.children
+        nodes.Append(before.Tokens())
+        nodes.AppendNode(root)
+        nodes.Append(after.Tokens())
+
+        return ret, diags
+}
+
+type inputTokens struct {
+        nativeTokens hclsyntax.Tokens
+        writerTokens Tokens
+}
+
+func (it inputTokens) Partition(rng hcl.Range) (before, within, after inputTokens) {
+        start, end := partitionTokens(it.nativeTokens, rng)
+        before = it.Slice(0, start)
+        within = it.Slice(start, end)
+        after = it.Slice(end, len(it.nativeTokens))
+        return
+}
+
+func (it inputTokens) PartitionType(ty hclsyntax.TokenType) (before, within, after inputTokens) {
+        for i, t := range it.writerTokens {
+                if t.Type == ty {
+                        return it.Slice(0, i), it.Slice(i, i+1), it.Slice(i+1, len(it.nativeTokens))
+                }
+        }
+        panic(fmt.Sprintf("didn't find any token of type %s", ty))
+}
+
+func (it inputTokens) PartitionTypeSingle(ty hclsyntax.TokenType) (before inputTokens, found *Token, after inputTokens) {
+        before, within, after := it.PartitionType(ty)
+        if within.Len() != 1 {
+                panic("PartitionType found more than one token")
+        }
+        return before, within.Tokens()[0], after
+}
+
+// PartitionIncludeComments is like Partition except the returned "within"
+// range includes any lead and line comments associated with the range.
+func (it inputTokens) PartitionIncludingComments(rng hcl.Range) (before, within, after inputTokens) {
+        start, end := partitionTokens(it.nativeTokens, rng)
+        start = partitionLeadCommentTokens(it.nativeTokens[:start])
+        _, afterNewline := partitionLineEndTokens(it.nativeTokens[end:])
+        end += afterNewline
+
+        before = it.Slice(0, start)
+        within = it.Slice(start, end)
+        after = it.Slice(end, len(it.nativeTokens))
+        return
+
+}
+
+// PartitionBlockItem is similar to PartitionIncludeComments but it returns
+// the comments as separate token sequences so that they can be captured into
+// AST attributes. It makes assumptions that apply only to block items, so
+// should not be used for other constructs.
+func (it inputTokens) PartitionBlockItem(rng hcl.Range) (before, leadComments, within, lineComments, newline, after inputTokens) {
+        before, within, after = it.Partition(rng)
+        before, leadComments = before.PartitionLeadComments()
+        lineComments, newline, after = after.PartitionLineEndTokens()
+        return
+}
+
+func (it inputTokens) PartitionLeadComments() (before, within inputTokens) {
+        start := partitionLeadCommentTokens(it.nativeTokens)
+        before = it.Slice(0, start)
+        within = it.Slice(start, len(it.nativeTokens))
+        return
+}
+
+func (it inputTokens) PartitionLineEndTokens() (comments, newline, after inputTokens) {
+        afterComments, afterNewline := partitionLineEndTokens(it.nativeTokens)
+        comments = it.Slice(0, afterComments)
+        newline = it.Slice(afterComments, afterNewline)
+        after = it.Slice(afterNewline, len(it.nativeTokens))
+        return
+}
+
+func (it inputTokens) Slice(start, end int) inputTokens {
+        // When we slice, we create a new slice with no additional capacity because
+        // we expect that these slices will be mutated in order to insert
+        // new code into the AST, and we want to ensure that a new underlying
+        // array gets allocated in that case, rather than writing into some
+        // following slice and corrupting it.
+        return inputTokens{
+                nativeTokens: it.nativeTokens[start:end:end],
+                writerTokens: it.writerTokens[start:end:end],
+        }
+}
+
+func (it inputTokens) Len() int {
+        return len(it.nativeTokens)
+}
+
+func (it inputTokens) Tokens() Tokens {
+        return it.writerTokens
+}
+
+func (it inputTokens) Types() []hclsyntax.TokenType {
+        ret := make([]hclsyntax.TokenType, len(it.nativeTokens))
+        for i, tok := range it.nativeTokens {
+                ret[i] = tok.Type
+        }
+        return ret
+}
+
+// parseBody locates the given body within the given input tokens and returns
+// the resulting *Body object as well as the tokens that appeared before and
+// after it.
+func parseBody(nativeBody *hclsyntax.Body, from inputTokens) (inputTokens, *node, inputTokens) {
+        before, within, after := from.PartitionIncludingComments(nativeBody.SrcRange)
+
+        // The main AST doesn't retain the original source ordering of the
+        // body items, so we need to reconstruct that ordering by inspecting
+        // their source ranges.
+        nativeItems := make([]hclsyntax.Node, 0, len(nativeBody.Attributes)+len(nativeBody.Blocks))
+        for _, nativeAttr := range nativeBody.Attributes {
+                nativeItems = append(nativeItems, nativeAttr)
+        }
+        for _, nativeBlock := range nativeBody.Blocks {
+                nativeItems = append(nativeItems, nativeBlock)
+        }
+        sort.Sort(nativeNodeSorter{nativeItems})
+
+        body := &Body{
+                inTree: newInTree(),
+                items:  newNodeSet(),
+        }
+
+        remain := within
+        for _, nativeItem := range nativeItems {
+                beforeItem, item, afterItem := parseBodyItem(nativeItem, remain)
+
+                if beforeItem.Len() > 0 {
+                        body.AppendUnstructuredTokens(beforeItem.Tokens())
+                }
+                body.appendItemNode(item)
+
+                remain = afterItem
+        }
+
+        if remain.Len() > 0 {
+                body.AppendUnstructuredTokens(remain.Tokens())
+        }
+
+        return before, newNode(body), after
+}
+
+func parseBodyItem(nativeItem hclsyntax.Node, from inputTokens) (inputTokens, *node, inputTokens) {
+        before, leadComments, within, lineComments, newline, after := from.PartitionBlockItem(nativeItem.Range())
+
+        var item *node
+
+        switch tItem := nativeItem.(type) {
+        case *hclsyntax.Attribute:
+                item = parseAttribute(tItem, within, leadComments, lineComments, newline)
+        case *hclsyntax.Block:
+                item = parseBlock(tItem, within, leadComments, lineComments, newline)
+        default:
+                // should never happen if caller is behaving
+                panic("unsupported native item type")
+        }
+
+        return before, item, after
+}
+
+func parseAttribute(nativeAttr *hclsyntax.Attribute, from, leadComments, lineComments, newline inputTokens) *node {
+        attr := &Attribute{
+                inTree: newInTree(),
+        }
+        children := attr.inTree.children
+
+        {
+                cn := newNode(newComments(leadComments.Tokens()))
+                attr.leadComments = cn
+                children.AppendNode(cn)
+        }
+
+        before, nameTokens, from := from.Partition(nativeAttr.NameRange)
+        {
+                children.AppendUnstructuredTokens(before.Tokens())
+                if nameTokens.Len() != 1 {
+                        // Should never happen with valid input
+                        panic("attribute name is not exactly one token")
+                }
+                token := nameTokens.Tokens()[0]
+                in := newNode(newIdentifier(token))
+                attr.name = in
+                children.AppendNode(in)
+        }
+
+        before, equalsTokens, from := from.Partition(nativeAttr.EqualsRange)
+        children.AppendUnstructuredTokens(before.Tokens())
+        children.AppendUnstructuredTokens(equalsTokens.Tokens())
+
+        before, exprTokens, from := from.Partition(nativeAttr.Expr.Range())
+        {
+                children.AppendUnstructuredTokens(before.Tokens())
+                exprNode := parseExpression(nativeAttr.Expr, exprTokens)
+                attr.expr = exprNode
+                children.AppendNode(exprNode)
+        }
+
+        {
+                cn := newNode(newComments(lineComments.Tokens()))
+                attr.lineComments = cn
+                children.AppendNode(cn)
+        }
+
+        children.AppendUnstructuredTokens(newline.Tokens())
+
+        // Collect any stragglers, though there shouldn't be any
+        children.AppendUnstructuredTokens(from.Tokens())
+
+        return newNode(attr)
+}
+
+func parseBlock(nativeBlock *hclsyntax.Block, from, leadComments, lineComments, newline inputTokens) *node {
+        block := &Block{
+                inTree: newInTree(),
+                labels: newNodeSet(),
+        }
+        children := block.inTree.children
+
+        {
+                cn := newNode(newComments(leadComments.Tokens()))
+                block.leadComments = cn
+                children.AppendNode(cn)
+        }
+
+        before, typeTokens, from := from.Partition(nativeBlock.TypeRange)
+        {
+                children.AppendUnstructuredTokens(before.Tokens())
+                if typeTokens.Len() != 1 {
+                        // Should never happen with valid input
+                        panic("block type name is not exactly one token")
+                }
+                token := typeTokens.Tokens()[0]
+                in := newNode(newIdentifier(token))
+                block.typeName = in
+                children.AppendNode(in)
+        }
+
+        for _, rng := range nativeBlock.LabelRanges {
+                var labelTokens inputTokens
+                before, labelTokens, from = from.Partition(rng)
+                children.AppendUnstructuredTokens(before.Tokens())
+                tokens := labelTokens.Tokens()
+                ln := newNode(newQuoted(tokens))
+                block.labels.Add(ln)
+                children.AppendNode(ln)
+        }
+
+        before, oBrace, from := from.Partition(nativeBlock.OpenBraceRange)
+        children.AppendUnstructuredTokens(before.Tokens())
+        children.AppendUnstructuredTokens(oBrace.Tokens())
+
+        // We go a bit out of order here: we go hunting for the closing brace
+        // so that we have a delimited body, but then we'll deal with the body
+        // before we actually append the closing brace and any straggling tokens
+        // that appear after it.
+        bodyTokens, cBrace, from := from.Partition(nativeBlock.CloseBraceRange)
+        before, body, after := parseBody(nativeBlock.Body, bodyTokens)
+        children.AppendUnstructuredTokens(before.Tokens())
+        block.body = body
+        children.AppendNode(body)
+        children.AppendUnstructuredTokens(after.Tokens())
+
+        children.AppendUnstructuredTokens(cBrace.Tokens())
+
+        // stragglers
+        children.AppendUnstructuredTokens(from.Tokens())
+        if lineComments.Len() > 0 {
+                // blocks don't actually have line comments, so we'll just treat
+                // them as extra stragglers
+                children.AppendUnstructuredTokens(lineComments.Tokens())
+        }
+        children.AppendUnstructuredTokens(newline.Tokens())
+
+        return newNode(block)
+}
+
+func parseExpression(nativeExpr hclsyntax.Expression, from inputTokens) *node {
+        expr := newExpression()
+        children := expr.inTree.children
+
+        nativeVars := nativeExpr.Variables()
+
+        for _, nativeTraversal := range nativeVars {
+                before, traversal, after := parseTraversal(nativeTraversal, from)
+                children.AppendUnstructuredTokens(before.Tokens())
+                children.AppendNode(traversal)
+                expr.absTraversals.Add(traversal)
+                from = after
+        }
+        // Attach any stragglers that don't belong to a traversal to the expression
+        // itself. In an expression with no traversals at all, this is just the
+        // entirety of "from".
+        children.AppendUnstructuredTokens(from.Tokens())
+
+        return newNode(expr)
+}
+
+func parseTraversal(nativeTraversal hcl.Traversal, from inputTokens) (before inputTokens, n *node, after inputTokens) {
+        traversal := newTraversal()
+        children := traversal.inTree.children
+        before, from, after = from.Partition(nativeTraversal.SourceRange())
+
+        stepAfter := from
+        for _, nativeStep := range nativeTraversal {
+                before, step, after := parseTraversalStep(nativeStep, stepAfter)
+                children.AppendUnstructuredTokens(before.Tokens())
+                children.AppendNode(step)
+                traversal.steps.Add(step)
+                stepAfter = after
+        }
+
+        return before, newNode(traversal), after
+}
+
+func parseTraversalStep(nativeStep hcl.Traverser, from inputTokens) (before inputTokens, n *node, after inputTokens) {
+        var children *nodes
+        switch tNativeStep := nativeStep.(type) {
+
+        case hcl.TraverseRoot, hcl.TraverseAttr:
+                step := newTraverseName()
+                children = step.inTree.children
+                before, from, after = from.Partition(nativeStep.SourceRange())
+                inBefore, token, inAfter := from.PartitionTypeSingle(hclsyntax.TokenIdent)
+                name := newIdentifier(token)
+                children.AppendUnstructuredTokens(inBefore.Tokens())
+                step.name = children.Append(name)
+                children.AppendUnstructuredTokens(inAfter.Tokens())
+                return before, newNode(step), after
+
+        case hcl.TraverseIndex:
+                step := newTraverseIndex()
+                children = step.inTree.children
+                before, from, after = from.Partition(nativeStep.SourceRange())
+
+                var inBefore, oBrack, keyTokens, cBrack inputTokens
+                inBefore, oBrack, from = from.PartitionType(hclsyntax.TokenOBrack)
+                children.AppendUnstructuredTokens(inBefore.Tokens())
+                children.AppendUnstructuredTokens(oBrack.Tokens())
+                keyTokens, cBrack, from = from.PartitionType(hclsyntax.TokenCBrack)
+
+                keyVal := tNativeStep.Key
+                switch keyVal.Type() {
+                case cty.String:
+                        key := newQuoted(keyTokens.Tokens())
+                        step.key = children.Append(key)
+                case cty.Number:
+                        valBefore, valToken, valAfter := keyTokens.PartitionTypeSingle(hclsyntax.TokenNumberLit)
+                        children.AppendUnstructuredTokens(valBefore.Tokens())
+                        key := newNumber(valToken)
+                        step.key = children.Append(key)
+                        children.AppendUnstructuredTokens(valAfter.Tokens())
+                }
+
+                children.AppendUnstructuredTokens(cBrack.Tokens())
+                children.AppendUnstructuredTokens(from.Tokens())
+
+                return before, newNode(step), after
+        default:
+                panic(fmt.Sprintf("unsupported traversal step type %T", nativeStep))
+        }
+
+}
+
+// writerTokens takes a sequence of tokens as produced by the main hclsyntax
+// package and transforms it into an equivalent sequence of tokens using
+// this package's own token model.
+//
+// The resulting list contains the same number of tokens and uses the same
+// indices as the input, allowing the two sets of tokens to be correlated
+// by index.
+func writerTokens(nativeTokens hclsyntax.Tokens) Tokens {
+        // Ultimately we want a slice of token _pointers_, but since we can
+        // predict how much memory we're going to devote to tokens we'll allocate
+        // it all as a single flat buffer and thus give the GC less work to do.
+        tokBuf := make([]Token, len(nativeTokens))
+        var lastByteOffset int
+        for i, mainToken := range nativeTokens {
+                // Create a copy of the bytes so that we can mutate without
+                // corrupting the original token stream.
+                bytes := make([]byte, len(mainToken.Bytes))
+                copy(bytes, mainToken.Bytes)
+
+                tokBuf[i] = Token{
+                        Type:  mainToken.Type,
+                        Bytes: bytes,
+
+                        // We assume here that spaces are always ASCII spaces, since
+                        // that's what the scanner also assumes, and thus the number
+                        // of bytes skipped is also the number of space characters.
+                        SpacesBefore: mainToken.Range.Start.Byte - lastByteOffset,
+                }
+
+                lastByteOffset = mainToken.Range.End.Byte
+        }
+
+        // Now make a slice of pointers into the previous slice.
+        ret := make(Tokens, len(tokBuf))
+        for i := range ret {
+                ret[i] = &tokBuf[i]
+        }
+
+        return ret
+}
+
+// partitionTokens takes a sequence of tokens and a hcl.Range and returns
+// two indices within the token sequence that correspond with the range
+// boundaries, such that the slice operator could be used to produce
+// three token sequences for before, within, and after respectively:
+//
+//     start, end := partitionTokens(toks, rng)
+//     before := toks[:start]
+//     within := toks[start:end]
+//     after := toks[end:]
+//
+// This works best when the range is aligned with token boundaries (e.g.
+// because it was produced in terms of the scanner's result) but if that isn't
+// true then it will make a best effort that may produce strange results at
+// the boundaries.
+//
+// Native hclsyntax tokens are used here, because they contain the necessary
+// absolute position information. However, since writerTokens produces a
+// correlatable sequence of writer tokens, the resulting indices can be
+// used also to index into its result, allowing the partitioning of writer
+// tokens to be driven by the partitioning of native tokens.
+//
+// The tokens are assumed to be in source order and non-overlapping, which
+// will be true if the token sequence from the scanner is used directly.
+func partitionTokens(toks hclsyntax.Tokens, rng hcl.Range) (start, end int) {
+        // We us a linear search here because we assume tha in most cases our
+        // target range is close to the beginning of the sequence, and the seqences
+        // are generally small for most reasonable files anyway.
+        for i := 0; ; i++ {
+                if i >= len(toks) {
+                        // No tokens for the given range at all!
+                        return len(toks), len(toks)
+                }
+
+                if toks[i].Range.Start.Byte >= rng.Start.Byte {
+                        start = i
+                        break
+                }
+        }
+
+        for i := start; ; i++ {
+                if i >= len(toks) {
+                        // The range "hangs off" the end of the token sequence
+                        return start, len(toks)
+                }
+
+                if toks[i].Range.Start.Byte >= rng.End.Byte {
+                        end = i // end marker is exclusive
+                        break
+                }
+        }
+
+        return start, end
+}
+
+// partitionLeadCommentTokens takes a sequence of tokens that is assumed
+// to immediately precede a construct that can have lead comment tokens,
+// and returns the index into that sequence where the lead comments begin.
+//
+// Lead comments are defined as whole lines containing only comment tokens
+// with no blank lines between. If no such lines are found, the returned
+// index will be len(toks).
+func partitionLeadCommentTokens(toks hclsyntax.Tokens) int {
+        // single-line comments (which is what we're interested in here)
+        // consume their trailing newline, so we can just walk backwards
+        // until we stop seeing comment tokens.
+        for i := len(toks) - 1; i >= 0; i-- {
+                if toks[i].Type != hclsyntax.TokenComment {
+                        return i + 1
+                }
+        }
+        return 0
+}
+
+// partitionLineEndTokens takes a sequence of tokens that is assumed
+// to immediately follow a construct that can have a line comment, and
+// returns first the index where any line comments end and then second
+// the index immediately after the trailing newline.
+//
+// Line comments are defined as comments that appear immediately after
+// a construct on the same line where its significant tokens ended.
+//
+// Since single-line comment tokens (# and //) include the newline that
+// terminates them, in the presence of these the two returned indices
+// will be the same since the comment itself serves as the line end.
+func partitionLineEndTokens(toks hclsyntax.Tokens) (afterComment, afterNewline int) {
+        for i := 0; i < len(toks); i++ {
+                tok := toks[i]
+                if tok.Type != hclsyntax.TokenComment {
+                        switch tok.Type {
+                        case hclsyntax.TokenNewline:
+                                return i, i + 1
+                        case hclsyntax.TokenEOF:
+                                // Although this is valid, we mustn't include the EOF
+                                // itself as our "newline" or else strange things will
+                                // happen when we try to append new items.
+                                return i, i
+                        default:
+                                // If we have well-formed input here then nothing else should be
+                                // possible. This path should never happen, because we only try
+                                // to extract tokens from the sequence if the parser succeeded,
+                                // and it should catch this problem itself.
+                                panic("malformed line trailers: expected only comments and newlines")
+                        }
+                }
+
+                if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+                        // Newline at the end of a single-line comment serves both as
+                        // the end of comments *and* the end of the line.
+                        return i + 1, i + 1
+                }
+        }
+        return len(toks), len(toks)
+}
+
+// lexConfig uses the hclsyntax scanner to get a token stream and then
+// rewrites it into this package's token model.
+//
+// Any errors produced during scanning are ignored, so the results of this
+// function should be used with care.
+func lexConfig(src []byte) Tokens {
+        mainTokens, _ := hclsyntax.LexConfig(src, "", hcl.Pos{Byte: 0, Line: 1, Column: 1})
+        return writerTokens(mainTokens)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/public.go b/vendor/github.com/hashicorp/hcl2/hclwrite/public.go
new file mode 100644
index 0000000..4d5ce2a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/public.go
@@ -0,0 +1,44 @@
+package hclwrite
+
+import (
+        "bytes"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// NewFile creates a new file object that is empty and ready to have constructs
+// added t it.
+func NewFile() *File {
+        body := &Body{
+                inTree: newInTree(),
+                items:  newNodeSet(),
+        }
+        file := &File{
+                inTree: newInTree(),
+        }
+        file.body = file.inTree.children.Append(body)
+        return file
+}
+
+// ParseConfig interprets the given source bytes into a *hclwrite.File. The
+// resulting AST can be used to perform surgical edits on the source code
+// before turning it back into bytes again.
+func ParseConfig(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) {
+        return parse(src, filename, start)
+}
+
+// Format takes source code and performs simple whitespace changes to transform
+// it to a canonical layout style.
+//
+// Format skips constructing an AST and works directly with tokens, so it
+// is less expensive than formatting via the AST for situations where no other
+// changes will be made. It also ignores syntax errors and can thus be applied
+// to partial source code, although the result in that case may not be
+// desirable.
+func Format(src []byte) []byte {
+        tokens := lexConfig(src)
+        format(tokens)
+        buf := &bytes.Buffer{}
+        tokens.WriteTo(buf)
+        return buf.Bytes()
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go b/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go
new file mode 100644
index 0000000..d87f818
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go
@@ -0,0 +1,122 @@
+package hclwrite
+
+import (
+        "bytes"
+        "io"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+)
+
+// Token is a single sequence of bytes annotated with a type. It is similar
+// in purpose to hclsyntax.Token, but discards the source position information
+// since that is not useful in code generation.
+type Token struct {
+        Type  hclsyntax.TokenType
+        Bytes []byte
+
+        // We record the number of spaces before each token so that we can
+        // reproduce the exact layout of the original file when we're making
+        // surgical changes in-place. When _new_ code is created it will always
+        // be in the canonical style, but we preserve layout of existing code.
+        SpacesBefore int
+}
+
+// asHCLSyntax returns the receiver expressed as an incomplete hclsyntax.Token.
+// A complete token is not possible since we don't have source location
+// information here, and so this method is unexported so we can be sure it will
+// only be used for internal purposes where we know the range isn't important.
+//
+// This is primarily intended to allow us to re-use certain functionality from
+// hclsyntax rather than re-implementing it against our own token type here.
+func (t *Token) asHCLSyntax() hclsyntax.Token {
+        return hclsyntax.Token{
+                Type:  t.Type,
+                Bytes: t.Bytes,
+                Range: hcl.Range{
+                        Filename: "<invalid>",
+                },
+        }
+}
+
+// Tokens is a flat list of tokens.
+type Tokens []*Token
+
+func (ts Tokens) Bytes() []byte {
+        buf := &bytes.Buffer{}
+        ts.WriteTo(buf)
+        return buf.Bytes()
+}
+
+func (ts Tokens) testValue() string {
+        return string(ts.Bytes())
+}
+
+// Columns returns the number of columns (grapheme clusters) the token sequence
+// occupies. The result is not meaningful if there are newline or single-line
+// comment tokens in the sequence.
+func (ts Tokens) Columns() int {
+        ret := 0
+        for _, token := range ts {
+                ret += token.SpacesBefore // spaces are always worth one column each
+                ct, _ := textseg.TokenCount(token.Bytes, textseg.ScanGraphemeClusters)
+                ret += ct
+        }
+        return ret
+}
+
+// WriteTo takes an io.Writer and writes the bytes for each token to it,
+// along with the spacing that separates each token. In other words, this
+// allows serializing the tokens to a file or other such byte stream.
+func (ts Tokens) WriteTo(wr io.Writer) (int64, error) {
+        // We know we're going to be writing a lot of small chunks of repeated
+        // space characters, so we'll prepare a buffer of these that we can
+        // easily pass to wr.Write without any further allocation.
+        spaces := make([]byte, 40)
+        for i := range spaces {
+                spaces[i] = ' '
+        }
+
+        var n int64
+        var err error
+        for _, token := range ts {
+                if err != nil {
+                        return n, err
+                }
+
+                for spacesBefore := token.SpacesBefore; spacesBefore > 0; spacesBefore -= len(spaces) {
+                        thisChunk := spacesBefore
+                        if thisChunk > len(spaces) {
+                                thisChunk = len(spaces)
+                        }
+                        var thisN int
+                        thisN, err = wr.Write(spaces[:thisChunk])
+                        n += int64(thisN)
+                        if err != nil {
+                                return n, err
+                        }
+                }
+
+                var thisN int
+                thisN, err = wr.Write(token.Bytes)
+                n += int64(thisN)
+        }
+
+        return n, err
+}
+
+func (ts Tokens) walkChildNodes(w internalWalkFunc) {
+        // Unstructured tokens have no child nodes
+}
+
+func (ts Tokens) BuildTokens(to Tokens) Tokens {
+        return append(to, ts...)
+}
+
+func newIdentToken(name string) *Token {
+        return &Token{
+                Type:  hclsyntax.TokenIdent,
+                Bytes: []byte(name),
+        }
+}