Expose new kind of origins (#112)

* add new targets field to body schema
* expose dependency key attributes as direct origins

When the body schema has a valid `Targets` set, we expose
all dependecy keys as DirectOrigin for go to definition.

* merge Targets as part of the dependent body schema merger

Co-authored-by: Radek Simko <[email protected]>

Author: dbanck

decoder/decoder.go

@@ -69,6 +69,8 @@ func mergeBlockBodySchemas(block *hcl.Block, blockSchema *schema.BlockSchema) (*
 		for _, tBody := range depSchema.TargetableAs {
 			mergedSchema.TargetableAs = append(mergedSchema.TargetableAs, tBody)
 		}
+
+		mergedSchema.Targets = depSchema.Targets.Copy()
 	}
 
 	return mergedSchema, nil

decoder/reference_origins.go

@@ -111,6 +111,14 @@ func (d *PathDecoder) referenceOriginsInBody(body hcl.Body, bodySchema *schema.B
 			}
 		}
 
+		if aSchema.IsDepKey && bodySchema.Targets != nil {
+			origins = append(origins, reference.DirectOrigin{
+				Range:       attr.Expr.Range(),
+				TargetPath:  bodySchema.Targets.Path,
+				TargetRange: bodySchema.Targets.Range,
+			})
+		}
+
 		origins = append(origins, d.findOriginsInExpression(attr.Expr, aSchema.Expr)...)
 	}
 

decoder/reference_targets.go

@@ -33,6 +33,15 @@ func (d *Decoder) ReferenceTargetsForOriginAtPos(path lang.Path, file string, po
 		targetCtx := pathCtx
 		targetPath := path
 
+		if directOrigin, ok := origin.(reference.DirectOrigin); ok {
+			matchingTargets = append(matchingTargets, &ReferenceTarget{
+				OriginRange: origin.OriginRange(),
+				Path:        directOrigin.TargetPath,
+				Range:       directOrigin.TargetRange,
+				DefRangePtr: nil,
+			})
+			continue
+		}
 		if pathOrigin, ok := origin.(reference.PathOrigin); ok {
 			ctx, err := d.pathReader.PathContext(pathOrigin.TargetPath)
 			if err != nil {
@@ -42,7 +51,11 @@ func (d *Decoder) ReferenceTargetsForOriginAtPos(path lang.Path, file string, po
 			targetPath = pathOrigin.TargetPath
 		}
 
-		targets, ok := targetCtx.ReferenceTargets.Match(origin.Address(), origin.OriginConstraints())
+		matchableOrigin, ok := origin.(reference.MatchableOrigin)
+		if !ok {
+			continue
+		}
+		targets, ok := targetCtx.ReferenceTargets.Match(matchableOrigin.Address(), matchableOrigin.OriginConstraints())
 		if !ok {
 			// target not found
 			continue

decoder/reference_targets_test.go

@@ -280,6 +280,49 @@ func TestReferenceTargetForOriginAtPos(t *testing.T) {
 			},
 			nil,
 		},
+		{
+			"direct origin target",
+			map[string]*PathContext{
+				dirPath: {
+					ReferenceTargets: reference.Targets{},
+					ReferenceOrigins: reference.Origins{
+						reference.DirectOrigin{
+							Range: hcl.Range{
+								Filename: "test.tf",
+								Start:    hcl.Pos{Line: 1, Column: 1, Byte: 0},
+								End:      hcl.Pos{Line: 1, Column: 6, Byte: 5},
+							},
+							TargetPath: lang.Path{Path: dirPath, LanguageID: "terraform"},
+							TargetRange: hcl.Range{
+								Filename: "target.tf",
+								Start:    hcl.Pos{Line: 1, Column: 1, Byte: 0},
+								End:      hcl.Pos{Line: 3, Column: 2, Byte: 15},
+							},
+						},
+					},
+				},
+			},
+			lang.Path{Path: dirPath},
+			"test.tf",
+			hcl.InitialPos,
+			ReferenceTargets{
+				{
+					OriginRange: hcl.Range{
+						Filename: "test.tf",
+						Start:    hcl.Pos{Line: 1, Column: 1, Byte: 0},
+						End:      hcl.Pos{Line: 1, Column: 6, Byte: 5},
+					},
+					Path: lang.Path{Path: dirPath, LanguageID: "terraform"},
+					Range: hcl.Range{
+						Filename: "target.tf",
+						Start:    hcl.Pos{Line: 1, Column: 1, Byte: 0},
+						End:      hcl.Pos{Line: 3, Column: 2, Byte: 15},
+					},
+					DefRangePtr: nil,
+				},
+			},
+			nil,
+		},
 	}
 
 	for i, tc := range testCases {

reference/origin.go

@@ -11,6 +11,10 @@ type Origin interface {
 	isOriginImpl() originSigil
 	Copy() Origin
 	OriginRange() hcl.Range
+}
+
+type MatchableOrigin interface {
+	Origin
 	OriginConstraints() OriginConstraints
 	Address() lang.Address
 }

reference/origin_direct.go

@@ -0,0 +1,35 @@
+package reference
+
+import (
+	"github.com/hashicorp/hcl-lang/lang"
+	"github.com/hashicorp/hcl/v2"
+)
+
+// DirectOrigin represents an origin which directly targets a file
+// and doesn't need a matching target
+type DirectOrigin struct {
+	// Range represents a range of a local traversal, attribute, or an expression
+	Range hcl.Range
+
+	// TargetPath represents what (directory) Path does the origin targets
+	TargetPath lang.Path
+
+	// TargetRange represents which file and line the origin targets
+	TargetRange hcl.Range
+}
+
+func (do DirectOrigin) Copy() Origin {
+	return DirectOrigin{
+		Range:       do.Range,
+		TargetPath:  do.TargetPath,
+		TargetRange: do.TargetRange,
+	}
+}
+
+func (DirectOrigin) isOriginImpl() originSigil {
+	return originSigil{}
+}
+
+func (do DirectOrigin) OriginRange() hcl.Range {
+	return do.Range
+}

reference/origins_test.go

@@ -501,6 +501,33 @@ func TestOrigins_Match(t *testing.T) {
 				},
 			},
 		},
+		{
+			"direct origin cannot be matched",
+			alphaPath,
+			Origins{
+				DirectOrigin{
+					Range: hcl.Range{
+						Filename: "origin.tf",
+						Start:    hcl.InitialPos,
+						End:      hcl.InitialPos,
+					},
+					TargetPath: betaPath,
+					TargetRange: hcl.Range{
+						Filename: "target.tf",
+						Start:    hcl.InitialPos,
+						End:      hcl.InitialPos,
+					},
+				},
+			},
+			alphaPath,
+			Target{
+				Addr: lang.Address{
+					lang.RootStep{Name: "test"},
+				},
+				Type: cty.String,
+			},
+			Origins{},
+		},
 	}
 	for i, tc := range testCases {
 		t.Run(fmt.Sprintf("%d-%s", i, tc.name), func(t *testing.T) {

reference/targets_test.go

@@ -16,7 +16,7 @@ func TestTargets_Match(t *testing.T) {
 	testCases := []struct {
 		name            string
 		targets         Targets
-		origin          Origin
+		origin          MatchableOrigin
 		expectedTargets Targets
 		expectedFound   bool
 	}{

schema/body_schema.go

@@ -31,13 +31,22 @@ type BodySchema struct {
 	// TargetableAs represents how else the body may be targeted
 	// if not by its declarable attributes or blocks.
 	TargetableAs Targetables
+
+	// Targets represents a location targeted by the body, when used as a body
+	// dependent on an attribute (e.g. Terraform module source)
+	Targets *Target
 }
 
 type DocsLink struct {
 	URL     string
 	Tooltip string
 }
 
+type Target struct {
+	Path  lang.Path
+	Range hcl.Range
+}
+
 func (*BodySchema) isSchemaImpl() schemaImplSigil {
 	return schemaImplSigil{}
 }
@@ -137,6 +146,7 @@ func (bs *BodySchema) Copy() *BodySchema {
 		AnyAttribute: bs.AnyAttribute.Copy(),
 		HoverURL:     bs.HoverURL,
 		DocsLink:     bs.DocsLink.Copy(),
+		Targets:      bs.Targets.Copy(),
 	}
 
 	if bs.TargetableAs != nil {
@@ -173,3 +183,14 @@ func (dl *DocsLink) Copy() *DocsLink {
 		Tooltip: dl.Tooltip,
 	}
 }
+
+func (t *Target) Copy() *Target {
+	if t == nil {
+		return nil
+	}
+
+	return &Target{
+		Path:  t.Path,
+		Range: t.Range,
+	}
+}