Upgrade to 0.12

7 files changed, 775 insertions, 32 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/function/function.go b/vendor/github.com/zclconf/go-cty/cty/function/function.go
index 162f7bf..9e8bf33 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/function.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/function.go
@@ -143,7 +143,7 @@ func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error)
                 val := posArgs[i]
 
                 if val.IsNull() && !spec.AllowNull {
-                        return cty.Type{}, NewArgErrorf(i, "must not be null")
+                        return cty.Type{}, NewArgErrorf(i, "argument must not be null")
                 }
 
                 // AllowUnknown is ignored for type-checking, since we expect to be
@@ -169,7 +169,7 @@ func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error)
                         realI := i + len(posArgs)
 
                         if val.IsNull() && !spec.AllowNull {
-                                return cty.Type{}, NewArgErrorf(realI, "must not be null")
+                                return cty.Type{}, NewArgErrorf(realI, "argument must not be null")
                         }
 
                         if val.Type() == cty.DynamicPseudoType {
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
new file mode 100644
index 0000000..aa15b7b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
@@ -0,0 +1,385 @@
+package stdlib
+
+import (
+        "bufio"
+        "bytes"
+        "fmt"
+        "strings"
+        "time"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var FormatDateFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "format",
+                        Type: cty.String,
+                },
+                {
+                        Name: "time",
+                        Type: cty.String,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                formatStr := args[0].AsString()
+                timeStr := args[1].AsString()
+                t, err := parseTimestamp(timeStr)
+                if err != nil {
+                        return cty.DynamicVal, function.NewArgError(1, err)
+                }
+
+                var buf bytes.Buffer
+                sc := bufio.NewScanner(strings.NewReader(formatStr))
+                sc.Split(splitDateFormat)
+                const esc = '\''
+                for sc.Scan() {
+                        tok := sc.Bytes()
+
+                        // The leading byte signals the token type
+                        switch {
+                        case tok[0] == esc:
+                                if tok[len(tok)-1] != esc || len(tok) == 1 {
+                                        return cty.DynamicVal, function.NewArgErrorf(0, "unterminated literal '")
+                                }
+                                if len(tok) == 2 {
+                                        // Must be a single escaped quote, ''
+                                        buf.WriteByte(esc)
+                                } else {
+                                        // The content (until a closing esc) is printed out verbatim
+                                        // except that we must un-double any double-esc escapes in
+                                        // the middle of the string.
+                                        raw := tok[1 : len(tok)-1]
+                                        for i := 0; i < len(raw); i++ {
+                                                buf.WriteByte(raw[i])
+                                                if raw[i] == esc {
+                                                        i++ // skip the escaped quote
+                                                }
+                                        }
+                                }
+
+                        case startsDateFormatVerb(tok[0]):
+                                switch tok[0] {
+                                case 'Y':
+                                        y := t.Year()
+                                        switch len(tok) {
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", y%100)
+                                        case 4:
+                                                fmt.Fprintf(&buf, "%04d", y)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: year must either be \"YY\" or \"YYYY\"", tok)
+                                        }
+                                case 'M':
+                                        m := t.Month()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", m)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", m)
+                                        case 3:
+                                                buf.WriteString(m.String()[:3])
+                                        case 4:
+                                                buf.WriteString(m.String())
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: month must be \"M\", \"MM\", \"MMM\", or \"MMMM\"", tok)
+                                        }
+                                case 'D':
+                                        d := t.Day()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", d)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", d)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of month must either be \"D\" or \"DD\"", tok)
+                                        }
+                                case 'E':
+                                        d := t.Weekday()
+                                        switch len(tok) {
+                                        case 3:
+                                                buf.WriteString(d.String()[:3])
+                                        case 4:
+                                                buf.WriteString(d.String())
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of week must either be \"EEE\" or \"EEEE\"", tok)
+                                        }
+                                case 'h':
+                                        h := t.Hour()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", h)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", h)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 24-hour must either be \"h\" or \"hh\"", tok)
+                                        }
+                                case 'H':
+                                        h := t.Hour() % 12
+                                        if h == 0 {
+                                                h = 12
+                                        }
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", h)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", h)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 12-hour must either be \"H\" or \"HH\"", tok)
+                                        }
+                                case 'A', 'a':
+                                        if len(tok) != 2 {
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: must be \"%s%s\"", tok, tok[0:1], tok[0:1])
+                                        }
+                                        upper := tok[0] == 'A'
+                                        switch t.Hour() / 12 {
+                                        case 0:
+                                                if upper {
+                                                        buf.WriteString("AM")
+                                                } else {
+                                                        buf.WriteString("am")
+                                                }
+                                        case 1:
+                                                if upper {
+                                                        buf.WriteString("PM")
+                                                } else {
+                                                        buf.WriteString("pm")
+                                                }
+                                        }
+                                case 'm':
+                                        m := t.Minute()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", m)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", m)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: minute must either be \"m\" or \"mm\"", tok)
+                                        }
+                                case 's':
+                                        s := t.Second()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", s)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", s)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: second must either be \"s\" or \"ss\"", tok)
+                                        }
+                                case 'Z':
+                                        // We'll just lean on Go's own formatter for this one, since
+                                        // the necessary information is unexported.
+                                        switch len(tok) {
+                                        case 1:
+                                                buf.WriteString(t.Format("Z07:00"))
+                                        case 3:
+                                                str := t.Format("-0700")
+                                                switch str {
+                                                case "+0000":
+                                                        buf.WriteString("UTC")
+                                                default:
+                                                        buf.WriteString(str)
+                                                }
+                                        case 4:
+                                                buf.WriteString(t.Format("-0700"))
+                                        case 5:
+                                                buf.WriteString(t.Format("-07:00"))
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: timezone must be Z, ZZZZ, or ZZZZZ", tok)
+                                        }
+                                default:
+                                        return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q", tok)
+                                }
+
+                        default:
+                                // Any other starting character indicates a literal sequence
+                                buf.Write(tok)
+                        }
+                }
+
+                return cty.StringVal(buf.String()), nil
+        },
+})
+
+// FormatDate reformats a timestamp given in RFC3339 syntax into another time
+// syntax defined by a given format string.
+//
+// The format string uses letter mnemonics to represent portions of the
+// timestamp, with repetition signifying length variants of each portion.
+// Single quote characters ' can be used to quote sequences of literal letters
+// that should not be interpreted as formatting mnemonics.
+//
+// The full set of supported mnemonic sequences is listed below:
+//
+//     YY       Year modulo 100 zero-padded to two digits, like "06".
+//     YYYY     Four (or more) digit year, like "2006".
+//     M        Month number, like "1" for January.
+//     MM       Month number zero-padded to two digits, like "01".
+//     MMM      English month name abbreviated to three letters, like "Jan".
+//     MMMM     English month name unabbreviated, like "January".
+//     D        Day of month number, like "2".
+//     DD       Day of month number zero-padded to two digits, like "02".
+//     EEE      English day of week name abbreviated to three letters, like "Mon".
+//     EEEE     English day of week name unabbreviated, like "Monday".
+//     h        24-hour number, like "2".
+//     hh       24-hour number zero-padded to two digits, like "02".
+//     H        12-hour number, like "2".
+//     HH       12-hour number zero-padded to two digits, like "02".
+//     AA       Hour AM/PM marker in uppercase, like "AM".
+//     aa       Hour AM/PM marker in lowercase, like "am".
+//     m        Minute within hour, like "5".
+//     mm       Minute within hour zero-padded to two digits, like "05".
+//     s        Second within minute, like "9".
+//     ss       Second within minute zero-padded to two digits, like "09".
+//     ZZZZ     Timezone offset with just sign and digit, like "-0800".
+//     ZZZZZ    Timezone offset with colon separating hours and minutes, like "-08:00".
+//     Z        Like ZZZZZ but with a special case "Z" for UTC.
+//     ZZZ      Like ZZZZ but with a special case "UTC" for UTC.
+//
+// The format syntax is optimized mainly for generating machine-oriented
+// timestamps rather than human-oriented timestamps; the English language
+// portions of the output reflect the use of English names in a number of
+// machine-readable date formatting standards. For presentation to humans,
+// a locale-aware time formatter (not included in this package) is a better
+// choice.
+//
+// The format syntax is not compatible with that of any other language, but
+// is optimized so that patterns for common standard date formats can be
+// recognized quickly even by a reader unfamiliar with the format syntax.
+func FormatDate(format cty.Value, timestamp cty.Value) (cty.Value, error) {
+        return FormatDateFunc.Call([]cty.Value{format, timestamp})
+}
+
+func parseTimestamp(ts string) (time.Time, error) {
+        t, err := time.Parse(time.RFC3339, ts)
+        if err != nil {
+                switch err := err.(type) {
+                case *time.ParseError:
+                        // If err is s time.ParseError then its string representation is not
+                        // appropriate since it relies on details of Go's strange date format
+                        // representation, which a caller of our functions is not expected
+                        // to be familiar with.
+                        //
+                        // Therefore we do some light transformation to get a more suitable
+                        // error that should make more sense to our callers. These are
+                        // still not awesome error messages, but at least they refer to
+                        // the timestamp portions by name rather than by Go's example
+                        // values.
+                        if err.LayoutElem == "" && err.ValueElem == "" && err.Message != "" {
+                                // For some reason err.Message is populated with a ": " prefix
+                                // by the time package.
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp%s", err.Message)
+                        }
+                        var what string
+                        switch err.LayoutElem {
+                        case "2006":
+                                what = "year"
+                        case "01":
+                                what = "month"
+                        case "02":
+                                what = "day of month"
+                        case "15":
+                                what = "hour"
+                        case "04":
+                                what = "minute"
+                        case "05":
+                                what = "second"
+                        case "Z07:00":
+                                what = "UTC offset"
+                        case "T":
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: missing required time introducer 'T'")
+                        case ":", "-":
+                                if err.ValueElem == "" {
+                                        return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string where %q is expected", err.LayoutElem)
+                                } else {
+                                        return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: found %q where %q is expected", err.ValueElem, err.LayoutElem)
+                                }
+                        default:
+                                // Should never get here, because time.RFC3339 includes only the
+                                // above portions, but since that might change in future we'll
+                                // be robust here.
+                                what = "timestamp segment"
+                        }
+                        if err.ValueElem == "" {
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string before %s", what)
+                        } else {
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: cannot use %q as %s", err.ValueElem, what)
+                        }
+                }
+                return time.Time{}, err
+        }
+        return t, nil
+}
+
+// splitDataFormat is a bufio.SplitFunc used to tokenize a date format.
+func splitDateFormat(data []byte, atEOF bool) (advance int, token []byte, err error) {
+        if len(data) == 0 {
+                return 0, nil, nil
+        }
+
+        const esc = '\''
+
+        switch {
+
+        case data[0] == esc:
+                // If we have another quote immediately after then this is a single
+                // escaped escape.
+                if len(data) > 1 && data[1] == esc {
+                        return 2, data[:2], nil
+                }
+
+                // Beginning of quoted sequence, so we will seek forward until we find
+                // the closing quote, ignoring escaped quotes along the way.
+                for i := 1; i < len(data); i++ {
+                        if data[i] == esc {
+                                if (i + 1) == len(data) {
+                                        // We need at least one more byte to decide if this is an
+                                        // escape or a terminator.
+                                        return 0, nil, nil
+                                }
+                                if data[i+1] == esc {
+                                        i++ // doubled-up quotes are an escape sequence
+                                        continue
+                                }
+                                // We've found the closing quote
+                                return i + 1, data[:i+1], nil
+                        }
+                }
+                // If we fall out here then we need more bytes to find the end,
+                // unless we're already at the end with an unclosed quote.
+                if atEOF {
+                        return len(data), data, nil
+                }
+                return 0, nil, nil
+
+        case startsDateFormatVerb(data[0]):
+                rep := data[0]
+                for i := 1; i < len(data); i++ {
+                        if data[i] != rep {
+                                return i, data[:i], nil
+                        }
+                }
+                if atEOF {
+                        return len(data), data, nil
+                }
+                // We need more data to decide if we've found the end
+                return 0, nil, nil
+
+        default:
+                for i := 1; i < len(data); i++ {
+                        if data[i] == esc || startsDateFormatVerb(data[i]) {
+                                return i, data[:i], nil
+                        }
+                }
+                // We might not actually be at the end of a literal sequence,
+                // but that doesn't matter since we'll concat them back together
+                // anyway.
+                return len(data), data, nil
+        }
+}
+
+func startsDateFormatVerb(b byte) bool {
+        return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
index fb24f20..664790b 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
@@ -84,6 +84,11 @@ var FormatListFunc = function.New(&function.Spec{
                         argTy := arg.Type()
                         switch {
                         case (argTy.IsListType() || argTy.IsSetType() || argTy.IsTupleType()) && !arg.IsNull():
+                                if !argTy.IsTupleType() && !arg.IsKnown() {
+                                        // We can't iterate this one at all yet then, so we can't
+                                        // yet produce a result.
+                                        return cty.UnknownVal(retType), nil
+                                }
                                 thisLen := arg.LengthInt()
                                 if iterLen == -1 {
                                         iterLen = thisLen
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
index 86876ba..32b1ac9 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
@@ -11,9 +11,10 @@ import (
         "unicode/utf8"
 
         "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
 )
 
-// line 20 "format_fsm.go"
+// line 21 "format_fsm.go"
 var _formatfsm_actions []byte = []byte{
         0, 1, 0, 1, 1, 1, 2, 1, 4,
         1, 5, 1, 6, 1, 7, 1, 8,
@@ -86,15 +87,16 @@ const formatfsm_error int = 0
 
 const formatfsm_en_main int = 8
 
-// line 19 "format_fsm.rl"
+// line 20 "format_fsm.rl"
 
 func formatFSM(format string, a []cty.Value) (string, error) {
         var buf bytes.Buffer
         data := format
         nextArg := 1 // arg numbers are 1-based
         var verb formatVerb
+        highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
 
-        // line 153 "format_fsm.rl"
+        // line 159 "format_fsm.rl"
 
         // Ragel state
         p := 0          // "Pointer" into data
@@ -109,12 +111,12 @@ func formatFSM(format string, a []cty.Value) (string, error) {
         _ = te
         _ = eof
 
-        // line 121 "format_fsm.go"
+        // line 123 "format_fsm.go"
         {
                 cs = formatfsm_start
         }
 
-        // line 126 "format_fsm.go"
+        // line 128 "format_fsm.go"
         {
                 var _klen int
                 var _trans int
@@ -195,7 +197,7 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                         _acts++
                         switch _formatfsm_actions[_acts-1] {
                         case 0:
-                                // line 29 "format_fsm.rl"
+                                // line 31 "format_fsm.rl"
 
                                 verb = formatVerb{
                                         ArgNum: nextArg,
@@ -205,12 +207,12 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                                 ts = p
 
                         case 1:
-                                // line 38 "format_fsm.rl"
+                                // line 40 "format_fsm.rl"
 
                                 buf.WriteByte(data[p])
 
                         case 4:
-                                // line 49 "format_fsm.rl"
+                                // line 51 "format_fsm.rl"
 
                                 // We'll try to slurp a whole UTF-8 sequence here, to give the user
                                 // better feedback.
@@ -218,85 +220,89 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                                 return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
 
                         case 5:
-                                // line 56 "format_fsm.rl"
+                                // line 58 "format_fsm.rl"
 
                                 verb.Sharp = true
 
                         case 6:
-                                // line 59 "format_fsm.rl"
+                                // line 61 "format_fsm.rl"
 
                                 verb.Zero = true
 
                         case 7:
-                                // line 62 "format_fsm.rl"
+                                // line 64 "format_fsm.rl"
 
                                 verb.Minus = true
 
                         case 8:
-                                // line 65 "format_fsm.rl"
+                                // line 67 "format_fsm.rl"
 
                                 verb.Plus = true
 
                         case 9:
-                                // line 68 "format_fsm.rl"
+                                // line 70 "format_fsm.rl"
 
                                 verb.Space = true
 
                         case 10:
-                                // line 72 "format_fsm.rl"
+                                // line 74 "format_fsm.rl"
 
                                 verb.ArgNum = 0
 
                         case 11:
-                                // line 75 "format_fsm.rl"
+                                // line 77 "format_fsm.rl"
 
                                 verb.ArgNum = (10 * verb.ArgNum) + (int(data[p]) - '0')
 
                         case 12:
-                                // line 79 "format_fsm.rl"
+                                // line 81 "format_fsm.rl"
 
                                 verb.HasWidth = true
 
                         case 13:
-                                // line 82 "format_fsm.rl"
+                                // line 84 "format_fsm.rl"
 
                                 verb.Width = 0
 
                         case 14:
-                                // line 85 "format_fsm.rl"
+                                // line 87 "format_fsm.rl"
 
                                 verb.Width = (10 * verb.Width) + (int(data[p]) - '0')
 
                         case 15:
-                                // line 89 "format_fsm.rl"
+                                // line 91 "format_fsm.rl"
 
                                 verb.HasPrec = true
 
                         case 16:
-                                // line 92 "format_fsm.rl"
+                                // line 94 "format_fsm.rl"
 
                                 verb.Prec = 0
 
                         case 17:
-                                // line 95 "format_fsm.rl"
+                                // line 97 "format_fsm.rl"
 
                                 verb.Prec = (10 * verb.Prec) + (int(data[p]) - '0')
 
                         case 18:
-                                // line 99 "format_fsm.rl"
+                                // line 101 "format_fsm.rl"
 
                                 verb.Mode = rune(data[p])
                                 te = p + 1
                                 verb.Raw = data[ts:te]
                                 verb.Offset = ts
 
+                                if verb.ArgNum > highestArgIdx {
+                                        highestArgIdx = verb.ArgNum
+                                }
+
                                 err := formatAppend(&verb, &buf, a)
                                 if err != nil {
                                         return buf.String(), err
                                 }
                                 nextArg = verb.ArgNum + 1
 
-                                // line 324 "format_fsm.go"
+                                // line 330 "format_fsm.go"
                         }
                 }
 
@@ -319,22 +325,22 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                                 __acts++
                                 switch _formatfsm_actions[__acts-1] {
                                 case 2:
-                                        // line 42 "format_fsm.rl"
+                                        // line 44 "format_fsm.rl"
 
                                 case 3:
-                                        // line 45 "format_fsm.rl"
+                                        // line 47 "format_fsm.rl"
 
                                         return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
 
                                 case 4:
-                                        // line 49 "format_fsm.rl"
+                                        // line 51 "format_fsm.rl"
 
                                         // We'll try to slurp a whole UTF-8 sequence here, to give the user
                                         // better feedback.
                                         r, _ := utf8.DecodeRuneInString(data[p:])
                                         return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
 
-                                        // line 363 "format_fsm.go"
+                                        // line 369 "format_fsm.go"
                                 }
                         }
                 }
@@ -344,14 +350,24 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                 }
         }
 
-        // line 171 "format_fsm.rl"
+        // line 177 "format_fsm.rl"
 
         // If we fall out here without being in a final state then we've
         // encountered something that the scanner can't match, which should
         // be impossible (the scanner matches all bytes _somehow_) but we'll
         // flag it anyway rather than just losing data from the end.
         if cs < formatfsm_first_final {
-                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+        }
+
+        if highestArgIdx < len(a) {
+                // Extraneous args are an error, to more easily detect mistakes
+                firstBad := highestArgIdx + 1
+                if highestArgIdx == 0 {
+                        // Custom error message for this case
+                        return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+                }
+                return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
         }
 
         return buf.String(), nil
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
index 85d43bb..3c642d9 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
@@ -12,6 +12,7 @@ import (
         "unicode/utf8"
 
         "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
 )
 
 %%{
@@ -23,6 +24,7 @@ func formatFSM(format string, a []cty.Value) (string, error) {
         data := format
         nextArg := 1 // arg numbers are 1-based
         var verb formatVerb
+        highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
 
         %%{
 
@@ -102,6 +104,10 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                 verb.Raw = data[ts:te]
                 verb.Offset = ts
 
+                if verb.ArgNum > highestArgIdx {
+                        highestArgIdx = verb.ArgNum
+                }
+
                 err := formatAppend(&verb, &buf, a)
                 if err != nil {
                         return buf.String(), err
@@ -175,7 +181,17 @@ func formatFSM(format string, a []cty.Value) (string, error) {
         // be impossible (the scanner matches all bytes _somehow_) but we'll
         // flag it anyway rather than just losing data from the end.
         if cs < formatfsm_first_final {
-                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+        }
+
+        if highestArgIdx < len(a) {
+                // Extraneous args are an error, to more easily detect mistakes
+                firstBad := highestArgIdx+1
+                if highestArgIdx == 0 {
+                        // Custom error message for this case
+                        return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+                }
+                return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
         }
 
         return buf.String(), nil
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
new file mode 100644
index 0000000..2dd6348
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
@@ -0,0 +1,233 @@
+package stdlib
+
+import (
+        "fmt"
+        "regexp"
+        resyntax "regexp/syntax"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var RegexFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "pattern",
+                        Type: cty.String,
+                },
+                {
+                        Name: "string",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                if !args[0].IsKnown() {
+                        // We can't predict our type without seeing our pattern
+                        return cty.DynamicPseudoType, nil
+                }
+
+                retTy, err := regexPatternResultType(args[0].AsString())
+                if err != nil {
+                        err = function.NewArgError(0, err)
+                }
+                return retTy, err
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                if retType == cty.DynamicPseudoType {
+                        return cty.DynamicVal, nil
+                }
+
+                re, err := regexp.Compile(args[0].AsString())
+                if err != nil {
+                        // Should never happen, since we checked this in the Type function above.
+                        return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+                }
+                str := args[1].AsString()
+
+                captureIdxs := re.FindStringSubmatchIndex(str)
+                if captureIdxs == nil {
+                        return cty.NilVal, fmt.Errorf("pattern did not match any part of the given string")
+                }
+
+                return regexPatternResult(re, str, captureIdxs, retType), nil
+        },
+})
+
+var RegexAllFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "pattern",
+                        Type: cty.String,
+                },
+                {
+                        Name: "string",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                if !args[0].IsKnown() {
+                        // We can't predict our type without seeing our pattern,
+                        // but we do know it'll always be a list of something.
+                        return cty.List(cty.DynamicPseudoType), nil
+                }
+
+                retTy, err := regexPatternResultType(args[0].AsString())
+                if err != nil {
+                        err = function.NewArgError(0, err)
+                }
+                return cty.List(retTy), err
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                ety := retType.ElementType()
+                if ety == cty.DynamicPseudoType {
+                        return cty.DynamicVal, nil
+                }
+
+                re, err := regexp.Compile(args[0].AsString())
+                if err != nil {
+                        // Should never happen, since we checked this in the Type function above.
+                        return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+                }
+                str := args[1].AsString()
+
+                captureIdxsEach := re.FindAllStringSubmatchIndex(str, -1)
+                if len(captureIdxsEach) == 0 {
+                        return cty.ListValEmpty(ety), nil
+                }
+
+                elems := make([]cty.Value, len(captureIdxsEach))
+                for i, captureIdxs := range captureIdxsEach {
+                        elems[i] = regexPatternResult(re, str, captureIdxs, ety)
+                }
+                return cty.ListVal(elems), nil
+        },
+})
+
+// Regex is a function that extracts one or more substrings from a given
+// string by applying a regular expression pattern, describing the first
+// match.
+//
+// The return type depends on the composition of the capture groups (if any)
+// in the pattern:
+//
+//   - If there are no capture groups at all, the result is a single string
+//     representing the entire matched pattern.
+//   - If all of the capture groups are named, the result is an object whose
+//     keys are the named groups and whose values are their sub-matches, or
+//     null if a particular sub-group was inside another group that didn't
+//     match.
+//   - If none of the capture groups are named, the result is a tuple whose
+//     elements are the sub-groups in order and whose values are their
+//     sub-matches, or null if a particular sub-group was inside another group
+//     that didn't match.
+//   - It is invalid to use both named and un-named capture groups together in
+//     the same pattern.
+//
+// If the pattern doesn't match, this function returns an error. To test for
+// a match, call RegexAll and check if the length of the result is greater
+// than zero.
+func Regex(pattern, str cty.Value) (cty.Value, error) {
+        return RegexFunc.Call([]cty.Value{pattern, str})
+}
+
+// RegexAll is similar to Regex but it finds all of the non-overlapping matches
+// in the given string and returns a list of them.
+//
+// The result type is always a list, whose element type is deduced from the
+// pattern in the same way as the return type for Regex is decided.
+//
+// If the pattern doesn't match at all, this function returns an empty list.
+func RegexAll(pattern, str cty.Value) (cty.Value, error) {
+        return RegexAllFunc.Call([]cty.Value{pattern, str})
+}
+
+// regexPatternResultType parses the given regular expression pattern and
+// returns the structural type that would be returned to represent its
+// capture groups.
+//
+// Returns an error if parsing fails or if the pattern uses a mixture of
+// named and unnamed capture groups, which is not permitted.
+func regexPatternResultType(pattern string) (cty.Type, error) {
+        re, rawErr := regexp.Compile(pattern)
+        switch err := rawErr.(type) {
+        case *resyntax.Error:
+                return cty.NilType, fmt.Errorf("invalid regexp pattern: %s in %s", err.Code, err.Expr)
+        case error:
+                // Should never happen, since all regexp compile errors should
+                // be resyntax.Error, but just in case...
+                return cty.NilType, fmt.Errorf("error parsing pattern: %s", err)
+        }
+
+        allNames := re.SubexpNames()[1:]
+        var names []string
+        unnamed := 0
+        for _, name := range allNames {
+                if name == "" {
+                        unnamed++
+                } else {
+                        if names == nil {
+                                names = make([]string, 0, len(allNames))
+                        }
+                        names = append(names, name)
+                }
+        }
+        switch {
+        case unnamed == 0 && len(names) == 0:
+                // If there are no capture groups at all then we'll return just a
+                // single string for the whole match.
+                return cty.String, nil
+        case unnamed > 0 && len(names) > 0:
+                return cty.NilType, fmt.Errorf("invalid regexp pattern: cannot mix both named and unnamed capture groups")
+        case unnamed > 0:
+                // For unnamed captures, we return a tuple of them all in order.
+                etys := make([]cty.Type, unnamed)
+                for i := range etys {
+                        etys[i] = cty.String
+                }
+                return cty.Tuple(etys), nil
+        default:
+                // For named captures, we return an object using the capture names
+                // as keys.
+                atys := make(map[string]cty.Type, len(names))
+                for _, name := range names {
+                        atys[name] = cty.String
+                }
+                return cty.Object(atys), nil
+        }
+}
+
+func regexPatternResult(re *regexp.Regexp, str string, captureIdxs []int, retType cty.Type) cty.Value {
+        switch {
+        case retType == cty.String:
+                start, end := captureIdxs[0], captureIdxs[1]
+                return cty.StringVal(str[start:end])
+        case retType.IsTupleType():
+                captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+                vals := make([]cty.Value, len(captureIdxs)/2)
+                for i := range vals {
+                        start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+                        if start < 0 || end < 0 {
+                                vals[i] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+                                continue
+                        }
+                        vals[i] = cty.StringVal(str[start:end])
+                }
+                return cty.TupleVal(vals)
+        case retType.IsObjectType():
+                captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+                vals := make(map[string]cty.Value, len(captureIdxs)/2)
+                names := re.SubexpNames()[1:]
+                for i, name := range names {
+                        start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+                        if start < 0 || end < 0 {
+                                vals[name] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+                                continue
+                        }
+                        vals[name] = cty.StringVal(str[start:end])
+                }
+                return cty.ObjectVal(vals)
+        default:
+                // Should never happen
+                panic(fmt.Sprintf("invalid return type %#v", retType))
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
index e2c77c5..d3cc341 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -119,6 +119,75 @@ var ConcatFunc = function.New(&function.Spec{
         },
 })
 
+var RangeFunc = function.New(&function.Spec{
+        VarParam: &function.Parameter{
+                Name: "params",
+                Type: cty.Number,
+        },
+        Type: function.StaticReturnType(cty.List(cty.Number)),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                var start, end, step cty.Value
+                switch len(args) {
+                case 1:
+                        if args[0].LessThan(cty.Zero).True() {
+                                start, end, step = cty.Zero, args[0], cty.NumberIntVal(-1)
+                        } else {
+                                start, end, step = cty.Zero, args[0], cty.NumberIntVal(1)
+                        }
+                case 2:
+                        if args[1].LessThan(args[0]).True() {
+                                start, end, step = args[0], args[1], cty.NumberIntVal(-1)
+                        } else {
+                                start, end, step = args[0], args[1], cty.NumberIntVal(1)
+                        }
+                case 3:
+                        start, end, step = args[0], args[1], args[2]
+                default:
+                        return cty.NilVal, fmt.Errorf("must have one, two, or three arguments")
+                }
+
+                var vals []cty.Value
+
+                if step == cty.Zero {
+                        return cty.NilVal, function.NewArgErrorf(2, "step must not be zero")
+                }
+                down := step.LessThan(cty.Zero).True()
+
+                if down {
+                        if end.GreaterThan(start).True() {
+                                return cty.NilVal, function.NewArgErrorf(1, "end must be less than start when step is negative")
+                        }
+                } else {
+                        if end.LessThan(start).True() {
+                                return cty.NilVal, function.NewArgErrorf(1, "end must be greater than start when step is positive")
+                        }
+                }
+
+                num := start
+                for {
+                        if down {
+                                if num.LessThanOrEqualTo(end).True() {
+                                        break
+                                }
+                        } else {
+                                if num.GreaterThanOrEqualTo(end).True() {
+                                        break
+                                }
+                        }
+                        if len(vals) >= 1024 {
+                                // Artificial limit to prevent bad arguments from consuming huge amounts of memory
+                                return cty.NilVal, fmt.Errorf("more than 1024 values were generated; either decrease the difference between start and end or use a smaller step")
+                        }
+                        vals = append(vals, num)
+                        num = num.Add(step)
+                }
+                if len(vals) == 0 {
+                        return cty.ListValEmpty(cty.Number), nil
+                }
+                return cty.ListVal(vals), nil
+        },
+})
+
 // Concat takes one or more sequences (lists or tuples) and returns the single
 // sequence that results from concatenating them together in order.
 //
@@ -128,3 +197,22 @@ var ConcatFunc = function.New(&function.Spec{
 func Concat(seqs ...cty.Value) (cty.Value, error) {
         return ConcatFunc.Call(seqs)
 }
+
+// Range creates a list of numbers by starting from the given starting value,
+// then adding the given step value until the result is greater than or
+// equal to the given stopping value. Each intermediate result becomes an
+// element in the resulting list.
+//
+// When all three parameters are set, the order is (start, end, step). If
+// only two parameters are set, they are the start and end respectively and
+// step defaults to 1. If only one argument is set, it gives the end value
+// with start defaulting to 0 and step defaulting to 1.
+//
+// Because the resulting list must be fully buffered in memory, there is an
+// artificial cap of 1024 elements, after which this function will return
+// an error to avoid consuming unbounded amounts of memory. The Range function
+// is primarily intended for creating small lists of indices to iterate over,
+// so there should be no reason to generate huge lists with it.
+func Range(params ...cty.Value) (cty.Value, error) {
+        return RangeFunc.Call(params)
+}