reference

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
}

type LocalOrigin struct {
	// Addr describes the resolved address of the reference
	Addr lang.Address

	// Range represents the range of the traversal
	Range hcl.Range

	// Constraints represents any traversal expression constraints
	// for the attribute where the origin was found.
	//
	// Further matching against decoded reference targets is needed
	// for >1 constraints, which is done later at runtime as
	// targets and origins can be decoded at different times.
	Constraints OriginConstraints
}

type MatchableOrigin interface {
	Origin
	OriginConstraints() OriginConstraints
	AppendConstraints(OriginConstraints) MatchableOrigin
	Address() lang.Address
}

type NoOriginFound struct{}

type NoTargetFound struct{}

type Origin interface {
	Copy() Origin
	OriginRange() hcl.Range
	// contains filtered or unexported methods
}

type OriginConstraint struct {
	OfScopeId lang.ScopeId
	OfType    cty.Type
}

type OriginConstraints []OriginConstraint

type Origins []Origin

type PathOrigin struct {
	// Range represents a range of a local traversal or an attribute
	Range hcl.Range

	// TargetAddr describes the address of the targeted attribute or block
	TargetAddr lang.Address

	// TargetPath represents what Path does the origin target
	TargetPath lang.Path

	// Constraints represent any constraints to use when filtering
	// the targets within the destination Path
	Constraints OriginConstraints
}

type Target struct {
	// Addr represents the address of the target, as available
	// elsewhere in the configuration
	Addr lang.Address

	// LocalAddr represents the address of the target
	// as available *locally* (e.g. self.attr_name)
	LocalAddr lang.Address

	// TargetableFromRangePtr defines where the target is targetable from.
	// This is considered when matching the target against origin.
	//
	// e.g. count.index is only available within the body of the block
	// where count is declared (and extension enabled)
	TargetableFromRangePtr *hcl.Range

	// ScopeId provides scope for matching/filtering
	// (in addition to Type & Addr/LocalAddr).
	//
	// There should never be two targets with the same Type & address,
	// but there are contexts (e.g. completion) where we don't filter
	// by address and may not have type either (e.g. because targets
	// are type-unaware).
	ScopeId lang.ScopeId

	// RangePtr represents range of the whole attribute or block
	// or nil if the target is not addressable.
	RangePtr *hcl.Range

	// DefRangePtr represents a definition range, i.e. block header,
	// or an attribute name or nil if the target is not addressable
	// or when it represents multiple list, set or map blocks.
	//
	// This is useful in situation where a representative single-line
	// range is needed - e.g. to render a contextual UI element in
	// the editor near the middle of this range.
	DefRangePtr *hcl.Range

	Type        cty.Type
	Name        string
	Description lang.MarkupContent

	NestedTargets Targets
}

type TargetWalkFunc func(Target) error

type Targets []Target