11 files changed, 2185 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/ast.go b/vendor/github.com/hashicorp/hcl2/hcl/json/ast.go
new file mode 100644
index 0000000..753bfa0
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/ast.go
@@ -0,0 +1,121 @@
+package json
+
+import (
+        "math/big"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+type node interface {
+        Range() hcl.Range
+        StartRange() hcl.Range
+}
+
+type objectVal struct {
+        Attrs      []*objectAttr
+        SrcRange   hcl.Range // range of the entire object, brace-to-brace
+        OpenRange  hcl.Range // range of the opening brace
+        CloseRange hcl.Range // range of the closing brace
+}
+
+func (n *objectVal) Range() hcl.Range {
+        return n.SrcRange
+}
+
+func (n *objectVal) StartRange() hcl.Range {
+        return n.OpenRange
+}
+
+type objectAttr struct {
+        Name      string
+        Value     node
+        NameRange hcl.Range // range of the name string
+}
+
+func (n *objectAttr) Range() hcl.Range {
+        return n.NameRange
+}
+
+func (n *objectAttr) StartRange() hcl.Range {
+        return n.NameRange
+}
+
+type arrayVal struct {
+        Values    []node
+        SrcRange  hcl.Range // range of the entire object, bracket-to-bracket
+        OpenRange hcl.Range // range of the opening bracket
+}
+
+func (n *arrayVal) Range() hcl.Range {
+        return n.SrcRange
+}
+
+func (n *arrayVal) StartRange() hcl.Range {
+        return n.OpenRange
+}
+
+type booleanVal struct {
+        Value    bool
+        SrcRange hcl.Range
+}
+
+func (n *booleanVal) Range() hcl.Range {
+        return n.SrcRange
+}
+
+func (n *booleanVal) StartRange() hcl.Range {
+        return n.SrcRange
+}
+
+type numberVal struct {
+        Value    *big.Float
+        SrcRange hcl.Range
+}
+
+func (n *numberVal) Range() hcl.Range {
+        return n.SrcRange
+}
+
+func (n *numberVal) StartRange() hcl.Range {
+        return n.SrcRange
+}
+
+type stringVal struct {
+        Value    string
+        SrcRange hcl.Range
+}
+
+func (n *stringVal) Range() hcl.Range {
+        return n.SrcRange
+}
+
+func (n *stringVal) StartRange() hcl.Range {
+        return n.SrcRange
+}
+
+type nullVal struct {
+        SrcRange hcl.Range
+}
+
+func (n *nullVal) Range() hcl.Range {
+        return n.SrcRange
+}
+
+func (n *nullVal) StartRange() hcl.Range {
+        return n.SrcRange
+}
+
+// invalidVal is used as a placeholder where a value is needed for a valid
+// parse tree but the input was invalid enough to prevent one from being
+// created.
+type invalidVal struct {
+        SrcRange hcl.Range
+}
+
+func (n invalidVal) Range() hcl.Range {
+        return n.SrcRange
+}
+
+func (n invalidVal) StartRange() hcl.Range {
+        return n.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/didyoumean.go b/vendor/github.com/hashicorp/hcl2/hcl/json/didyoumean.go
new file mode 100644
index 0000000..fbdd8bf
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/didyoumean.go
@@ -0,0 +1,33 @@
+package json
+
+import (
+        "github.com/agext/levenshtein"
+)
+
+var keywords = []string{"false", "true", "null"}
+
+// keywordSuggestion tries to find a valid JSON keyword that is close to the
+// given string and returns it if found. If no keyword is close enough, returns
+// the empty string.
+func keywordSuggestion(given string) string {
+        return nameSuggestion(given, keywords)
+}
+
+// nameSuggestion tries to find a name from the given slice of suggested names
+// that is close to the given name and returns it if found. If no suggestion
+// is close enough, returns the empty string.
+//
+// The suggestions are tried in order, so earlier suggestions take precedence
+// if the given string is similar to two or more suggestions.
+//
+// This function is intended to be used with a relatively-small number of
+// suggestions. It's not optimized for hundreds or thousands of them.
+func nameSuggestion(given string, suggestions []string) string {
+        for _, suggestion := range suggestions {
+                dist := levenshtein.Distance(given, suggestion, nil)
+                if dist < 3 { // threshold determined experimentally
+                        return suggestion
+                }
+        }
+        return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/doc.go b/vendor/github.com/hashicorp/hcl2/hcl/json/doc.go
new file mode 100644
index 0000000..4943f9b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/doc.go
@@ -0,0 +1,8 @@
+// Package json is the JSON parser for HCL. It parses JSON files and returns
+// implementations of the core HCL structural interfaces in terms of the
+// JSON data inside.
+//
+// This is not a generic JSON parser. Instead, it deals with the mapping from
+// the JSON information model to the HCL information model, using a number
+// of hard-coded structural conventions.
+package json
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go b/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go
new file mode 100644
index 0000000..bc8a97f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go
@@ -0,0 +1,70 @@
+package json
+
+import (
+        "fmt"
+        "strings"
+)
+
+type navigation struct {
+        root node
+}
+
+// Implementation of hcled.ContextString
+func (n navigation) ContextString(offset int) string {
+        steps := navigationStepsRev(n.root, offset)
+        if steps == nil {
+                return ""
+        }
+
+        // We built our slice backwards, so we'll reverse it in-place now.
+        half := len(steps) / 2 // integer division
+        for i := 0; i < half; i++ {
+                steps[i], steps[len(steps)-1-i] = steps[len(steps)-1-i], steps[i]
+        }
+
+        ret := strings.Join(steps, "")
+        if len(ret) > 0 && ret[0] == '.' {
+                ret = ret[1:]
+        }
+        return ret
+}
+
+func navigationStepsRev(v node, offset int) []string {
+        switch tv := v.(type) {
+        case *objectVal:
+                // Do any of our properties have an object that contains the target
+                // offset?
+                for _, attr := range tv.Attrs {
+                        k := attr.Name
+                        av := attr.Value
+
+                        switch av.(type) {
+                        case *objectVal, *arrayVal:
+                                // okay
+                        default:
+                                continue
+                        }
+
+                        if av.Range().ContainsOffset(offset) {
+                                return append(navigationStepsRev(av, offset), "."+k)
+                        }
+                }
+        case *arrayVal:
+                // Do any of our elements contain the target offset?
+                for i, elem := range tv.Values {
+
+                        switch elem.(type) {
+                        case *objectVal, *arrayVal:
+                                // okay
+                        default:
+                                continue
+                        }
+
+                        if elem.Range().ContainsOffset(offset) {
+                                return append(navigationStepsRev(elem, offset), fmt.Sprintf("[%d]", i))
+                        }
+                }
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
new file mode 100644
index 0000000..246fd1c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
@@ -0,0 +1,491 @@
+package json
+
+import (
+        "encoding/json"
+        "fmt"
+        "math/big"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+func parseFileContent(buf []byte, filename string) (node, hcl.Diagnostics) {
+        tokens := scan(buf, pos{
+                Filename: filename,
+                Pos: hcl.Pos{
+                        Byte:   0,
+                        Line:   1,
+                        Column: 1,
+                },
+        })
+        p := newPeeker(tokens)
+        node, diags := parseValue(p)
+        if len(diags) == 0 && p.Peek().Type != tokenEOF {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Extraneous data after value",
+                        Detail:   "Extra characters appear after the JSON value.",
+                        Subject:  p.Peek().Range.Ptr(),
+                })
+        }
+        return node, diags
+}
+
+func parseValue(p *peeker) (node, hcl.Diagnostics) {
+        tok := p.Peek()
+
+        wrapInvalid := func(n node, diags hcl.Diagnostics) (node, hcl.Diagnostics) {
+                if n != nil {
+                        return n, diags
+                }
+                return invalidVal{tok.Range}, diags
+        }
+
+        switch tok.Type {
+        case tokenBraceO:
+                return wrapInvalid(parseObject(p))
+        case tokenBrackO:
+                return wrapInvalid(parseArray(p))
+        case tokenNumber:
+                return wrapInvalid(parseNumber(p))
+        case tokenString:
+                return wrapInvalid(parseString(p))
+        case tokenKeyword:
+                return wrapInvalid(parseKeyword(p))
+        case tokenBraceC:
+                return wrapInvalid(nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing attribute value",
+                                Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+                                Subject:  &tok.Range,
+                        },
+                })
+        case tokenBrackC:
+                return wrapInvalid(nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing array element value",
+                                Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+                                Subject:  &tok.Range,
+                        },
+                })
+        case tokenEOF:
+                return wrapInvalid(nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing value",
+                                Detail:   "The JSON data ends prematurely.",
+                                Subject:  &tok.Range,
+                        },
+                })
+        default:
+                return wrapInvalid(nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid start of value",
+                                Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+                                Subject:  &tok.Range,
+                        },
+                })
+        }
+}
+
+func tokenCanStartValue(tok token) bool {
+        switch tok.Type {
+        case tokenBraceO, tokenBrackO, tokenNumber, tokenString, tokenKeyword:
+                return true
+        default:
+                return false
+        }
+}
+
+func parseObject(p *peeker) (node, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+
+        open := p.Read()
+        attrs := []*objectAttr{}
+
+        // recover is used to shift the peeker to what seems to be the end of
+        // our object, so that when we encounter an error we leave the peeker
+        // at a reasonable point in the token stream to continue parsing.
+        recover := func(tok token) {
+                open := 1
+                for {
+                        switch tok.Type {
+                        case tokenBraceO:
+                                open++
+                        case tokenBraceC:
+                                open--
+                                if open <= 1 {
+                                        return
+                                }
+                        case tokenEOF:
+                                // Ran out of source before we were able to recover,
+                                // so we'll bail here and let the caller deal with it.
+                                return
+                        }
+                        tok = p.Read()
+                }
+        }
+
+Token:
+        for {
+                if p.Peek().Type == tokenBraceC {
+                        break Token
+                }
+
+                keyNode, keyDiags := parseValue(p)
+                diags = diags.Extend(keyDiags)
+                if keyNode == nil {
+                        return nil, diags
+                }
+
+                keyStrNode, ok := keyNode.(*stringVal)
+                if !ok {
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid object attribute name",
+                                Detail:   "A JSON object attribute name must be a string",
+                                Subject:  keyNode.StartRange().Ptr(),
+                        })
+                }
+
+                key := keyStrNode.Value
+
+                colon := p.Read()
+                if colon.Type != tokenColon {
+                        recover(colon)
+
+                        if colon.Type == tokenBraceC || colon.Type == tokenComma {
+                                // Catch common mistake of using braces instead of brackets
+                                // for an object.
+                                return nil, diags.Append(&hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Missing object value",
+                                        Detail:   "A JSON object attribute must have a value, introduced by a colon.",
+                                        Subject:  &colon.Range,
+                                })
+                        }
+
+                        if colon.Type == tokenEquals {
+                                // Possible confusion with native HCL syntax.
+                                return nil, diags.Append(&hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Missing attribute value colon",
+                                        Detail:   "JSON uses a colon as its name/value delimiter, not an equals sign.",
+                                        Subject:  &colon.Range,
+                                })
+                        }
+
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing attribute value colon",
+                                Detail:   "A colon must appear between an object attribute's name and its value.",
+                                Subject:  &colon.Range,
+                        })
+                }
+
+                valNode, valDiags := parseValue(p)
+                diags = diags.Extend(valDiags)
+                if valNode == nil {
+                        return nil, diags
+                }
+
+                attrs = append(attrs, &objectAttr{
+                        Name:      key,
+                        Value:     valNode,
+                        NameRange: keyStrNode.SrcRange,
+                })
+
+                switch p.Peek().Type {
+                case tokenComma:
+                        comma := p.Read()
+                        if p.Peek().Type == tokenBraceC {
+                                // Special error message for this common mistake
+                                return nil, diags.Append(&hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Trailing comma in object",
+                                        Detail:   "JSON does not permit a trailing comma after the final attribute in an object.",
+                                        Subject:  &comma.Range,
+                                })
+                        }
+                        continue Token
+                case tokenEOF:
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Unclosed object",
+                                Detail:   "No closing brace was found for this JSON object.",
+                                Subject:  &open.Range,
+                        })
+                case tokenBrackC:
+                        // Consume the bracket anyway, so that we don't return with the peeker
+                        // at a strange place.
+                        p.Read()
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Mismatched braces",
+                                Detail:   "A JSON object must be closed with a brace, not a bracket.",
+                                Subject:  p.Peek().Range.Ptr(),
+                        })
+                case tokenBraceC:
+                        break Token
+                default:
+                        recover(p.Read())
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing attribute seperator comma",
+                                Detail:   "A comma must appear between each attribute declaration in an object.",
+                                Subject:  p.Peek().Range.Ptr(),
+                        })
+                }
+
+        }
+
+        close := p.Read()
+        return &objectVal{
+                Attrs:      attrs,
+                SrcRange:   hcl.RangeBetween(open.Range, close.Range),
+                OpenRange:  open.Range,
+                CloseRange: close.Range,
+        }, diags
+}
+
+func parseArray(p *peeker) (node, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+
+        open := p.Read()
+        vals := []node{}
+
+        // recover is used to shift the peeker to what seems to be the end of
+        // our array, so that when we encounter an error we leave the peeker
+        // at a reasonable point in the token stream to continue parsing.
+        recover := func(tok token) {
+                open := 1
+                for {
+                        switch tok.Type {
+                        case tokenBrackO:
+                                open++
+                        case tokenBrackC:
+                                open--
+                                if open <= 1 {
+                                        return
+                                }
+                        case tokenEOF:
+                                // Ran out of source before we were able to recover,
+                                // so we'll bail here and let the caller deal with it.
+                                return
+                        }
+                        tok = p.Read()
+                }
+        }
+
+Token:
+        for {
+                if p.Peek().Type == tokenBrackC {
+                        break Token
+                }
+
+                valNode, valDiags := parseValue(p)
+                diags = diags.Extend(valDiags)
+                if valNode == nil {
+                        return nil, diags
+                }
+
+                vals = append(vals, valNode)
+
+                switch p.Peek().Type {
+                case tokenComma:
+                        comma := p.Read()
+                        if p.Peek().Type == tokenBrackC {
+                                // Special error message for this common mistake
+                                return nil, diags.Append(&hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Trailing comma in array",
+                                        Detail:   "JSON does not permit a trailing comma after the final attribute in an array.",
+                                        Subject:  &comma.Range,
+                                })
+                        }
+                        continue Token
+                case tokenColon:
+                        recover(p.Read())
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid array value",
+                                Detail:   "A colon is not used to introduce values in a JSON array.",
+                                Subject:  p.Peek().Range.Ptr(),
+                        })
+                case tokenEOF:
+                        recover(p.Read())
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Unclosed object",
+                                Detail:   "No closing bracket was found for this JSON array.",
+                                Subject:  &open.Range,
+                        })
+                case tokenBraceC:
+                        recover(p.Read())
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Mismatched brackets",
+                                Detail:   "A JSON array must be closed with a bracket, not a brace.",
+                                Subject:  p.Peek().Range.Ptr(),
+                        })
+                case tokenBrackC:
+                        break Token
+                default:
+                        recover(p.Read())
+                        return nil, diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing attribute seperator comma",
+                                Detail:   "A comma must appear between each value in an array.",
+                                Subject:  p.Peek().Range.Ptr(),
+                        })
+                }
+
+        }
+
+        close := p.Read()
+        return &arrayVal{
+                Values:    vals,
+                SrcRange:  hcl.RangeBetween(open.Range, close.Range),
+                OpenRange: open.Range,
+        }, diags
+}
+
+func parseNumber(p *peeker) (node, hcl.Diagnostics) {
+        tok := p.Read()
+
+        // Use encoding/json to validate the number syntax.
+        // TODO: Do this more directly to produce better diagnostics.
+        var num json.Number
+        err := json.Unmarshal(tok.Bytes, &num)
+        if err != nil {
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid JSON number",
+                                Detail:   fmt.Sprintf("There is a syntax error in the given JSON number."),
+                                Subject:  &tok.Range,
+                        },
+                }
+        }
+
+        f, _, err := big.ParseFloat(string(num), 10, 512, big.ToNearestEven)
+        if err != nil {
+                // Should never happen if above passed, since JSON numbers are a subset
+                // of what big.Float can parse...
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid JSON number",
+                                Detail:   fmt.Sprintf("There is a syntax error in the given JSON number."),
+                                Subject:  &tok.Range,
+                        },
+                }
+        }
+
+        return &numberVal{
+                Value:    f,
+                SrcRange: tok.Range,
+        }, nil
+}
+
+func parseString(p *peeker) (node, hcl.Diagnostics) {
+        tok := p.Read()
+        var str string
+        err := json.Unmarshal(tok.Bytes, &str)
+
+        if err != nil {
+                var errRange hcl.Range
+                if serr, ok := err.(*json.SyntaxError); ok {
+                        errOfs := serr.Offset
+                        errPos := tok.Range.Start
+                        errPos.Byte += int(errOfs)
+
+                        // TODO: Use the byte offset to properly count unicode
+                        // characters for the column, and mark the whole of the
+                        // character that was wrong as part of our range.
+                        errPos.Column += int(errOfs)
+
+                        errEndPos := errPos
+                        errEndPos.Byte++
+                        errEndPos.Column++
+
+                        errRange = hcl.Range{
+                                Filename: tok.Range.Filename,
+                                Start:    errPos,
+                                End:      errEndPos,
+                        }
+                } else {
+                        errRange = tok.Range
+                }
+
+                var contextRange *hcl.Range
+                if errRange != tok.Range {
+                        contextRange = &tok.Range
+                }
+
+                // FIXME: Eventually we should parse strings directly here so
+                // we can produce a more useful error message in the face fo things
+                // such as invalid escapes, etc.
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid JSON string",
+                                Detail:   fmt.Sprintf("There is a syntax error in the given JSON string."),
+                                Subject:  &errRange,
+                                Context:  contextRange,
+                        },
+                }
+        }
+
+        return &stringVal{
+                Value:    str,
+                SrcRange: tok.Range,
+        }, nil
+}
+
+func parseKeyword(p *peeker) (node, hcl.Diagnostics) {
+        tok := p.Read()
+        s := string(tok.Bytes)
+
+        switch s {
+        case "true":
+                return &booleanVal{
+                        Value:    true,
+                        SrcRange: tok.Range,
+                }, nil
+        case "false":
+                return &booleanVal{
+                        Value:    false,
+                        SrcRange: tok.Range,
+                }, nil
+        case "null":
+                return &nullVal{
+                        SrcRange: tok.Range,
+                }, nil
+        case "undefined", "NaN", "Infinity":
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid JSON keyword",
+                                Detail:   fmt.Sprintf("The JavaScript identifier %q cannot be used in JSON.", s),
+                                Subject:  &tok.Range,
+                        },
+                }
+        default:
+                var dym string
+                if suggest := keywordSuggestion(s); suggest != "" {
+                        dym = fmt.Sprintf(" Did you mean %q?", suggest)
+                }
+
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid JSON keyword",
+                                Detail:   fmt.Sprintf("%q is not a valid JSON keyword.%s", s, dym),
+                                Subject:  &tok.Range,
+                        },
+                }
+        }
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/peeker.go b/vendor/github.com/hashicorp/hcl2/hcl/json/peeker.go
new file mode 100644
index 0000000..fc7bbf5
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/peeker.go
@@ -0,0 +1,25 @@
+package json
+
+type peeker struct {
+        tokens []token
+        pos    int
+}
+
+func newPeeker(tokens []token) *peeker {
+        return &peeker{
+                tokens: tokens,
+                pos:    0,
+        }
+}
+
+func (p *peeker) Peek() token {
+        return p.tokens[p.pos]
+}
+
+func (p *peeker) Read() token {
+        ret := p.tokens[p.pos]
+        if ret.Type != tokenEOF {
+                p.pos++
+        }
+        return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/public.go b/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
new file mode 100644
index 0000000..2728aa1
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
@@ -0,0 +1,94 @@
+package json
+
+import (
+        "fmt"
+        "io/ioutil"
+        "os"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// Parse attempts to parse the given buffer as JSON and, if successful, returns
+// a hcl.File for the HCL configuration represented by it.
+//
+// This is not a generic JSON parser. Instead, it deals only with the profile
+// of JSON used to express HCL configuration.
+//
+// The returned file is valid only if the returned diagnostics returns false
+// from its HasErrors method. If HasErrors returns true, the file represents
+// the subset of data that was able to be parsed, which may be none.
+func Parse(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+        rootNode, diags := parseFileContent(src, filename)
+
+        switch rootNode.(type) {
+        case *objectVal, *arrayVal:
+                // okay
+        default:
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Root value must be object",
+                        Detail:   "The root value in a JSON-based configuration must be either a JSON object or a JSON array of objects.",
+                        Subject:  rootNode.StartRange().Ptr(),
+                })
+
+                // Since we've already produced an error message for this being
+                // invalid, we'll return an empty placeholder here so that trying to
+                // extract content from our root body won't produce a redundant
+                // error saying the same thing again in more general terms.
+                fakePos := hcl.Pos{
+                        Byte:   0,
+                        Line:   1,
+                        Column: 1,
+                }
+                fakeRange := hcl.Range{
+                        Filename: filename,
+                        Start:    fakePos,
+                        End:      fakePos,
+                }
+                rootNode = &objectVal{
+                        Attrs:     []*objectAttr{},
+                        SrcRange:  fakeRange,
+                        OpenRange: fakeRange,
+                }
+        }
+
+        file := &hcl.File{
+                Body: &body{
+                        val: rootNode,
+                },
+                Bytes: src,
+                Nav:   navigation{rootNode},
+        }
+        return file, diags
+}
+
+// ParseFile is a convenience wrapper around Parse that first attempts to load
+// data from the given filename, passing the result to Parse if successful.
+//
+// If the file cannot be read, an error diagnostic with nil context is returned.
+func ParseFile(filename string) (*hcl.File, hcl.Diagnostics) {
+        f, err := os.Open(filename)
+        if err != nil {
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Failed to open file",
+                                Detail:   fmt.Sprintf("The file %q could not be opened.", filename),
+                        },
+                }
+        }
+        defer f.Close()
+
+        src, err := ioutil.ReadAll(f)
+        if err != nil {
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Failed to read file",
+                                Detail:   fmt.Sprintf("The file %q was opened, but an error occured while reading it.", filename),
+                        },
+                }
+        }
+
+        return Parse(src, filename)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go b/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go
new file mode 100644
index 0000000..0a8378b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go
@@ -0,0 +1,293 @@
+package json
+
+import (
+        "fmt"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+//go:generate stringer -type tokenType scanner.go
+type tokenType rune
+
+const (
+        tokenBraceO  tokenType = '{'
+        tokenBraceC  tokenType = '}'
+        tokenBrackO  tokenType = '['
+        tokenBrackC  tokenType = ']'
+        tokenComma   tokenType = ','
+        tokenColon   tokenType = ':'
+        tokenKeyword tokenType = 'K'
+        tokenString  tokenType = 'S'
+        tokenNumber  tokenType = 'N'
+        tokenEOF     tokenType = '␄'
+        tokenInvalid tokenType = 0
+        tokenEquals  tokenType = '=' // used only for reminding the user of JSON syntax
+)
+
+type token struct {
+        Type  tokenType
+        Bytes []byte
+        Range hcl.Range
+}
+
+// scan returns the primary tokens for the given JSON buffer in sequence.
+//
+// The responsibility of this pass is to just mark the slices of the buffer
+// as being of various types. It is lax in how it interprets the multi-byte
+// token types keyword, string and number, preferring to capture erroneous
+// extra bytes that we presume the user intended to be part of the token
+// so that we can generate more helpful diagnostics in the parser.
+func scan(buf []byte, start pos) []token {
+        var tokens []token
+        p := start
+        for {
+                if len(buf) == 0 {
+                        tokens = append(tokens, token{
+                                Type:  tokenEOF,
+                                Bytes: nil,
+                                Range: posRange(p, p),
+                        })
+                        return tokens
+                }
+
+                buf, p = skipWhitespace(buf, p)
+
+                if len(buf) == 0 {
+                        tokens = append(tokens, token{
+                                Type:  tokenEOF,
+                                Bytes: nil,
+                                Range: posRange(p, p),
+                        })
+                        return tokens
+                }
+
+                start = p
+
+                first := buf[0]
+                switch {
+                case first == '{' || first == '}' || first == '[' || first == ']' || first == ',' || first == ':' || first == '=':
+                        p.Pos.Column++
+                        p.Pos.Byte++
+                        tokens = append(tokens, token{
+                                Type:  tokenType(first),
+                                Bytes: buf[0:1],
+                                Range: posRange(start, p),
+                        })
+                        buf = buf[1:]
+                case first == '"':
+                        var tokBuf []byte
+                        tokBuf, buf, p = scanString(buf, p)
+                        tokens = append(tokens, token{
+                                Type:  tokenString,
+                                Bytes: tokBuf,
+                                Range: posRange(start, p),
+                        })
+                case byteCanStartNumber(first):
+                        var tokBuf []byte
+                        tokBuf, buf, p = scanNumber(buf, p)
+                        tokens = append(tokens, token{
+                                Type:  tokenNumber,
+                                Bytes: tokBuf,
+                                Range: posRange(start, p),
+                        })
+                case byteCanStartKeyword(first):
+                        var tokBuf []byte
+                        tokBuf, buf, p = scanKeyword(buf, p)
+                        tokens = append(tokens, token{
+                                Type:  tokenKeyword,
+                                Bytes: tokBuf,
+                                Range: posRange(start, p),
+                        })
+                default:
+                        tokens = append(tokens, token{
+                                Type:  tokenInvalid,
+                                Bytes: buf[:1],
+                                Range: start.Range(1, 1),
+                        })
+                        // If we've encountered an invalid then we might as well stop
+                        // scanning since the parser won't proceed beyond this point.
+                        return tokens
+                }
+        }
+}
+
+func byteCanStartNumber(b byte) bool {
+        switch b {
+        // We are slightly more tolerant than JSON requires here since we
+        // expect the parser will make a stricter interpretation of the
+        // number bytes, but we specifically don't allow 'e' or 'E' here
+        // since we want the scanner to treat that as the start of an
+        // invalid keyword instead, to produce more intelligible error messages.
+        case '-', '+', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                return true
+        default:
+                return false
+        }
+}
+
+func scanNumber(buf []byte, start pos) ([]byte, []byte, pos) {
+        // The scanner doesn't check that the sequence of digit-ish bytes is
+        // in a valid order. The parser must do this when decoding a number
+        // token.
+        var i int
+        p := start
+Byte:
+        for i = 0; i < len(buf); i++ {
+                switch buf[i] {
+                case '-', '+', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                        p.Pos.Byte++
+                        p.Pos.Column++
+                default:
+                        break Byte
+                }
+        }
+        return buf[:i], buf[i:], p
+}
+
+func byteCanStartKeyword(b byte) bool {
+        switch {
+        // We allow any sequence of alphabetical characters here, even though
+        // JSON is more constrained, so that we can collect what we presume
+        // the user intended to be a single keyword and then check its validity
+        // in the parser, where we can generate better diagnostics.
+        // So e.g. we want to be able to say:
+        //   unrecognized keyword "True". Did you mean "true"?
+        case b >= 'a' || b <= 'z' || b >= 'A' || b <= 'Z':
+                return true
+        default:
+                return false
+        }
+}
+
+func scanKeyword(buf []byte, start pos) ([]byte, []byte, pos) {
+        var i int
+        p := start
+Byte:
+        for i = 0; i < len(buf); i++ {
+                b := buf[i]
+                switch {
+                case (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_':
+                        p.Pos.Byte++
+                        p.Pos.Column++
+                default:
+                        break Byte
+                }
+        }
+        return buf[:i], buf[i:], p
+}
+
+func scanString(buf []byte, start pos) ([]byte, []byte, pos) {
+        // The scanner doesn't validate correct use of escapes, etc. It pays
+        // attention to escapes only for the purpose of identifying the closing
+        // quote character. It's the parser's responsibility to do proper
+        // validation.
+        //
+        // The scanner also doesn't specifically detect unterminated string
+        // literals, though they can be identified in the parser by checking if
+        // the final byte in a string token is the double-quote character.
+
+        // Skip the opening quote symbol
+        i := 1
+        p := start
+        p.Pos.Byte++
+        p.Pos.Column++
+        escaping := false
+Byte:
+        for i < len(buf) {
+                b := buf[i]
+
+                switch {
+                case b == '\\':
+                        escaping = !escaping
+                        p.Pos.Byte++
+                        p.Pos.Column++
+                        i++
+                case b == '"':
+                        p.Pos.Byte++
+                        p.Pos.Column++
+                        i++
+                        if !escaping {
+                                break Byte
+                        }
+                        escaping = false
+                case b < 32:
+                        break Byte
+                default:
+                        // Advance by one grapheme cluster, so that we consider each
+                        // grapheme to be a "column".
+                        // Ignoring error because this scanner cannot produce errors.
+                        advance, _, _ := textseg.ScanGraphemeClusters(buf[i:], true)
+
+                        p.Pos.Byte += advance
+                        p.Pos.Column++
+                        i += advance
+
+                        escaping = false
+                }
+        }
+        return buf[:i], buf[i:], p
+}
+
+func skipWhitespace(buf []byte, start pos) ([]byte, pos) {
+        var i int
+        p := start
+Byte:
+        for i = 0; i < len(buf); i++ {
+                switch buf[i] {
+                case ' ':
+                        p.Pos.Byte++
+                        p.Pos.Column++
+                case '\n':
+                        p.Pos.Byte++
+                        p.Pos.Column = 1
+                        p.Pos.Line++
+                case '\r':
+                        // For the purpose of line/column counting we consider a
+                        // carriage return to take up no space, assuming that it will
+                        // be paired up with a newline (on Windows, for example) that
+                        // will account for both of them.
+                        p.Pos.Byte++
+                case '\t':
+                        // We arbitrarily count a tab as if it were two spaces, because
+                        // we need to choose _some_ number here. This means any system
+                        // that renders code on-screen with markers must itself treat
+                        // tabs as a pair of spaces for rendering purposes, or instead
+                        // use the byte offset and back into its own column position.
+                        p.Pos.Byte++
+                        p.Pos.Column += 2
+                default:
+                        break Byte
+                }
+        }
+        return buf[i:], p
+}
+
+type pos struct {
+        Filename string
+        Pos      hcl.Pos
+}
+
+func (p *pos) Range(byteLen, charLen int) hcl.Range {
+        start := p.Pos
+        end := p.Pos
+        end.Byte += byteLen
+        end.Column += charLen
+        return hcl.Range{
+                Filename: p.Filename,
+                Start:    start,
+                End:      end,
+        }
+}
+
+func posRange(start, end pos) hcl.Range {
+        return hcl.Range{
+                Filename: start.Filename,
+                Start:    start.Pos,
+                End:      end.Pos,
+        }
+}
+
+func (t token) GoString() string {
+        return fmt.Sprintf("json.token{json.%s, []byte(%q), %#v}", t.Type, t.Bytes, t.Range)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md
new file mode 100644
index 0000000..9b33c7f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md
@@ -0,0 +1,405 @@
+# HCL JSON Syntax Specification
+
+This is the specification for the JSON serialization for hcl. HCL is a system
+for defining configuration languages for applications. The HCL information
+model is designed to support multiple concrete syntaxes for configuration,
+and this JSON-based format complements [the native syntax](../hclsyntax/spec.md)
+by being easy to machine-generate, whereas the native syntax is oriented
+towards human authoring and maintenence.
+
+This syntax is defined in terms of JSON as defined in
+[RFC7159](https://tools.ietf.org/html/rfc7159). As such it inherits the JSON
+grammar as-is, and merely defines a specific methodology for interpreting
+JSON constructs into HCL structural elements and expressions.
+
+This mapping is defined such that valid JSON-serialized HCL input can be
+_produced_ using standard JSON implementations in various programming languages.
+_Parsing_ such JSON has some additional constraints not beyond what is normally
+supported by JSON parsers, so a specialized parser may be required that
+is able to:
+
+* Preserve the relative ordering of properties defined in an object.
+* Preserve multiple definitions of the same property name.
+* Preserve numeric values to the precision required by the number type
+  in [the HCL syntax-agnostic information model](../spec.md).
+* Retain source location information for parsed tokens/constructs in order
+  to produce good error messages.
+
+## Structural Elements
+
+[The HCL syntax-agnostic information model](../spec.md) defines a _body_ as an
+abstract container for attribute definitions and child blocks. A body is
+represented in JSON as either a single JSON object or a JSON array of objects.
+
+Body processing is in terms of JSON object properties, visited in the order
+they appear in the input. Where a body is represented by a single JSON object,
+the properties of that object are visited in order. Where a body is
+represented by a JSON array, each of its elements are visited in order and
+each element has its properties visited in order. If any element of the array
+is not a JSON object then the input is erroneous.
+
+When a body is being processed in the _dynamic attributes_ mode, the allowance
+of a JSON array in the previous paragraph does not apply and instead a single
+JSON object is always required.
+
+As defined in the language-agnostic model, body processing is in terms
+of a schema which provides context for interpreting the body's content. For
+JSON bodies, the schema is crucial to allow differentiation of attribute
+definitions and block definitions, both of which are represented via object
+properties.
+
+The special property name `"//"`, when used in an object representing a HCL
+body, is parsed and ignored. A property with this name can be used to
+include human-readable comments. (This special property name is _not_
+processed in this way for any _other_ HCL constructs that are represented as
+JSON objects.)
+
+### Attributes
+
+Where the given schema describes an attribute with a given name, the object
+property with the matching name — if present — serves as the attribute's
+definition.
+
+When a body is being processed in the _dynamic attributes_ mode, each object
+property serves as an attribute definition for the attribute whose name
+matches the property name.
+
+The value of an attribute definition property is interpreted as an _expression_,
+as described in a later section.
+
+Given a schema that calls for an attribute named "foo", a JSON object like
+the following provides a definition for that attribute:
+
+```json
+{
+  "foo": "bar baz"
+}
+```
+
+### Blocks
+
+Where the given schema describes a block with a given type name, each object
+property with the matching name serves as a definition of zero or more blocks
+of that type.
+
+Processing of child blocks is in terms of nested JSON objects and arrays.
+If the schema defines one or more _labels_ for the block type, a nested JSON
+object or JSON array of objects is required for each labelling level. These
+are flattened to a single ordered sequence of object properties using the
+same algorithm as for body content as defined above. Each object property
+serves as a label value at the corresponding level.
+
+After any labelling levels, the next nested value is either a JSON object
+representing a single block body, or a JSON array of JSON objects that each
+represent a single block body. Use of an array accommodates the definition
+of multiple blocks that have identical type and labels.
+
+Given a schema that calls for a block type named "foo" with no labels, the
+following JSON objects are all valid definitions of zero or more blocks of this
+type:
+
+```json
+{
+  "foo": {
+    "child_attr": "baz"
+  }
+}
+```
+
+```json
+{
+  "foo": [
+    {
+      "child_attr": "baz"
+    },
+    {
+      "child_attr": "boz"
+    }
+  ]
+}
+```
+```json
+{
+  "foo": []
+}
+```
+
+The first of these defines a single child block of type "foo". The second
+defines _two_ such blocks. The final example shows a degenerate definition
+of zero blocks, though generators should prefer to omit the property entirely
+in this scenario.
+
+Given a schema that calls for a block type named "foo" with _two_ labels, the
+extra label levels must be represented as objects or arrays of objects as in
+the following examples:
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "boz": {
+      "baz": {
+        "child_attr": "baz"
+      },
+    }
+  }
+}
+```
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "boz": {
+      "baz": [
+        {
+          "child_attr": "baz"
+        },
+        {
+          "child_attr": "boz"
+        }
+      ]
+    }
+  }
+}
+```
+
+```json
+{
+  "foo": [
+    {
+      "bar": {
+        "baz": {
+          "child_attr": "baz"
+        },
+        "boz": {
+          "child_attr": "baz"
+        }
+      },
+    },
+    {
+      "bar": {
+        "baz": [
+          {
+            "child_attr": "baz"
+          },
+          {
+            "child_attr": "boz"
+          }
+        ]
+      }
+    }
+  ]
+}
+```
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "bar": {
+      "baz": [
+        {
+          "child_attr": "baz"
+        },
+        {
+          "child_attr": "boz"
+        }
+      ]
+    }
+  }
+}
+```
+
+Arrays can be introduced at either the label definition or block body
+definition levels to define multiple definitions of the same block type
+or labels while preserving order.
+
+A JSON HCL parser _must_ support duplicate definitions of the same property
+name within a single object, preserving all of them and the relative ordering
+between them. The array-based forms are also required so that JSON HCL
+configurations can be produced with JSON producing libraries that are not
+able to preserve property definition order and multiple definitions of
+the same property.
+
+## Expressions
+
+JSON lacks a native expression syntax, so the HCL JSON syntax instead defines
+a mapping for each of the JSON value types, including a special mapping for
+strings that allows optional use of arbitrary expressions.
+
+### Objects
+
+When interpreted as an expression, a JSON object represents a value of a HCL
+object type.
+
+Each property of the JSON object represents an attribute of the HCL object type.
+The property name string given in the JSON input is interpreted as a string
+expression as described below, and its result is converted to string as defined
+by the syntax-agnostic information model. If such a conversion is not possible,
+an error is produced and evaluation fails.
+
+An instance of the constructed object type is then created, whose values
+are interpreted by again recursively applying the mapping rules defined in
+this section to each of the property values.
+
+If any evaluated property name strings produce null values, an error is
+produced and evaluation fails. If any produce _unknown_ values, the _entire
+object's_ result is an unknown value of the dynamic pseudo-type, signalling
+that the type of the object cannot be determined.
+
+It is an error to define the same property name multiple times within a single
+JSON object interpreted as an expression. In full expression mode, this
+constraint applies to the name expression results after conversion to string,
+rather than the raw string that may contain interpolation expressions.
+
+### Arrays
+
+When interpreted as an expression, a JSON array represents a value of a HCL
+tuple type.
+
+Each element of the JSON array represents an element of the HCL tuple type.
+The tuple type is constructed by enumerationg the JSON array elements, creating
+for each an element whose type is the result of recursively applying the
+expression mapping rules. Correspondance is preserved between the array element
+indices and the tuple element indices.
+
+An instance of the constructed tuple type is then created, whose values are
+interpreted by again recursively applying the mapping rules defined in this
+section.
+
+### Numbers
+
+When interpreted as an expression, a JSON number represents a HCL number value.
+
+HCL numbers are arbitrary-precision decimal values, so a JSON HCL parser must
+be able to translate exactly the value given to a number of corresponding
+precision, within the constraints set by the HCL syntax-agnostic information
+model.
+
+In practice, off-the-shelf JSON serializers often do not support customizing the
+processing of numbers, and instead force processing as 32-bit or 64-bit
+floating point values.
+
+A _producer_ of JSON HCL that uses such a serializer can provide numeric values
+as JSON strings where they have precision too great for representation in the
+serializer's chosen numeric type in situations where the result will be
+converted to number (using the standard conversion rules) by a calling
+application.
+
+Alternatively, for expressions that are evaluated in full expression mode an
+embedded template interpolation can be used to faithfully represent a number,
+such as `"${1e150}"`, which will then be evaluated by the underlying HCL native
+syntax expression evaluator.
+
+### Boolean Values
+
+The JSON boolean values `true` and `false`, when interpreted as expressions,
+represent the corresponding HCL boolean values.
+
+### The Null Value
+
+The JSON value `null`, when interpreted as an expression, represents a
+HCL null value of the dynamic pseudo-type.
+
+### Strings
+
+When intepreted as an expression, a JSON string may be interpreted in one of
+two ways depending on the evaluation mode.
+
+If evaluating in literal-only mode (as defined by the syntax-agnostic
+information model) the literal string is intepreted directly as a HCL string
+value, by directly using the exact sequence of unicode characters represented.
+Template interpolations and directives MUST NOT be processed in this mode,
+allowing any characters that appear as introduction sequences to pass through
+literally:
+
+```json
+"Hello world! Template sequences like ${ are not intepreted here."
+```
+
+When evaluating in full expression mode (again, as defined by the syntax-
+agnostic information model) the literal string is instead interpreted as a
+_standalone template_ in the HCL Native Syntax. The expression evaluation
+result is then the direct result of evaluating that template with the current
+variable scope and function table.
+
+```json
+"Hello, ${name}! Template sequences are interpreted in full expression mode."
+```
+
+In particular the _Template Interpolation Unwrapping_ requirement from the
+HCL native syntax specification must be implemented, allowing the use of
+single-interpolation templates to represent expressions that would not
+otherwise be representable in JSON, such as the following example where
+the result must be a number, rather than a string representation of a number:
+
+```json
+"${ a + b }"
+```
+
+## Static Analysis
+
+The HCL static analysis operations are implemented for JSON values that
+represent expressions, as described in the following sections.
+
+Due to the limited expressive power of the JSON syntax alone, use of these
+static analyses functions rather than normal expression evaluation is used
+as additional context for how a JSON value is to be interpreted, which means
+that static analyses can result in a different interpretation of a given
+expression than normal evaluation.
+
+### Static List
+
+An expression interpreted as a static list must be a JSON array. Each of the
+values in the array is interpreted as an expression and returned.
+
+### Static Map
+
+An expression interpreted as a static map must be a JSON object. Each of the
+key/value pairs in the object is presented as a pair of expressions. Since
+object property names are always strings, evaluating the key expression with
+a non-`nil` evaluation context will evaluate any template sequences given
+in the property name.
+
+### Static Call
+
+An expression interpreted as a static call must be a string. The content of
+the string is interpreted as a native syntax expression (not a _template_,
+unlike normal evaluation) and then the static call analysis is delegated to
+that expression.
+
+If the original expression is not a string or its contents cannot be parsed
+as a native syntax expression then static call analysis is not supported.
+
+### Static Traversal
+
+An expression interpreted as a static traversal must be a string. The content
+of the string is interpreted as a native syntax expression (not a _template_,
+unlike normal evaluation) and then static traversal analysis is delegated
+to that expression.
+
+If the original expression is not a string or its contents cannot be parsed
+as a native syntax expression then static call analysis is not supported.
+
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
new file mode 100644
index 0000000..28dcf52
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
@@ -0,0 +1,616 @@
+package json
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+// body is the implementation of "Body" used for files processed with the JSON
+// parser.
+type body struct {
+        val node
+
+        // If non-nil, the keys of this map cause the corresponding attributes to
+        // be treated as non-existing. This is used when Body.PartialContent is
+        // called, to produce the "remaining content" Body.
+        hiddenAttrs map[string]struct{}
+}
+
+// expression is the implementation of "Expression" used for files processed
+// with the JSON parser.
+type expression struct {
+        src node
+}
+
+func (b *body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+        content, newBody, diags := b.PartialContent(schema)
+
+        hiddenAttrs := newBody.(*body).hiddenAttrs
+
+        var nameSuggestions []string
+        for _, attrS := range schema.Attributes {
+                if _, ok := hiddenAttrs[attrS.Name]; !ok {
+                        // Only suggest an attribute name if we didn't use it already.
+                        nameSuggestions = append(nameSuggestions, attrS.Name)
+                }
+        }
+        for _, blockS := range schema.Blocks {
+                // Blocks can appear multiple times, so we'll suggest their type
+                // names regardless of whether they've already been used.
+                nameSuggestions = append(nameSuggestions, blockS.Type)
+        }
+
+        jsonAttrs, attrDiags := b.collectDeepAttrs(b.val, nil)
+        diags = append(diags, attrDiags...)
+
+        for _, attr := range jsonAttrs {
+                k := attr.Name
+                if k == "//" {
+                        // Ignore "//" keys in objects representing bodies, to allow
+                        // their use as comments.
+                        continue
+                }
+
+                if _, ok := hiddenAttrs[k]; !ok {
+                        suggestion := nameSuggestion(k, nameSuggestions)
+                        if suggestion != "" {
+                                suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+                        }
+
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Extraneous JSON object property",
+                                Detail:   fmt.Sprintf("No attribute or block type is named %q.%s", k, suggestion),
+                                Subject:  &attr.NameRange,
+                                Context:  attr.Range().Ptr(),
+                        })
+                }
+        }
+
+        return content, diags
+}
+
+func (b *body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+
+        jsonAttrs, attrDiags := b.collectDeepAttrs(b.val, nil)
+        diags = append(diags, attrDiags...)
+
+        usedNames := map[string]struct{}{}
+        if b.hiddenAttrs != nil {
+                for k := range b.hiddenAttrs {
+                        usedNames[k] = struct{}{}
+                }
+        }
+
+        content := &hcl.BodyContent{
+                Attributes: map[string]*hcl.Attribute{},
+                Blocks:     nil,
+
+                MissingItemRange: b.MissingItemRange(),
+        }
+
+        // Create some more convenient data structures for our work below.
+        attrSchemas := map[string]hcl.AttributeSchema{}
+        blockSchemas := map[string]hcl.BlockHeaderSchema{}
+        for _, attrS := range schema.Attributes {
+                attrSchemas[attrS.Name] = attrS
+        }
+        for _, blockS := range schema.Blocks {
+                blockSchemas[blockS.Type] = blockS
+        }
+
+        for _, jsonAttr := range jsonAttrs {
+                attrName := jsonAttr.Name
+                if _, used := b.hiddenAttrs[attrName]; used {
+                        continue
+                }
+
+                if attrS, defined := attrSchemas[attrName]; defined {
+                        if existing, exists := content.Attributes[attrName]; exists {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate attribute definition",
+                                        Detail:   fmt.Sprintf("The attribute %q was already defined at %s.", attrName, existing.Range),
+                                        Subject:  &jsonAttr.NameRange,
+                                        Context:  jsonAttr.Range().Ptr(),
+                                })
+                                continue
+                        }
+
+                        content.Attributes[attrS.Name] = &hcl.Attribute{
+                                Name:      attrS.Name,
+                                Expr:      &expression{src: jsonAttr.Value},
+                                Range:     hcl.RangeBetween(jsonAttr.NameRange, jsonAttr.Value.Range()),
+                                NameRange: jsonAttr.NameRange,
+                        }
+                        usedNames[attrName] = struct{}{}
+
+                } else if blockS, defined := blockSchemas[attrName]; defined {
+                        bv := jsonAttr.Value
+                        blockDiags := b.unpackBlock(bv, blockS.Type, &jsonAttr.NameRange, blockS.LabelNames, nil, nil, &content.Blocks)
+                        diags = append(diags, blockDiags...)
+                        usedNames[attrName] = struct{}{}
+                }
+
+                // We ignore anything that isn't defined because that's the
+                // PartialContent contract. The Content method will catch leftovers.
+        }
+
+        // Make sure we got all the required attributes.
+        for _, attrS := range schema.Attributes {
+                if !attrS.Required {
+                        continue
+                }
+                if _, defined := content.Attributes[attrS.Name]; !defined {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing required attribute",
+                                Detail:   fmt.Sprintf("The attribute %q is required, but no definition was found.", attrS.Name),
+                                Subject:  b.MissingItemRange().Ptr(),
+                        })
+                }
+        }
+
+        unusedBody := &body{
+                val:         b.val,
+                hiddenAttrs: usedNames,
+        }
+
+        return content, unusedBody, diags
+}
+
+// JustAttributes for JSON bodies interprets all properties of the wrapped
+// JSON object as attributes and returns them.
+func (b *body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        attrs := make(map[string]*hcl.Attribute)
+
+        obj, ok := b.val.(*objectVal)
+        if !ok {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Incorrect JSON value type",
+                        Detail:   "A JSON object is required here, defining the attributes for this block.",
+                        Subject:  b.val.StartRange().Ptr(),
+                })
+                return attrs, diags
+        }
+
+        for _, jsonAttr := range obj.Attrs {
+                name := jsonAttr.Name
+                if name == "//" {
+                        // Ignore "//" keys in objects representing bodies, to allow
+                        // their use as comments.
+                        continue
+                }
+
+                if _, hidden := b.hiddenAttrs[name]; hidden {
+                        continue
+                }
+
+                if existing, exists := attrs[name]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Duplicate attribute definition",
+                                Detail:   fmt.Sprintf("The attribute %q was already defined at %s.", name, existing.Range),
+                                Subject:  &jsonAttr.NameRange,
+                        })
+                        continue
+                }
+
+                attrs[name] = &hcl.Attribute{
+                        Name:      name,
+                        Expr:      &expression{src: jsonAttr.Value},
+                        Range:     hcl.RangeBetween(jsonAttr.NameRange, jsonAttr.Value.Range()),
+                        NameRange: jsonAttr.NameRange,
+                }
+        }
+
+        // No diagnostics possible here, since the parser already took care of
+        // finding duplicates and every JSON value can be a valid attribute value.
+        return attrs, diags
+}
+
+func (b *body) MissingItemRange() hcl.Range {
+        switch tv := b.val.(type) {
+        case *objectVal:
+                return tv.CloseRange
+        case *arrayVal:
+                return tv.OpenRange
+        default:
+                // Should not happen in correct operation, but might show up if the
+                // input is invalid and we are producing partial results.
+                return tv.StartRange()
+        }
+}
+
+func (b *body) unpackBlock(v node, typeName string, typeRange *hcl.Range, labelsLeft []string, labelsUsed []string, labelRanges []hcl.Range, blocks *hcl.Blocks) (diags hcl.Diagnostics) {
+        if len(labelsLeft) > 0 {
+                labelName := labelsLeft[0]
+                jsonAttrs, attrDiags := b.collectDeepAttrs(v, &labelName)
+                diags = append(diags, attrDiags...)
+
+                if len(jsonAttrs) == 0 {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing block label",
+                                Detail:   fmt.Sprintf("At least one object property is required, whose name represents the %s block's %s.", typeName, labelName),
+                                Subject:  v.StartRange().Ptr(),
+                        })
+                        return
+                }
+                labelsUsed := append(labelsUsed, "")
+                labelRanges := append(labelRanges, hcl.Range{})
+                for _, p := range jsonAttrs {
+                        pk := p.Name
+                        labelsUsed[len(labelsUsed)-1] = pk
+                        labelRanges[len(labelRanges)-1] = p.NameRange
+                        diags = append(diags, b.unpackBlock(p.Value, typeName, typeRange, labelsLeft[1:], labelsUsed, labelRanges, blocks)...)
+                }
+                return
+        }
+
+        // By the time we get here, we've peeled off all the labels and we're ready
+        // to deal with the block's actual content.
+
+        // need to copy the label slices because their underlying arrays will
+        // continue to be mutated after we return.
+        labels := make([]string, len(labelsUsed))
+        copy(labels, labelsUsed)
+        labelR := make([]hcl.Range, len(labelRanges))
+        copy(labelR, labelRanges)
+
+        switch tv := v.(type) {
+        case *objectVal:
+                // Single instance of the block
+                *blocks = append(*blocks, &hcl.Block{
+                        Type:   typeName,
+                        Labels: labels,
+                        Body: &body{
+                                val: tv,
+                        },
+
+                        DefRange:    tv.OpenRange,
+                        TypeRange:   *typeRange,
+                        LabelRanges: labelR,
+                })
+        case *arrayVal:
+                // Multiple instances of the block
+                for _, av := range tv.Values {
+                        *blocks = append(*blocks, &hcl.Block{
+                                Type:   typeName,
+                                Labels: labels,
+                                Body: &body{
+                                        val: av, // might be mistyped; we'll find out when content is requested for this body
+                                },
+
+                                DefRange:    tv.OpenRange,
+                                TypeRange:   *typeRange,
+                                LabelRanges: labelR,
+                        })
+                }
+        default:
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Incorrect JSON value type",
+                        Detail:   fmt.Sprintf("Either a JSON object or a JSON array is required, representing the contents of one or more %q blocks.", typeName),
+                        Subject:  v.StartRange().Ptr(),
+                })
+        }
+        return
+}
+
+// collectDeepAttrs takes either a single object or an array of objects and
+// flattens it into a list of object attributes, collecting attributes from
+// all of the objects in a given array.
+//
+// Ordering is preserved, so a list of objects that each have one property
+// will result in those properties being returned in the same order as the
+// objects appeared in the array.
+//
+// This is appropriate for use only for objects representing bodies or labels
+// within a block.
+//
+// The labelName argument, if non-null, is used to tailor returned error
+// messages to refer to block labels rather than attributes and child blocks.
+// It has no other effect.
+func (b *body) collectDeepAttrs(v node, labelName *string) ([]*objectAttr, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        var attrs []*objectAttr
+
+        switch tv := v.(type) {
+
+        case *objectVal:
+                attrs = append(attrs, tv.Attrs...)
+
+        case *arrayVal:
+                for _, ev := range tv.Values {
+                        switch tev := ev.(type) {
+                        case *objectVal:
+                                attrs = append(attrs, tev.Attrs...)
+                        default:
+                                if labelName != nil {
+                                        diags = append(diags, &hcl.Diagnostic{
+                                                Severity: hcl.DiagError,
+                                                Summary:  "Incorrect JSON value type",
+                                                Detail:   fmt.Sprintf("A JSON object is required here, to specify %s labels for this block.", *labelName),
+                                                Subject:  ev.StartRange().Ptr(),
+                                        })
+                                } else {
+                                        diags = append(diags, &hcl.Diagnostic{
+                                                Severity: hcl.DiagError,
+                                                Summary:  "Incorrect JSON value type",
+                                                Detail:   "A JSON object is required here, to define attributes and child blocks.",
+                                                Subject:  ev.StartRange().Ptr(),
+                                        })
+                                }
+                        }
+                }
+
+        default:
+                if labelName != nil {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Incorrect JSON value type",
+                                Detail:   fmt.Sprintf("Either a JSON object or JSON array of objects is required here, to specify %s labels for this block.", *labelName),
+                                Subject:  v.StartRange().Ptr(),
+                        })
+                } else {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Incorrect JSON value type",
+                                Detail:   "Either a JSON object or JSON array of objects is required here, to define attributes and child blocks.",
+                                Subject:  v.StartRange().Ptr(),
+                        })
+                }
+        }
+
+        return attrs, diags
+}
+
+func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+        switch v := e.src.(type) {
+        case *stringVal:
+                if ctx != nil {
+                        // Parse string contents as a HCL native language expression.
+                        // We only do this if we have a context, so passing a nil context
+                        // is how the caller specifies that interpolations are not allowed
+                        // and that the string should just be returned verbatim.
+                        templateSrc := v.Value
+                        expr, diags := hclsyntax.ParseTemplate(
+                                []byte(templateSrc),
+                                v.SrcRange.Filename,
+
+                                // This won't produce _exactly_ the right result, since
+                                // the hclsyntax parser can't "see" any escapes we removed
+                                // while parsing JSON, but it's better than nothing.
+                                hcl.Pos{
+                                        Line: v.SrcRange.Start.Line,
+
+                                        // skip over the opening quote mark
+                                        Byte:   v.SrcRange.Start.Byte + 1,
+                                        Column: v.SrcRange.Start.Column + 1,
+                                },
+                        )
+                        if diags.HasErrors() {
+                                return cty.DynamicVal, diags
+                        }
+                        val, evalDiags := expr.Value(ctx)
+                        diags = append(diags, evalDiags...)
+                        return val, diags
+                }
+
+                return cty.StringVal(v.Value), nil
+        case *numberVal:
+                return cty.NumberVal(v.Value), nil
+        case *booleanVal:
+                return cty.BoolVal(v.Value), nil
+        case *arrayVal:
+                vals := []cty.Value{}
+                for _, jsonVal := range v.Values {
+                        val, _ := (&expression{src: jsonVal}).Value(ctx)
+                        vals = append(vals, val)
+                }
+                return cty.TupleVal(vals), nil
+        case *objectVal:
+                var diags hcl.Diagnostics
+                attrs := map[string]cty.Value{}
+                attrRanges := map[string]hcl.Range{}
+                known := true
+                for _, jsonAttr := range v.Attrs {
+                        // In this one context we allow keys to contain interpolation
+                        // experessions too, assuming we're evaluating in interpolation
+                        // mode. This achieves parity with the native syntax where
+                        // object expressions can have dynamic keys, while block contents
+                        // may not.
+                        name, nameDiags := (&expression{src: &stringVal{
+                                Value:    jsonAttr.Name,
+                                SrcRange: jsonAttr.NameRange,
+                        }}).Value(ctx)
+                        val, valDiags := (&expression{src: jsonAttr.Value}).Value(ctx)
+                        diags = append(diags, nameDiags...)
+                        diags = append(diags, valDiags...)
+
+                        var err error
+                        name, err = convert.Convert(name, cty.String)
+                        if err != nil {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid object key expression",
+                                        Detail:   fmt.Sprintf("Cannot use this expression as an object key: %s.", err),
+                                        Subject:  &jsonAttr.NameRange,
+                                })
+                                continue
+                        }
+                        if name.IsNull() {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid object key expression",
+                                        Detail:   "Cannot use null value as an object key.",
+                                        Subject:  &jsonAttr.NameRange,
+                                })
+                                continue
+                        }
+                        if !name.IsKnown() {
+                                // This is a bit of a weird case, since our usual rules require
+                                // us to tolerate unknowns and just represent the result as
+                                // best we can but if we don't know the key then we can't
+                                // know the type of our object at all, and thus we must turn
+                                // the whole thing into cty.DynamicVal. This is consistent with
+                                // how this situation is handled in the native syntax.
+                                // We'll keep iterating so we can collect other errors in
+                                // subsequent attributes.
+                                known = false
+                                continue
+                        }
+                        nameStr := name.AsString()
+                        if _, defined := attrs[nameStr]; defined {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate object attribute",
+                                        Detail:   fmt.Sprintf("An attribute named %q was already defined at %s.", nameStr, attrRanges[nameStr]),
+                                        Subject:  &jsonAttr.NameRange,
+                                })
+                                continue
+                        }
+                        attrs[nameStr] = val
+                        attrRanges[nameStr] = jsonAttr.NameRange
+                }
+                if !known {
+                        // We encountered an unknown key somewhere along the way, so
+                        // we can't know what our type will eventually be.
+                        return cty.DynamicVal, diags
+                }
+                return cty.ObjectVal(attrs), diags
+        default:
+                // Default to DynamicVal so that ASTs containing invalid nodes can
+                // still be partially-evaluated.
+                return cty.DynamicVal, nil
+        }
+}
+
+func (e *expression) Variables() []hcl.Traversal {
+        var vars []hcl.Traversal
+
+        switch v := e.src.(type) {
+        case *stringVal:
+                templateSrc := v.Value
+                expr, diags := hclsyntax.ParseTemplate(
+                        []byte(templateSrc),
+                        v.SrcRange.Filename,
+
+                        // This won't produce _exactly_ the right result, since
+                        // the hclsyntax parser can't "see" any escapes we removed
+                        // while parsing JSON, but it's better than nothing.
+                        hcl.Pos{
+                                Line: v.SrcRange.Start.Line,
+
+                                // skip over the opening quote mark
+                                Byte:   v.SrcRange.Start.Byte + 1,
+                                Column: v.SrcRange.Start.Column + 1,
+                        },
+                )
+                if diags.HasErrors() {
+                        return vars
+                }
+                return expr.Variables()
+
+        case *arrayVal:
+                for _, jsonVal := range v.Values {
+                        vars = append(vars, (&expression{src: jsonVal}).Variables()...)
+                }
+        case *objectVal:
+                for _, jsonAttr := range v.Attrs {
+                        vars = append(vars, (&expression{src: jsonAttr.Value}).Variables()...)
+                }
+        }
+
+        return vars
+}
+
+func (e *expression) Range() hcl.Range {
+        return e.src.Range()
+}
+
+func (e *expression) StartRange() hcl.Range {
+        return e.src.StartRange()
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *expression) AsTraversal() hcl.Traversal {
+        // In JSON-based syntax a traversal is given as a string containing
+        // traversal syntax as defined by hclsyntax.ParseTraversalAbs.
+
+        switch v := e.src.(type) {
+        case *stringVal:
+                traversal, diags := hclsyntax.ParseTraversalAbs([]byte(v.Value), v.SrcRange.Filename, v.SrcRange.Start)
+                if diags.HasErrors() {
+                        return nil
+                }
+                return traversal
+        default:
+                return nil
+        }
+}
+
+// Implementation for hcl.ExprCall.
+func (e *expression) ExprCall() *hcl.StaticCall {
+        // In JSON-based syntax a static call is given as a string containing
+        // an expression in the native syntax that also supports ExprCall.
+
+        switch v := e.src.(type) {
+        case *stringVal:
+                expr, diags := hclsyntax.ParseExpression([]byte(v.Value), v.SrcRange.Filename, v.SrcRange.Start)
+                if diags.HasErrors() {
+                        return nil
+                }
+
+                call, diags := hcl.ExprCall(expr)
+                if diags.HasErrors() {
+                        return nil
+                }
+
+                return call
+        default:
+                return nil
+        }
+}
+
+// Implementation for hcl.ExprList.
+func (e *expression) ExprList() []hcl.Expression {
+        switch v := e.src.(type) {
+        case *arrayVal:
+                ret := make([]hcl.Expression, len(v.Values))
+                for i, node := range v.Values {
+                        ret[i] = &expression{src: node}
+                }
+                return ret
+        default:
+                return nil
+        }
+}
+
+// Implementation for hcl.ExprMap.
+func (e *expression) ExprMap() []hcl.KeyValuePair {
+        switch v := e.src.(type) {
+        case *objectVal:
+                ret := make([]hcl.KeyValuePair, len(v.Attrs))
+                for i, jsonAttr := range v.Attrs {
+                        ret[i] = hcl.KeyValuePair{
+                                Key: &expression{src: &stringVal{
+                                        Value:    jsonAttr.Name,
+                                        SrcRange: jsonAttr.NameRange,
+                                }},
+                                Value: &expression{src: jsonAttr.Value},
+                        }
+                }
+                return ret
+        default:
+                return nil
+        }
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/tokentype_string.go b/vendor/github.com/hashicorp/hcl2/hcl/json/tokentype_string.go
new file mode 100644
index 0000000..bbcce5b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/tokentype_string.go
@@ -0,0 +1,29 @@
+// Code generated by "stringer -type tokenType scanner.go"; DO NOT EDIT.
+
+package json
+
+import "strconv"
+
+const _tokenType_name = "tokenInvalidtokenCommatokenColontokenEqualstokenKeywordtokenNumbertokenStringtokenBrackOtokenBrackCtokenBraceOtokenBraceCtokenEOF"
+
+var _tokenType_map = map[tokenType]string{
+        0:    _tokenType_name[0:12],
+        44:   _tokenType_name[12:22],
+        58:   _tokenType_name[22:32],
+        61:   _tokenType_name[32:43],
+        75:   _tokenType_name[43:55],
+        78:   _tokenType_name[55:66],
+        83:   _tokenType_name[66:77],
+        91:   _tokenType_name[77:88],
+        93:   _tokenType_name[88:99],
+        123:  _tokenType_name[99:110],
+        125:  _tokenType_name[110:121],
+        9220: _tokenType_name[121:129],
+}
+
+func (i tokenType) String() string {
+        if str, ok := _tokenType_map[i]; ok {
+                return str
+        }
+        return "tokenType(" + strconv.FormatInt(int64(i), 10) + ")"
+}