gohcl: Fix docs about supported types for blocks.

This commit fixes a clause in the `gohcl` package documentation which incorrectly
states that HCL blocks could be decoded into `hcl.Body` and `hcl.Block` types.

It also removes some code paths in `decodeBlockToValue()` that _appeared_ to
handled these cases. In practice, these paths were unreachable anyway due to
various reflection-based type checks made before `decodeBlockToValue()` is
called.

gohcl/decode.go

@@ -258,32 +258,14 @@ func decodeBodyToMap(body hcl.Body, ctx *hcl.EvalContext, v reflect.Value) hcl.D
 }
 
 func decodeBlockToValue(block *hcl.Block, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
-	var diags hcl.Diagnostics
-
-	ty := v.Type()
-
-	switch {
-	case blockType.AssignableTo(ty):
-		v.Elem().Set(reflect.ValueOf(block))
-	case bodyType.AssignableTo(ty):
-		v.Elem().Set(reflect.ValueOf(block.Body))
-	case attrsType.AssignableTo(ty):
-		attrs, attrsDiags := block.Body.JustAttributes()
-		if len(attrsDiags) > 0 {
-			diags = append(diags, attrsDiags...)
-		}
-		v.Elem().Set(reflect.ValueOf(attrs))
-	default:
-		diags = append(diags, decodeBodyToValue(block.Body, ctx, v)...)
+	diags := decodeBodyToValue(block.Body, ctx, v)
 
-		if len(block.Labels) > 0 {
-			blockTags := getFieldTags(ty)
-			for li, lv := range block.Labels {
-				lfieldIdx := blockTags.Labels[li].FieldIndex
-				v.Field(lfieldIdx).Set(reflect.ValueOf(lv))
-			}
+	if len(block.Labels) > 0 {
+		blockTags := getFieldTags(v.Type())
+		for li, lv := range block.Labels {
+			lfieldIdx := blockTags.Labels[li].FieldIndex
+			v.Field(lfieldIdx).Set(reflect.ValueOf(lv))
 		}
-
 	}
 
 	return diags

gohcl/doc.go

@@ -24,11 +24,9 @@
 // expression is assigned, or of any type accepted by gocty, in which case
 // gocty will be used to assign the value to a native Go type.
 //
-// "block" fields may be of type *hcl.Block or hcl.Body, in which case the
-// corresponding raw value is assigned, or may be a struct that recursively
-// uses the same tags. Block fields may also be slices of any of these types,
-// in which case multiple blocks of the corresponding type are decoded into
-// the slice.
+// "block" fields may be a struct that recursively uses the same tags, or a
+// slice of such structs, in which case multiple blocks of the corresponding
+// type are decoded into the slice.
 //
 // "body" can be placed on a single field of type hcl.Body to capture
 // the full hcl.Body that was decoded for a block. This does not allow leftover