Enable go to module output (#122)

* Add `ImpliedOrigins` to the body schema
* Collect and match `ImpliedOrigin` during reference origin collection

We match the implied origins from the schema against each
`LocalOrigin` we found. If the address matches, we introduce a
new `PathOrigin`, so the user can navigate from this origin to the
target of the implied origin.

This is primarily used for navigating to output block of modules
in Terraform.

* Add test case for implied origin reference collection

Author: dbanck

decoder/decoder.go

@@ -47,6 +47,9 @@ func mergeBlockBodySchemas(block *hcl.Block, blockSchema *schema.BlockSchema) (*
 	if mergedSchema.TargetableAs == nil {
 		mergedSchema.TargetableAs = make([]*schema.Targetable, 0)
 	}
+	if mergedSchema.ImpliedOrigins == nil {
+		mergedSchema.ImpliedOrigins = make([]schema.ImpliedOrigin, 0)
+	}
 
 	depSchema, _, ok := NewBlockSchema(blockSchema).DependentBodySchema(block)
 	if ok {
@@ -66,10 +69,9 @@ func mergeBlockBodySchemas(block *hcl.Block, blockSchema *schema.BlockSchema) (*
 				continue
 			}
 		}
-		for _, tBody := range depSchema.TargetableAs {
-			mergedSchema.TargetableAs = append(mergedSchema.TargetableAs, tBody)
-		}
 
+		mergedSchema.TargetableAs = append(mergedSchema.TargetableAs, depSchema.TargetableAs...)
+		mergedSchema.ImpliedOrigins = append(mergedSchema.ImpliedOrigins, depSchema.ImpliedOrigins...)
 		mergedSchema.Targets = depSchema.Targets.Copy()
 		mergedSchema.DocsLink = depSchema.DocsLink.Copy()
 	}

decoder/reference_origins.go

@@ -50,6 +50,7 @@ func (d *Decoder) ReferenceOriginsTargetingPos(path lang.Path, file string, pos
 
 func (d *PathDecoder) CollectReferenceOrigins() (reference.Origins, error) {
 	refOrigins := make(reference.Origins, 0)
+	impliedOrigins := make([]schema.ImpliedOrigin, 0)
 
 	if d.pathCtx.Schema == nil {
 		// unable to collect reference origins without schema
@@ -64,7 +65,29 @@ func (d *PathDecoder) CollectReferenceOrigins() (reference.Origins, error) {
 			continue
 		}
 
-		refOrigins = append(refOrigins, d.referenceOriginsInBody(f.Body, d.pathCtx.Schema)...)
+		os, ios := d.referenceOriginsInBody(f.Body, d.pathCtx.Schema)
+		refOrigins = append(refOrigins, os...)
+		impliedOrigins = append(impliedOrigins, ios...)
+	}
+
+	for _, impliedOrigin := range impliedOrigins {
+		for _, origin := range refOrigins {
+			localOrigin, ok := origin.(reference.LocalOrigin)
+
+			if ok && localOrigin.Addr.Equals(impliedOrigin.OriginAddress) {
+				refOrigins = append(refOrigins, reference.PathOrigin{
+					Range:      origin.OriginRange(),
+					TargetAddr: impliedOrigin.TargetAddress,
+					TargetPath: impliedOrigin.Path,
+					Constraints: reference.OriginConstraints{
+						{
+							OfScopeId: impliedOrigin.Constraints.ScopeId,
+							OfType:    impliedOrigin.Constraints.Type,
+						},
+					},
+				})
+			}
+		}
 	}
 
 	sort.SliceStable(refOrigins, func(i, j int) bool {
@@ -75,13 +98,15 @@ func (d *PathDecoder) CollectReferenceOrigins() (reference.Origins, error) {
 	return refOrigins, nil
 }
 
-func (d *PathDecoder) referenceOriginsInBody(body hcl.Body, bodySchema *schema.BodySchema) reference.Origins {
+func (d *PathDecoder) referenceOriginsInBody(body hcl.Body, bodySchema *schema.BodySchema) (reference.Origins, []schema.ImpliedOrigin) {
 	origins := make(reference.Origins, 0)
+	impliedOrigins := make([]schema.ImpliedOrigin, 0)
 
 	if bodySchema == nil {
-		return origins
+		return origins, impliedOrigins
 	}
 
+	impliedOrigins = append(impliedOrigins, bodySchema.ImpliedOrigins...)
 	content := decodeBody(body, bodySchema)
 
 	for _, attr := range content.Attributes {
@@ -133,11 +158,14 @@ func (d *PathDecoder) referenceOriginsInBody(body hcl.Body, bodySchema *schema.B
 			if err != nil {
 				continue
 			}
-			origins = append(origins, d.referenceOriginsInBody(block.Body, mergedSchema)...)
+
+			os, ios := d.referenceOriginsInBody(block.Body, mergedSchema)
+			origins = append(origins, os...)
+			impliedOrigins = append(impliedOrigins, ios...)
 		}
 	}
 
-	return origins
+	return origins, impliedOrigins
 }
 
 func (d *PathDecoder) findOriginsInExpression(expr hcl.Expression, ec schema.ExprConstraints) reference.Origins {

decoder/reference_origins_collect_hcl_test.go

@@ -941,6 +941,80 @@ tup = [ var.three ]
 				},
 			},
 		},
+		{
+			"schema with implied origin",
+			&schema.BodySchema{
+				Attributes: map[string]*schema.AttributeSchema{
+					"attr": {
+						Expr: schema.ExprConstraints{
+							schema.TraversalExpr{},
+						},
+					},
+				},
+				ImpliedOrigins: schema.ImpliedOrigins{
+					{
+						OriginAddress: lang.Address{
+							lang.RootStep{Name: "module"},
+							lang.AttrStep{Name: "refname"},
+							lang.AttrStep{Name: "outname"},
+						},
+						TargetAddress: lang.Address{
+							lang.RootStep{Name: "output"},
+							lang.AttrStep{Name: "outname"},
+						},
+						Path:        lang.Path{Path: "./local", LanguageID: "terraform"},
+						Constraints: schema.Constraints{ScopeId: "output"},
+					},
+				},
+			},
+			`attr = module.refname.outname`,
+			reference.Origins{
+				reference.LocalOrigin{
+					Addr: lang.Address{
+						lang.RootStep{Name: "module"},
+						lang.AttrStep{Name: "refname"},
+						lang.AttrStep{Name: "outname"},
+					},
+					Constraints: reference.OriginConstraints{{}},
+					Range: hcl.Range{
+						Filename: "test.tf",
+						Start: hcl.Pos{
+							Line:   1,
+							Column: 8,
+							Byte:   7,
+						},
+						End: hcl.Pos{
+							Line:   1,
+							Column: 30,
+							Byte:   29,
+						},
+					},
+				},
+				reference.PathOrigin{
+					TargetAddr: lang.Address{
+						lang.RootStep{Name: "output"},
+						lang.AttrStep{Name: "outname"},
+					},
+					TargetPath: lang.Path{Path: "./local", LanguageID: "terraform"},
+					Constraints: reference.OriginConstraints{{
+						OfScopeId: "output",
+					}},
+					Range: hcl.Range{
+						Filename: "test.tf",
+						Start: hcl.Pos{
+							Line:   1,
+							Column: 8,
+							Byte:   7,
+						},
+						End: hcl.Pos{
+							Line:   1,
+							Column: 30,
+							Byte:   29,
+						},
+					},
+				},
+			},
+		},
 	}
 	for i, tc := range testCases {
 		t.Run(fmt.Sprintf("%d/%s", i, tc.name), func(t *testing.T) {

schema/body_schema.go

@@ -32,9 +32,34 @@ type BodySchema struct {
 	// 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 represent a location targeted by the body; when used as a body
+	// dependent on an attribute (e.g., Terraform module source)
 	Targets *Target
+
+	// ImpliedOrigins represent a list of origins we should revisit during
+	// reference origin collection. For example, module outputs can be
+	// referenced from still unknown locations during the build of the module
+	// schema.
+	ImpliedOrigins ImpliedOrigins
+}
+
+type ImpliedOrigins []ImpliedOrigin
+
+type ImpliedOrigin struct {
+	OriginAddress lang.Address
+
+	TargetAddress lang.Address
+	Path          lang.Path
+	Constraints   Constraints
+}
+
+func (io ImpliedOrigin) Copy() ImpliedOrigin {
+	return ImpliedOrigin{
+		OriginAddress: io.OriginAddress,
+		TargetAddress: io.TargetAddress,
+		Path:          io.Path,
+		Constraints:   io.Constraints,
+	}
 }
 
 type DocsLink struct {
@@ -170,6 +195,13 @@ func (bs *BodySchema) Copy() *BodySchema {
 		}
 	}
 
+	if bs.ImpliedOrigins != nil {
+		newBs.ImpliedOrigins = make(ImpliedOrigins, len(bs.ImpliedOrigins))
+		for id, impliedOrigin := range bs.ImpliedOrigins {
+			newBs.ImpliedOrigins[id] = impliedOrigin.Copy()
+		}
+	}
+
 	return newBs
 }