8 files changed, 100 insertions, 13 deletions

diff --git a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go
index 2f2463a..47a0256 100644
--- a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go
+++ b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go
@@ -55,10 +55,11 @@ func effectiveSchema(given *hcl.BodySchema, body hcl.Body, ambiguousNames map[st
                                 },
                         }
                         content, _, _ = body.PartialContent(&probeSchema)
-                        if len(content.Blocks) > 0 {
-                                // No attribute present and at least one block present, so
-                                // we'll need to rewrite this one as a block for a successful
-                                // result.
+                        if len(content.Blocks) > 0 || dynamicExpanded {
+                                // A dynamic block with an empty iterator returns nothing.
+                                // If there's no attribute and we have either a block or a
+                                // dynamic expansion, we need to rewrite this one as a
+                                // block for a successful result.
                                 appearsAsBlock[name] = struct{}{}
                         }
                 }
diff --git a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go
index e123b8a..b172805 100644
--- a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go
+++ b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go
@@ -33,7 +33,7 @@ func walkVariables(node dynblock.WalkVariablesNode, body hcl.Body, schema *confi
         for _, child := range children {
                 if blockS, exists := schema.BlockTypes[child.BlockTypeName]; exists {
                         vars = append(vars, walkVariables(child.Node, child.Body(), &blockS.Block)...)
-                } else if attrS, exists := schema.Attributes[child.BlockTypeName]; exists {
+                } else if attrS, exists := schema.Attributes[child.BlockTypeName]; exists && attrS.Type.ElementType().IsObjectType() {
                         synthSchema := SchemaForCtyElementType(attrS.Type.ElementType())
                         vars = append(vars, walkVariables(child.Node, child.Body(), synthSchema)...)
                 }
diff --git a/vendor/github.com/hashicorp/terraform/lang/data.go b/vendor/github.com/hashicorp/terraform/lang/data.go
index 80313d6..eca588e 100644
--- a/vendor/github.com/hashicorp/terraform/lang/data.go
+++ b/vendor/github.com/hashicorp/terraform/lang/data.go
@@ -23,6 +23,7 @@ type Data interface {
         StaticValidateReferences(refs []*addrs.Reference, self addrs.Referenceable) tfdiags.Diagnostics
 
         GetCountAttr(addrs.CountAttr, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
+        GetForEachAttr(addrs.ForEachAttr, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
         GetResourceInstance(addrs.ResourceInstance, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
         GetLocalValue(addrs.LocalValue, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
         GetModuleInstance(addrs.ModuleCallInstance, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
diff --git a/vendor/github.com/hashicorp/terraform/lang/eval.go b/vendor/github.com/hashicorp/terraform/lang/eval.go
index a3fb363..a8fe8b6 100644
--- a/vendor/github.com/hashicorp/terraform/lang/eval.go
+++ b/vendor/github.com/hashicorp/terraform/lang/eval.go
@@ -203,6 +203,7 @@ func (s *Scope) evalContext(refs []*addrs.Reference, selfAddr addrs.Referenceabl
         pathAttrs := map[string]cty.Value{}
         terraformAttrs := map[string]cty.Value{}
         countAttrs := map[string]cty.Value{}
+        forEachAttrs := map[string]cty.Value{}
         var self cty.Value
 
         for _, ref := range refs {
@@ -334,6 +335,14 @@ func (s *Scope) evalContext(refs []*addrs.Reference, selfAddr addrs.Referenceabl
                                 self = val
                         }
 
+                case addrs.ForEachAttr:
+                        val, valDiags := normalizeRefValue(s.Data.GetForEachAttr(subj, rng))
+                        diags = diags.Append(valDiags)
+                        forEachAttrs[subj.Name] = val
+                        if isSelf {
+                                self = val
+                        }
+
                 default:
                         // Should never happen
                         panic(fmt.Errorf("Scope.buildEvalContext cannot handle address type %T", rawSubj))
@@ -350,6 +359,7 @@ func (s *Scope) evalContext(refs []*addrs.Reference, selfAddr addrs.Referenceabl
         vals["path"] = cty.ObjectVal(pathAttrs)
         vals["terraform"] = cty.ObjectVal(terraformAttrs)
         vals["count"] = cty.ObjectVal(countAttrs)
+        vals["each"] = cty.ObjectVal(forEachAttrs)
         if self != cty.NilVal {
                 vals["self"] = self
         }
diff --git a/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go b/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go
index 71b7a84..bcccc1f 100644
--- a/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go
+++ b/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go
@@ -246,7 +246,7 @@ var CompactFunc = function.New(&function.Spec{
 
                 for it := listVal.ElementIterator(); it.Next(); {
                         _, v := it.Element()
-                        if v.AsString() == "" {
+                        if v.IsNull() || v.AsString() == "" {
                                 continue
                         }
                         outputList = append(outputList, v)
@@ -363,6 +363,9 @@ var DistinctFunc = function.New(&function.Spec{
                         }
                 }
 
+                if len(list) == 0 {
+                        return cty.ListValEmpty(retType.ElementType()), nil
+                }
                 return cty.ListVal(list), nil
         },
 })
@@ -389,6 +392,10 @@ var ChunklistFunc = function.New(&function.Spec{
                         return cty.UnknownVal(retType), nil
                 }
 
+                if listVal.LengthInt() == 0 {
+                        return cty.ListValEmpty(listVal.Type()), nil
+                }
+
                 var size int
                 err = gocty.FromCtyValue(args[1], &size)
                 if err != nil {
@@ -686,8 +693,10 @@ var LookupFunc = function.New(&function.Spec{
                                         return cty.StringVal(v.AsString()), nil
                                 case ty.Equals(cty.Number):
                                         return cty.NumberVal(v.AsBigFloat()), nil
+                                case ty.Equals(cty.Bool):
+                                        return cty.BoolVal(v.True()), nil
                                 default:
-                                        return cty.NilVal, errors.New("lookup() can only be used with flat lists")
+                                        return cty.NilVal, errors.New("lookup() can only be used with maps of primitive types")
                                 }
                         }
                 }
@@ -797,10 +806,12 @@ var MatchkeysFunc = function.New(&function.Spec{
                 },
         },
         Type: func(args []cty.Value) (cty.Type, error) {
-                if !args[1].Type().Equals(args[2].Type()) {
-                        return cty.NilType, errors.New("lists must be of the same type")
+                ty, _ := convert.UnifyUnsafe([]cty.Type{args[1].Type(), args[2].Type()})
+                if ty == cty.NilType {
+                        return cty.NilType, errors.New("keys and searchset must be of the same type")
                 }
 
+                // the return type is based on args[0] (values)
                 return args[0].Type(), nil
         },
         Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
@@ -813,10 +824,14 @@ var MatchkeysFunc = function.New(&function.Spec{
                 }
 
                 output := make([]cty.Value, 0)
-
                 values := args[0]
-                keys := args[1]
-                searchset := args[2]
+
+                // Keys and searchset must be the same type.
+                // We can skip error checking here because we've already verified that
+                // they can be unified in the Type function
+                ty, _ := convert.UnifyUnsafe([]cty.Type{args[1].Type(), args[2].Type()})
+                keys, _ := convert.Convert(args[1], ty)
+                searchset, _ := convert.Convert(args[2], ty)
 
                 // if searchset is empty, return an empty list.
                 if searchset.LengthInt() == 0 {
@@ -867,7 +882,6 @@ var MergeFunc = function.New(&function.Spec{
                 Name:             "maps",
                 Type:             cty.DynamicPseudoType,
                 AllowDynamicType: true,
-                AllowNull:        true,
         },
         Type: function.StaticReturnType(cty.DynamicPseudoType),
         Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
diff --git a/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go b/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go
index 5cb4bc5..be006f8 100644
--- a/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go
+++ b/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go
@@ -14,6 +14,7 @@ import (
         "hash"
 
         uuid "github.com/hashicorp/go-uuid"
+        uuidv5 "github.com/satori/go.uuid"
         "github.com/zclconf/go-cty/cty"
         "github.com/zclconf/go-cty/cty/function"
         "github.com/zclconf/go-cty/cty/gocty"
@@ -32,6 +33,39 @@ var UUIDFunc = function.New(&function.Spec{
         },
 })
 
+var UUIDV5Func = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "namespace",
+                        Type: cty.String,
+                },
+                {
+                        Name: "name",
+                        Type: cty.String,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                var namespace uuidv5.UUID
+                switch {
+                case args[0].AsString() == "dns":
+                        namespace = uuidv5.NamespaceDNS
+                case args[0].AsString() == "url":
+                        namespace = uuidv5.NamespaceURL
+                case args[0].AsString() == "oid":
+                        namespace = uuidv5.NamespaceOID
+                case args[0].AsString() == "x500":
+                        namespace = uuidv5.NamespaceX500
+                default:
+                        if namespace, err = uuidv5.FromString(args[0].AsString()); err != nil {
+                                return cty.UnknownVal(cty.String), fmt.Errorf("uuidv5() doesn't support namespace %s (%v)", args[0].AsString(), err)
+                        }
+                }
+                val := args[1].AsString()
+                return cty.StringVal(uuidv5.NewV5(namespace, val).String()), nil
+        },
+})
+
 // Base64Sha256Func constructs a function that computes the SHA256 hash of a given string
 // and encodes it with Base64.
 var Base64Sha256Func = makeStringHashFunction(sha256.New, base64.StdEncoding.EncodeToString)
@@ -228,6 +262,12 @@ func UUID() (cty.Value, error) {
         return UUIDFunc.Call(nil)
 }
 
+// UUIDV5 generates and returns a Type-5 UUID in the standard hexadecimal string
+// format.
+func UUIDV5(namespace cty.Value, name cty.Value) (cty.Value, error) {
+        return UUIDV5Func.Call([]cty.Value{namespace, name})
+}
+
 // Base64Sha256 computes the SHA256 hash of a given string and encodes it with
 // Base64.
 //
diff --git a/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go b/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go
index 7dfc905..016b102 100644
--- a/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go
+++ b/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go
@@ -237,6 +237,21 @@ var DirnameFunc = function.New(&function.Spec{
         },
 })
 
+// AbsPathFunc constructs a function that converts a filesystem path to an absolute path
+var AbsPathFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "path",
+                        Type: cty.String,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                absPath, err := filepath.Abs(args[0].AsString())
+                return cty.StringVal(filepath.ToSlash(absPath)), err
+        },
+})
+
 // PathExpandFunc constructs a function that expands a leading ~ character to the current user's home directory.
 var PathExpandFunc = function.New(&function.Spec{
         Params: []function.Parameter{
diff --git a/vendor/github.com/hashicorp/terraform/lang/functions.go b/vendor/github.com/hashicorp/terraform/lang/functions.go
index 2c7b548..b77a55f 100644
--- a/vendor/github.com/hashicorp/terraform/lang/functions.go
+++ b/vendor/github.com/hashicorp/terraform/lang/functions.go
@@ -3,6 +3,7 @@ package lang
 import (
         "fmt"
 
+        ctyyaml "github.com/zclconf/go-cty-yaml"
         "github.com/zclconf/go-cty/cty"
         "github.com/zclconf/go-cty/cty/function"
         "github.com/zclconf/go-cty/cty/function/stdlib"
@@ -30,6 +31,7 @@ func (s *Scope) Functions() map[string]function.Function {
 
                 s.funcs = map[string]function.Function{
                         "abs":              stdlib.AbsoluteFunc,
+                        "abspath":          funcs.AbsPathFunc,
                         "basename":         funcs.BasenameFunc,
                         "base64decode":     funcs.Base64DecodeFunc,
                         "base64encode":     funcs.Base64EncodeFunc,
@@ -85,6 +87,7 @@ func (s *Scope) Functions() map[string]function.Function {
                         "min":              stdlib.MinFunc,
                         "pathexpand":       funcs.PathExpandFunc,
                         "pow":              funcs.PowFunc,
+                        "range":            stdlib.RangeFunc,
                         "replace":          funcs.ReplaceFunc,
                         "reverse":          funcs.ReverseFunc,
                         "rsadecrypt":       funcs.RsaDecryptFunc,
@@ -114,7 +117,10 @@ func (s *Scope) Functions() map[string]function.Function {
                         "upper":            stdlib.UpperFunc,
                         "urlencode":        funcs.URLEncodeFunc,
                         "uuid":             funcs.UUIDFunc,
+                        "uuidv5":           funcs.UUIDV5Func,
                         "values":           funcs.ValuesFunc,
+                        "yamldecode":       ctyyaml.YAMLDecodeFunc,
+                        "yamlencode":       ctyyaml.YAMLEncodeFunc,
                         "zipmap":           funcs.ZipmapFunc,
                 }