vendor: update github.com/hashicorp/hcl/v2 to v2.19.1

Signed-off-by: CrazyMax <crazy-max@users.noreply.github.com>

vendor/github.com/zclconf/go-cty/cty/function/function.go

@@ -14,6 +14,9 @@ type Function struct {
 // Spec is the specification of a function, used to instantiate
 // a new Function.
 type Spec struct {
+	// Description is an optional description for the function specification.
+	Description string
+
 	// Params is a description of the positional parameters for the function.
 	// The standard checking logic rejects any calls that do not provide
 	// arguments conforming to this definition, freeing the function
@@ -36,6 +39,19 @@ type Spec struct {
 	// depending on its arguments.
 	Type TypeFunc
 
+	// RefineResult is an optional callback for describing additional
+	// refinements for the result value beyond what can be described using
+	// a type constraint.
+	//
+	// A refinement callback should always return the same builder it was
+	// given, typically after modifying it using the methods of
+	// [cty.RefinementBuilder].
+	//
+	// Any refinements described by this callback must hold for the entire
+	// range of results from the function. For refinements that only apply
+	// to certain results, use direct refinement within [Impl] instead.
+	RefineResult func(*cty.RefinementBuilder) *cty.RefinementBuilder
+
 	// Impl is the ImplFunc that implements the function's behavior.
 	//
 	// Functions are expected to behave as pure functions, and not create
@@ -230,6 +246,22 @@ func (f Function) Call(args []cty.Value) (val cty.Value, err error) {
 		return cty.NilVal, err
 	}
 
+	if refineResult := f.spec.RefineResult; refineResult != nil {
+		// If this function has a refinement callback then we'll refine
+		// our result value in the same way regardless of how we return.
+		// It's the function author's responsibility to ensure that the
+		// refinements they specify are valid for the full range of possible
+		// return values from the function. If not, this will panic when
+		// detecting an inconsistency.
+		defer func() {
+			if val != cty.NilVal {
+				if val.IsKnown() || val.Type() != cty.DynamicPseudoType {
+					val = val.RefineWith(refineResult)
+				}
+			}
+		}()
+	}
+
 	// Type checking already dealt with most situations relating to our
 	// parameter specification, but we still need to deal with unknown
 	// values and marked values.
@@ -344,3 +376,62 @@ func (f Function) VarParam() *Parameter {
 	ret := *f.spec.VarParam
 	return &ret
 }
+
+// Description returns a human-readable description of the function.
+func (f Function) Description() string {
+	return f.spec.Description
+}
+
+// WithNewDescriptions returns a new function that has the same signature
+// and implementation as the receiver but has the function description and
+// the parameter descriptions replaced with those given in the arguments.
+//
+// All descriptions may be given as an empty string to specify that there
+// should be no description at all.
+//
+// The paramDescs argument must match the number of parameters
+// the reciever expects, or this function will panic. If the function has a
+// VarParam then that counts as one parameter for the sake of this rule. The
+// given descriptions will be assigned in order starting with the positional
+// arguments in their declared order, followed by the variadic parameter if
+// any.
+//
+// As a special case, WithNewDescriptions will accept a paramDescs which
+// does not cover the reciever's variadic parameter (if any), so that it's
+// possible to add a variadic parameter to a function which didn't previously
+// have one without that being a breaking change for an existing caller using
+// WithNewDescriptions against that function. In this case the base description
+// of the variadic parameter will be preserved.
+func (f Function) WithNewDescriptions(funcDesc string, paramDescs []string) Function {
+	retSpec := *f.spec // shallow copy of the reciever
+	retSpec.Description = funcDesc
+
+	retSpec.Params = make([]Parameter, len(f.spec.Params))
+	copy(retSpec.Params, f.spec.Params) // shallow copy of positional parameters
+	if f.spec.VarParam != nil {
+		retVarParam := *f.spec.VarParam // shallow copy of variadic parameter
+		retSpec.VarParam = &retVarParam
+	}
+
+	if retSpec.VarParam != nil {
+		if with, without := len(retSpec.Params)+1, len(retSpec.Params); len(paramDescs) != with && len(paramDescs) != without {
+			panic(fmt.Sprintf("paramDescs must have length of either %d or %d", with, without))
+		}
+	} else {
+		if want := len(retSpec.Params); len(paramDescs) != want {
+			panic(fmt.Sprintf("paramDescs must have length %d", want))
+		}
+	}
+
+	posParamDescs := paramDescs[:len(retSpec.Params)]
+	varParamDescs := paramDescs[len(retSpec.Params):] // guaranteed to be zero or one elements because of the rules above
+
+	for i, desc := range posParamDescs {
+		retSpec.Params[i].Description = desc
+	}
+	for _, desc := range varParamDescs {
+		retSpec.VarParam.Description = desc
+	}
+
+	return New(&retSpec)
+}