Finish reference target collection for all constraints

decoder/expr_list_ref_targets.go

@@ -5,28 +5,33 @@ import (
 
 	"github.com/hashicorp/hcl-lang/lang"
 	"github.com/hashicorp/hcl-lang/reference"
-	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/hashicorp/hcl-lang/schema"
+	"github.com/hashicorp/hcl/v2"
 	"github.com/zclconf/go-cty/cty"
 )
 
 func (list List) ReferenceTargets(ctx context.Context, targetCtx *TargetContext) reference.Targets {
-	eType, ok := list.expr.(*hclsyntax.TupleConsExpr)
-	if !ok {
+	elems, diags := hcl.ExprList(list.expr)
+	if diags.HasErrors() {
 		return reference.Targets{}
 	}
 
-	if len(eType.Exprs) == 0 || list.cons.Elem == nil {
+	if list.cons.Elem == nil {
 		return reference.Targets{}
 	}
 
-	targets := make(reference.Targets, 0)
-
-	// TODO: collect parent target for the whole list
-	// See https://github.com/hashicorp/hcl-lang/issues/228
+	elemTargets := make(reference.Targets, 0)
 
-	for i, elemExpr := range eType.Exprs {
+	for i, elemExpr := range elems {
 		expr := newExpression(list.pathCtx, elemExpr, list.cons.Elem)
 		if e, ok := expr.(ReferenceTargetsExpression); ok {
+			if targetCtx == nil {
+				// collect any targets inside the expression
+				// if attribute itself isn't targetable
+				elemTargets = append(elemTargets, e.ReferenceTargets(ctx, nil)...)
+				continue
+			}
+
 			elemCtx := targetCtx.Copy()
 			elemCtx.ParentAddress = append(elemCtx.ParentAddress, lang.IndexStep{
 				Key: cty.NumberIntVal(int64(i)),
@@ -37,8 +42,58 @@ func (list List) ReferenceTargets(ctx context.Context, targetCtx *TargetContext)
 				})
 			}
 
-			targets = append(targets, e.ReferenceTargets(ctx, elemCtx)...)
+			elemTargets = append(elemTargets, e.ReferenceTargets(ctx, elemCtx)...)
+		}
+	}
+
+	targets := make(reference.Targets, 0)
+
+	if targetCtx != nil {
+		// collect target for the whole list
+
+		var rangePtr *hcl.Range
+		if targetCtx.ParentRangePtr != nil {
+			rangePtr = targetCtx.ParentRangePtr
+		} else {
+			rangePtr = list.expr.Range().Ptr()
+		}
+
+		// type-aware
+		elemCons, ok := list.cons.Elem.(schema.TypeAwareConstraint)
+		if targetCtx.AsExprType && ok {
+			elemType, ok := elemCons.ConstraintType()
+			if ok {
+				targets = append(targets, reference.Target{
+					Addr:                   targetCtx.ParentAddress,
+					Name:                   targetCtx.FriendlyName,
+					Type:                   cty.List(elemType),
+					ScopeId:                targetCtx.ScopeId,
+					RangePtr:               rangePtr,
+					DefRangePtr:            targetCtx.ParentDefRangePtr,
+					NestedTargets:          elemTargets,
+					LocalAddr:              targetCtx.ParentLocalAddress,
+					TargetableFromRangePtr: targetCtx.TargetableFromRangePtr,
+				})
+			}
+		}
+
+		// type-unaware
+		if targetCtx.AsReference {
+			targets = append(targets, reference.Target{
+				Addr:                   targetCtx.ParentAddress,
+				Name:                   targetCtx.FriendlyName,
+				ScopeId:                targetCtx.ScopeId,
+				RangePtr:               rangePtr,
+				DefRangePtr:            targetCtx.ParentDefRangePtr,
+				NestedTargets:          elemTargets,
+				LocalAddr:              targetCtx.ParentLocalAddress,
+				TargetableFromRangePtr: targetCtx.TargetableFromRangePtr,
+			})
 		}
+	} else {
+		// treat element targets as 1st class ones
+		// if the list itself isn't targetable
+		targets = elemTargets
 	}
 
 	return targets