Add gohcl body variable inspections

Signed-off-by: Christian Mesh <[email protected]>

Author: cam72cam

gohcl/decode.go

@@ -123,6 +123,13 @@ func decodeBodyToStruct(body hcl.Body, ctx *hcl.EvalContext, val reflect.Value)
 			fieldV.Set(reflect.ValueOf(attr))
 		case exprType.AssignableTo(field.Type):
 			fieldV.Set(reflect.ValueOf(attr.Expr))
+		case field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct:
+			// TODO might want to check for nil here
+			rn := reflect.New(field.Type.Elem())
+			fieldV.Set(rn)
+			diags = append(diags, DecodeExpression(
+				attr.Expr, ctx, fieldV.Interface(),
+			)...)
 		default:
 			diags = append(diags, DecodeExpression(
 				attr.Expr, ctx, fieldV.Addr().Interface(),
@@ -276,7 +283,9 @@ func decodeBlockToValue(block *hcl.Block, ctx *hcl.EvalContext, v reflect.Value)
 
 // DecodeExpression extracts the value of the given expression into the given
 // value. This value must be something that gocty is able to decode into,
-// since the final decoding is delegated to that package.
+// since the final decoding is delegated to that package.  If a reference to
+// a struct is provided which contains gohcl tags, it will be decoded using
+// the attr and optional tags.
 //
 // The given EvalContext is used to resolve any variables or functions in
 // expressions encountered while decoding. This may be nil to require only
@@ -290,20 +299,59 @@ func decodeBlockToValue(block *hcl.Block, ctx *hcl.EvalContext, v reflect.Value)
 // integration use-cases.
 func DecodeExpression(expr hcl.Expression, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
 	srcVal, diags := expr.Value(ctx)
+	if diags.HasErrors() {
+		return diags
+	}
+
+	return append(diags, DecodeValue(srcVal, expr.StartRange(), expr.Range(), val)...)
+}
+
+// DecodeValue extracts the given value into the provided target.
+// This value must be something that gocty is able to decode into,
+// since the final decoding is delegated to that package.  If a reference to
+// a struct is provided which contains gohcl tags, it will be decoded using
+// the attr and optional tags.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeValue(srcVal cty.Value, subject hcl.Range, context hcl.Range, val interface{}) hcl.Diagnostics {
+	rv := reflect.ValueOf(val)
+	if rv.Type().Kind() == reflect.Ptr && rv.Type().Elem().Kind() == reflect.Struct && hasFieldTags(rv.Elem().Type()) {
+		attrs := make(hcl.Attributes)
+		for k, v := range srcVal.AsValueMap() {
+			attrs[k] = &hcl.Attribute{
+				Name:  k,
+				Expr:  hcl.StaticExpr(v, context),
+				Range: subject,
+			}
+
+		}
+		return decodeBodyToStruct(synthBody{
+			attrs:   attrs,
+			subject: subject,
+			context: context,
+		}, nil, rv.Elem())
+
+	}
 
 	convTy, err := gocty.ImpliedType(val)
 	if err != nil {
 		panic(fmt.Sprintf("unsuitable DecodeExpression target: %s", err))
 	}
 
+	var diags hcl.Diagnostics
+
 	srcVal, err = convert.Convert(srcVal, convTy)
 	if err != nil {
 		diags = append(diags, &hcl.Diagnostic{
 			Severity: hcl.DiagError,
 			Summary:  "Unsuitable value type",
 			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
-			Subject:  expr.StartRange().Ptr(),
-			Context:  expr.Range().Ptr(),
+			Subject:  subject.Ptr(),
+			Context:  context.Ptr(),
 		})
 		return diags
 	}
@@ -314,10 +362,80 @@ func DecodeExpression(expr hcl.Expression, ctx *hcl.EvalContext, val interface{}
 			Severity: hcl.DiagError,
 			Summary:  "Unsuitable value type",
 			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
-			Subject:  expr.StartRange().Ptr(),
-			Context:  expr.Range().Ptr(),
+			Subject:  subject.Ptr(),
+			Context:  context.Ptr(),
 		})
 	}
 
 	return diags
 }
+
+type synthBody struct {
+	attrs   hcl.Attributes
+	subject hcl.Range
+	context hcl.Range
+}
+
+func (s synthBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+	body, partial, diags := s.PartialContent(schema)
+
+	attrs, _ := partial.JustAttributes()
+	for name := range attrs {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsupported argument",
+			Detail:   fmt.Sprintf("An argument named %q is not expected here.", name),
+			Subject:  s.subject.Ptr(),
+			Context:  s.context.Ptr(),
+		})
+	}
+
+	return body, diags
+}
+
+func (s synthBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	for _, block := range schema.Blocks {
+		panic("hcl block tags are not allowed in attribute structs: " + block.Type)
+	}
+
+	attrs := make(hcl.Attributes)
+	remainder := make(hcl.Attributes)
+
+	for _, attr := range schema.Attributes {
+		v, ok := s.attrs[attr.Name]
+		if !ok {
+			if attr.Required {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing required argument",
+					Detail:   fmt.Sprintf("The argument %q is required, but no definition was found.", attr.Name),
+					Subject:  s.subject.Ptr(),
+					Context:  s.context.Ptr(),
+				})
+			}
+			continue
+		}
+
+		attrs[attr.Name] = v
+	}
+
+	for k, v := range s.attrs {
+		if _, ok := attrs[k]; !ok {
+			remainder[k] = v
+		}
+	}
+
+	return &hcl.BodyContent{
+		Attributes:       attrs,
+		MissingItemRange: s.context,
+	}, synthBody{attrs: remainder}, diags
+}
+
+func (s synthBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+	return s.attrs, nil
+}
+func (s synthBody) MissingItemRange() hcl.Range {
+	return s.context
+}

gohcl/doc.go

@@ -10,18 +10,18 @@
 // A struct field tag scheme is used, similar to other decoding and
 // unmarshalling libraries. The tags are formatted as in the following example:
 //
-//    ThingType string `hcl:"thing_type,attr"`
+//	ThingType string `hcl:"thing_type,attr"`
 //
 // Within each tag there are two comma-separated tokens. The first is the
 // name of the corresponding construct in configuration, while the second
 // is a keyword giving the kind of construct expected. The following
 // kind keywords are supported:
 //
-//    attr (the default) indicates that the value is to be populated from an attribute
-//    block indicates that the value is to populated from a block
-//    label indicates that the value is to populated from a block label
-//    optional is the same as attr, but the field is optional
-//    remain indicates that the value is to be populated from the remaining body after populating other fields
+//	attr (the default) indicates that the value is to be populated from an attribute
+//	block indicates that the value is to populated from a block
+//	label indicates that the value is to populated from a block label
+//	optional is the same as attr, but the field is optional
+//	remain indicates that the value is to be populated from the remaining body after populating other fields
 //
 // "attr" fields may either be of type *hcl.Expression, in which case the raw
 // expression is assigned, or of any type accepted by gocty, in which case

gohcl/schema.go

@@ -111,6 +111,18 @@ func ImpliedBodySchema(val interface{}) (schema *hcl.BodySchema, partial bool) {
 	return schema, partial
 }
 
+func hasFieldTags(ty reflect.Type) bool {
+	ct := ty.NumField()
+	for i := 0; i < ct; i++ {
+		field := ty.Field(i)
+		tag := field.Tag.Get("hcl")
+		if tag != "" {
+			return true
+		}
+	}
+	return false
+}
+
 type fieldTags struct {
 	Attributes map[string]int
 	Blocks     map[string]int

gohcl/vardecode.go

@@ -0,0 +1,99 @@
+// Copyright (c) The OpenTofu Authors
+// SPDX-License-Identifier: MPL-2.0
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+func VariablesInBody(body hcl.Body, val interface{}) ([]hcl.Traversal, hcl.Diagnostics) {
+	rv := reflect.ValueOf(val)
+	if rv.Kind() != reflect.Ptr {
+		panic(fmt.Sprintf("target value must be a pointer, not %s", rv.Type().String()))
+	}
+
+	return findVariablesInBody(body, rv.Elem())
+}
+
+func findVariablesInBody(body hcl.Body, val reflect.Value) ([]hcl.Traversal, hcl.Diagnostics) {
+	et := val.Type()
+	switch et.Kind() {
+	case reflect.Struct:
+		return findVariablesInBodyStruct(body, val)
+	case reflect.Map:
+		return findVariablesInBodyMap(body, val)
+	default:
+		panic(fmt.Sprintf("target value must be pointer to struct or map, not %s", et.String()))
+	}
+}
+
+func findVariablesInBodyStruct(body hcl.Body, val reflect.Value) ([]hcl.Traversal, hcl.Diagnostics) {
+	var variables []hcl.Traversal
+
+	schema, partial := ImpliedBodySchema(val.Interface())
+
+	var content *hcl.BodyContent
+	var diags hcl.Diagnostics
+	if partial {
+		content, _, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+	if content == nil {
+		return variables, diags
+	}
+
+	tags := getFieldTags(val.Type())
+
+	for name := range tags.Attributes {
+		attr := content.Attributes[name]
+		if attr != nil {
+			variables = append(variables, attr.Expr.Variables()...)
+		}
+	}
+
+	blocksByType := content.Blocks.ByType()
+
+	for typeName, fieldIdx := range tags.Blocks {
+		blocks := blocksByType[typeName]
+		field := val.Type().Field(fieldIdx)
+
+		ty := field.Type
+		if ty.Kind() == reflect.Slice {
+			ty = ty.Elem()
+		}
+		if ty.Kind() == reflect.Ptr {
+			ty = ty.Elem()
+		}
+
+		for _, block := range blocks {
+			blockVars, blockDiags := findVariablesInBody(block.Body, reflect.New(ty).Elem())
+			variables = append(variables, blockVars...)
+			diags = append(diags, blockDiags...)
+		}
+
+	}
+
+	return variables, diags
+}
+
+func findVariablesInBodyMap(body hcl.Body, v reflect.Value) ([]hcl.Traversal, hcl.Diagnostics) {
+	var variables []hcl.Traversal
+
+	attrs, diags := body.JustAttributes()
+	if attrs == nil {
+		return variables, diags
+	}
+
+	for _, attr := range attrs {
+		variables = append(variables, attr.Expr.Variables()...)
+	}
+
+	return variables, diags
+}

gohcl/vardecode_test.go

@@ -0,0 +1,84 @@
+// Copyright (c) The OpenTofu Authors
+// SPDX-License-Identifier: MPL-2.0
+// Copyright (c) 2023 HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package gohcl_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/gohcl"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+var data = `
+inner "foo" "bar" {
+	val = magic.foo.bar
+	data = {
+		"z" = nested.value
+	}
+}
+`
+
+type InnerBlock struct {
+	Type  string            `hcl:"type,label"`
+	Name  string            `hcl:"name,label"`
+	Value string            `hcl:"val"`
+	Data  map[string]string `hcl:"data"`
+}
+
+type OuterBlock struct {
+	Contents InnerBlock `hcl:"inner,block"`
+}
+
+func Test(t *testing.T) {
+
+	println("> Parse HCL")
+	file, diags := hclsyntax.ParseConfig([]byte(data), "INLINE", hcl.Pos{Byte: 0, Line: 1, Column: 1})
+
+	println(diags.Error())
+
+	ob := &OuterBlock{}
+
+	println()
+	println("> Detect Variables")
+	vars, diags := gohcl.VariablesInBody(file.Body, ob)
+	println(diags.Error())
+	for _, v := range vars {
+		ident := ""
+		for _, p := range v {
+			if root, ok := p.(hcl.TraverseRoot); ok {
+				ident += root.Name
+			}
+			if attr, ok := p.(hcl.TraverseAttr); ok {
+				ident += "." + attr.Name
+			}
+		}
+		println("Required: " + ident)
+	}
+
+	println()
+	println("> Decode Body")
+
+	ctx := &hcl.EvalContext{
+		Variables: map[string]cty.Value{
+			"magic": cty.ObjectVal(map[string]cty.Value{
+				"foo": cty.ObjectVal(map[string]cty.Value{
+					"bar": cty.StringVal("BAR IS BEST BAR"),
+				}),
+			}),
+			"nested": cty.ObjectVal(map[string]cty.Value{
+				"value": cty.StringVal("ZISHERE"),
+			}),
+		},
+	}
+
+	diags = gohcl.DecodeBody(file.Body, ctx, ob)
+	println(diags.Error())
+
+	fmt.Printf("%#v\n", ob)
+}