Revert "chore: defer dependency-label support to a follow-up PR"

This reverts commit cecfe0e.

Author: diofeher

internal/tg/definition/definition.go

@@ -83,8 +83,11 @@ func traversalDefinitionTarget(expr *hclsyntax.ScopeTraversalExpr) (string, stri
 		return "", "", false
 	}
 
-	if rootStep.Name == "local" {
+	switch rootStep.Name {
+	case "local":
 		return attrStep.Name, DefinitionContextLocal, true
+	case "dependency":
+		return attrStep.Name, DefinitionContextDependency, true
 	}
 
 	return "", "", false

internal/tg/references/references_test.go

@@ -71,3 +71,28 @@ inputs = {
 		assert.Nil(t, locs)
 	})
 }
+
+func TestGetReferences_DependencyLabel(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	content := `dependency "vpc" {
+  config_path = "../vpc"
+}
+
+inputs = {
+  vpc_id = dependency.vpc.outputs.id
+}
+`
+	_, err := testutils.CreateFile(tmpDir, "terragrunt.hcl", content)
+	require.NoError(t, err)
+
+	tgPath := filepath.Join(tmpDir, "terragrunt.hcl")
+	l := testutils.NewTestLogger(t)
+	s := tg.NewState()
+	s.OpenDocument(t.Context(), l, uri.File(tgPath), content)
+
+	// Cursor on the reference (`vpc` in dependency.vpc.outputs.id).
+	locs := references.GetReferences(l, s.Configs[tgPath], protocol.Position{Line: 5, Character: 23}, tgPath, s.Configs, true)
+	require.Len(t, locs, 2, "label definition + outputs reference")
+}

internal/tg/rename/rename.go

@@ -22,6 +22,10 @@ const (
 	// (`locals { name = ... }` and `local.name` references).
 	RenameContextLocal = "local"
 
+	// RenameContextDependency is the context for renaming a dependency block
+	// label (`dependency "name" {}` and `dependency.name.outputs.X` references).
+	RenameContextDependency = "dependency"
+
 	// RenameContextNull means the cursor is not on a renameable identifier.
 	RenameContextNull = "null"
 )
@@ -33,7 +37,8 @@ type RenameTarget struct {
 	// Context is one of the RenameContext* constants.
 	Context string
 	// IdentRange is the LSP range covering only the identifier token, suitable
-	// for use as the prepare-rename range.
+	// for use as the prepare-rename range. For block labels this excludes the
+	// surrounding quotes.
 	IdentRange protocol.Range
 }
 
@@ -83,31 +88,37 @@ func GetRenameTarget(l logger.Logger, st store.Store, position protocol.Position
 	}
 
 	for cur := inode; cur != nil; cur = cur.Parent {
-		attr, ok := cur.Node.(*hclsyntax.Attribute)
-		if !ok {
-			continue
-		}
-
-		if !ast.IsLocalAttribute(cur) {
+		switch n := cur.Node.(type) {
+		case *hclsyntax.Block:
+			if t, ok := blockLabelTarget(n, position); ok {
+				return t
+			}
+			// We hit an enclosing block but the cursor isn't on its label.
 			return null
-		}
 
-		if !rangeContainsPosition(attr.NameRange, position) {
-			return null
-		}
+		case *hclsyntax.Attribute:
+			if !ast.IsLocalAttribute(cur) {
+				return null
+			}
+
+			if !rangeContainsPosition(n.NameRange, position) {
+				return null
+			}
 
-		return RenameTarget{
-			Name:       attr.Name,
-			Context:    RenameContextLocal,
-			IdentRange: ast.FromHCLRange(attr.NameRange),
+			return RenameTarget{
+				Name:       n.Name,
+				Context:    RenameContextLocal,
+				IdentRange: ast.FromHCLRange(n.NameRange),
+			}
 		}
 	}
 
 	return null
 }
 
 // traversalTarget extracts a RenameTarget from a ScopeTraversalExpr if the
-// cursor is positioned on its first two traversal steps and the root is `local`.
+// cursor is positioned on its first two traversal steps and the root is a
+// supported kind.
 func traversalTarget(expr *hclsyntax.ScopeTraversalExpr, position protocol.Position) RenameTarget {
 	null := RenameTarget{Context: RenameContextNull}
 
@@ -125,11 +136,8 @@ func traversalTarget(expr *hclsyntax.ScopeTraversalExpr, position protocol.Posit
 		return null
 	}
 
-	if rootStep.Name != "local" {
-		return null
-	}
-
-	// Restrict cursor to the first two steps.
+	// Restrict cursor to the first two steps so that, e.g., `dependency.vpc.outputs.x`
+	// only triggers rename when the cursor is on `dependency` or `vpc`.
 	firstTwo := hcl.Range{
 		Filename: rootStep.SrcRange.Filename,
 		Start:    rootStep.SrcRange.Start,
@@ -139,13 +147,56 @@ func traversalTarget(expr *hclsyntax.ScopeTraversalExpr, position protocol.Posit
 		return null
 	}
 
+	context, ok := contextForRoot(rootStep.Name)
+	if !ok {
+		return null
+	}
+
 	return RenameTarget{
 		Name:       attrStep.Name,
-		Context:    RenameContextLocal,
+		Context:    context,
 		IdentRange: ast.FromHCLRange(ast.TraverseAttrIdentRange(attrStep)),
 	}
 }
 
+// blockLabelTarget returns a RenameTarget when the cursor is on the first
+// label of an `include` or `dependency` block.
+func blockLabelTarget(block *hclsyntax.Block, position protocol.Position) (RenameTarget, bool) {
+	null := RenameTarget{Context: RenameContextNull}
+
+	context, ok := contextForRoot(block.Type)
+	if !ok || context == RenameContextLocal {
+		return null, false
+	}
+
+	if len(block.Labels) == 0 || len(block.LabelRanges) == 0 {
+		return null, false
+	}
+
+	if !rangeContainsPosition(block.LabelRanges[0], position) {
+		return null, false
+	}
+
+	return RenameTarget{
+		Name:       block.Labels[0],
+		Context:    context,
+		IdentRange: labelInnerRange(block.LabelRanges[0]),
+	}, true
+}
+
+// contextForRoot maps an HCL root identifier (the first traversal step or a
+// block type) to a rename context. Returns false for unsupported names.
+func contextForRoot(name string) (string, bool) {
+	switch name {
+	case "local":
+		return RenameContextLocal, true
+	case "dependency":
+		return RenameContextDependency, true
+	}
+
+	return "", false
+}
+
 // FindAllOccurrences returns every rename occurrence of target across all
 // sibling .hcl files in the same directory as originFile (including originFile
 // itself). When a file has an entry in configs with a parsed AST, that AST is
@@ -175,7 +226,7 @@ func FindAllOccurrences(l logger.Logger, target RenameTarget, originFile string,
 			continue
 		}
 
-		occurrences = append(occurrences, definitionOccurrences(target, file, iast)...)
+		occurrences = append(occurrences, definitionOccurrences(target, file, iast, body)...)
 
 		ast.WalkReferences(body, target.Context, target.Name, func(_ *hclsyntax.ScopeTraversalExpr, r hcl.Range) {
 			occurrences = append(occurrences, Occurrence{
@@ -204,26 +255,50 @@ func FindAllOccurrences(l logger.Logger, target RenameTarget, originFile string,
 }
 
 // definitionOccurrences finds the definition site(s) of target in the given file.
-func definitionOccurrences(target RenameTarget, file string, iast *ast.IndexedAST) []Occurrence {
-	if target.Context != RenameContextLocal {
-		return nil
-	}
+func definitionOccurrences(target RenameTarget, file string, iast *ast.IndexedAST, body *hclsyntax.Body) []Occurrence {
+	var occs []Occurrence
 
-	def, ok := iast.Locals[target.Name]
-	if !ok {
-		return nil
-	}
+	switch target.Context {
+	case RenameContextLocal:
+		def, ok := iast.Locals[target.Name]
+		if !ok {
+			return nil
+		}
 
-	attr, ok := def.Node.(*hclsyntax.Attribute)
-	if !ok {
-		return nil
+		attr, ok := def.Node.(*hclsyntax.Attribute)
+		if !ok {
+			return nil
+		}
+
+		occs = append(occs, Occurrence{
+			File:         file,
+			Range:        ast.FromHCLRange(attr.NameRange),
+			IsDefinition: true,
+		})
+
+	case RenameContextDependency:
+		for _, blk := range body.Blocks {
+			if blk.Type != target.Context {
+				continue
+			}
+
+			if len(blk.Labels) == 0 || blk.Labels[0] != target.Name {
+				continue
+			}
+
+			if len(blk.LabelRanges) == 0 {
+				continue
+			}
+
+			occs = append(occs, Occurrence{
+				File:         file,
+				Range:        labelInnerRange(blk.LabelRanges[0]),
+				IsDefinition: true,
+			})
+		}
 	}
 
-	return []Occurrence{{
-		File:         file,
-		Range:        ast.FromHCLRange(attr.NameRange),
-		IsDefinition: true,
-	}}
+	return occs
 }
 
 // siblingHCLFiles returns absolute paths of *.hcl files in dir, excluding
@@ -300,6 +375,17 @@ func getOrParseAST(path string, configs map[string]store.Store, l logger.Logger)
 	return iast
 }
 
+// labelInnerRange returns the LSP range of a quoted label's contents, excluding
+// the surrounding double quotes.
+func labelInnerRange(r hcl.Range) protocol.Range {
+	r.Start.Column++
+	r.Start.Byte++
+	r.End.Column--
+	r.End.Byte--
+
+	return ast.FromHCLRange(r)
+}
+
 // rangeContainsPosition reports whether p (LSP coordinates) is inside r (HCL
 // coordinates). The end of an HCL range is exclusive.
 func rangeContainsPosition(r hcl.Range, p protocol.Position) bool {

internal/tg/rename/rename_test.go

@@ -87,6 +87,32 @@ inputs = {
 			expectedName:    "foo",
 			expectedContext: rename.RenameContextLocal,
 		},
+		{
+			name: "cursor on dependency label",
+			document: `dependency "vpc" {
+  config_path = "../vpc"
+}`,
+			position:        protocol.Position{Line: 0, Character: 13},
+			expectedName:    "vpc",
+			expectedContext: rename.RenameContextDependency,
+		},
+		{
+			name: "cursor on dependency outputs reference",
+			document: `inputs = {
+  id = dependency.vpc.outputs.id
+}`,
+			position:        protocol.Position{Line: 1, Character: 19},
+			expectedName:    "vpc",
+			expectedContext: rename.RenameContextDependency,
+		},
+		{
+			name: "cursor on outputs step is not renameable",
+			document: `inputs = {
+  id = dependency.vpc.outputs.id
+}`,
+			position:        protocol.Position{Line: 1, Character: 24},
+			expectedContext: rename.RenameContextNull,
+		},
 		{
 			name: "cursor on unrelated traversal root",
 			document: `inputs = {
@@ -284,3 +310,34 @@ func TestFindAllOccurrences_PrefersInMemoryAST(t *testing.T) {
 	occs := rename.FindAllOccurrences(l, target, tgPath, configs)
 	require.Len(t, occs, 2, "definition (from in-memory common) + reference")
 }
+
+func TestFindAllOccurrences_DependencyLabel(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	content := `dependency "vpc" {
+  config_path = "../vpc"
+}
+
+inputs = {
+  vpc_id = dependency.vpc.outputs.id
+}
+`
+	_, err := testutils.CreateFile(tmpDir, "terragrunt.hcl", content)
+	require.NoError(t, err)
+
+	tgPath := filepath.Join(tmpDir, "terragrunt.hcl")
+
+	l := testutils.NewTestLogger(t)
+	s := tg.NewState()
+	s.OpenDocument(t.Context(), l, uri.File(tgPath), content)
+
+	// Cursor on the dependency label "vpc".
+	target := rename.GetRenameTarget(l, s.Configs[tgPath], protocol.Position{Line: 0, Character: 13})
+	require.Equal(t, rename.RenameContextDependency, target.Context)
+	require.Equal(t, "vpc", target.Name)
+
+	occs := rename.FindAllOccurrences(l, target, tgPath, s.Configs)
+	require.Len(t, occs, 2, "definition label + outputs reference")
+}

internal/tg/state_definition_test.go

@@ -1,6 +1,7 @@
 package tg_test
 
 import (
+	"os"
 	"path/filepath"
 	"testing"
 
@@ -107,3 +108,39 @@ func TestState_Definition_LocalReference_NotFound(t *testing.T) {
 	assert.Equal(t, docURI, resp.Result.URI)
 	assert.Equal(t, protocol.Position{Line: 1, Character: 18}, resp.Result.Range.Start)
 }
+
+func TestState_Definition_DependencyTraversalReference(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	vpcDir := filepath.Join(tmpDir, "vpc")
+	require.NoError(t, os.MkdirAll(vpcDir, 0o755))
+	_, err := testutils.CreateFile(vpcDir, "terragrunt.hcl", "")
+	require.NoError(t, err)
+
+	unitDir := filepath.Join(tmpDir, "app")
+	require.NoError(t, os.MkdirAll(unitDir, 0o755))
+
+	content := `dependency "vpc" {
+  config_path = "../vpc"
+}
+
+inputs = {
+  vpc_id = dependency.vpc.outputs.id
+}
+`
+	unitPath := filepath.Join(unitDir, "terragrunt.hcl")
+	_, err = testutils.CreateFile(unitDir, "terragrunt.hcl", content)
+	require.NoError(t, err)
+
+	l := testutils.NewTestLogger(t)
+	s := tg.NewState()
+	s.OpenDocument(t.Context(), l, uri.File(unitPath), content)
+
+	// Cursor on `vpc` in `dependency.vpc.outputs.id`.
+	resp := s.Definition(l, 1, uri.File(unitPath), protocol.Position{Line: 5, Character: 23})
+
+	expectedURI := uri.File(filepath.Join(vpcDir, "terragrunt.hcl"))
+	assert.Equal(t, expectedURI, resp.Result.URI, "should jump to dependent unit's terragrunt.hcl")
+}