rename internal to pkg

.gitignore

@@ -3,7 +3,6 @@
 .DS_Store
 bin/
 modules-dev/
-/pkg/
 website/.vagrant
 website/.bundle
 website/build

pkg/addrs/check.go

@@ -0,0 +1,136 @@
+// Copyright (c) The OpenTofu Authors
+// SPDX-License-Identifier: MPL-2.0
+// Copyright (c) 2023 HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package addrs
+
+import "fmt"
+
+// Check is the address of a check block within a module.
+//
+// For now, checks do not support meta arguments such as "count" or "for_each"
+// so this address uniquely describes a single check within a module.
+type Check struct {
+	referenceable
+	Name string
+}
+
+func (c Check) String() string {
+	return fmt.Sprintf("check.%s", c.Name)
+}
+
+// InModule returns a ConfigCheck from the receiver and the given module
+// address.
+func (c Check) InModule(modAddr Module) ConfigCheck {
+	return ConfigCheck{
+		Module: modAddr,
+		Check:  c,
+	}
+}
+
+// Absolute returns an AbsCheck from the receiver and the given module instance
+// address.
+func (c Check) Absolute(modAddr ModuleInstance) AbsCheck {
+	return AbsCheck{
+		Module: modAddr,
+		Check:  c,
+	}
+}
+
+func (c Check) Equal(o Check) bool {
+	return c.Name == o.Name
+}
+
+func (c Check) UniqueKey() UniqueKey {
+	return c // A Check is its own UniqueKey
+}
+
+func (c Check) uniqueKeySigil() {}
+
+// ConfigCheck is an address for a check block within a configuration.
+//
+// This contains a Check address and a Module address, meaning this describes
+// a check block within the entire configuration.
+type ConfigCheck struct {
+	Module Module
+	Check  Check
+}
+
+var _ ConfigCheckable = ConfigCheck{}
+
+func (c ConfigCheck) UniqueKey() UniqueKey {
+	return configCheckUniqueKey(c.String())
+}
+
+func (c ConfigCheck) configCheckableSigil() {}
+
+func (c ConfigCheck) CheckableKind() CheckableKind {
+	return CheckableCheck
+}
+
+func (c ConfigCheck) String() string {
+	if len(c.Module) == 0 {
+		return c.Check.String()
+	}
+	return fmt.Sprintf("%s.%s", c.Module, c.Check)
+}
+
+// AbsCheck is an absolute address for a check block under a given module path.
+//
+// This contains an actual ModuleInstance address (compared to the Module within
+// a ConfigCheck), meaning this uniquely describes a check block within the
+// entire configuration after any "count" or "foreach" meta arguments have been
+// evaluated on the containing module.
+type AbsCheck struct {
+	Module ModuleInstance
+	Check  Check
+}
+
+var _ Checkable = AbsCheck{}
+
+func (c AbsCheck) UniqueKey() UniqueKey {
+	return absCheckUniqueKey(c.String())
+}
+
+func (c AbsCheck) checkableSigil() {}
+
+// CheckRule returns an address for a given rule type within the check block.
+//
+// There will be at most one CheckDataResource rule within a check block (with
+// an index of 0). There will be at least one, but potentially many,
+// CheckAssertion rules within a check block.
+func (c AbsCheck) CheckRule(typ CheckRuleType, i int) CheckRule {
+	return CheckRule{
+		Container: c,
+		Type:      typ,
+		Index:     i,
+	}
+}
+
+// ConfigCheckable returns the ConfigCheck address for this absolute reference.
+func (c AbsCheck) ConfigCheckable() ConfigCheckable {
+	return ConfigCheck{
+		Module: c.Module.Module(),
+		Check:  c.Check,
+	}
+}
+
+func (c AbsCheck) CheckableKind() CheckableKind {
+	return CheckableCheck
+}
+
+func (c AbsCheck) String() string {
+	if len(c.Module) == 0 {
+		return c.Check.String()
+	}
+	return fmt.Sprintf("%s.%s", c.Module, c.Check)
+}
+
+type configCheckUniqueKey string
+
+func (k configCheckUniqueKey) uniqueKeySigil() {}
+
+type absCheckUniqueKey string
+
+func (k absCheckUniqueKey) uniqueKeySigil() {}

pkg/addrs/check_rule.go

@@ -0,0 +1,119 @@
+// Copyright (c) The OpenTofu Authors
+// SPDX-License-Identifier: MPL-2.0
+// Copyright (c) 2023 HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package addrs
+
+import (
+	"fmt"
+)
+
+// CheckRule is the address of a check rule within a checkable object.
+//
+// This represents the check rule globally within a configuration, and is used
+// during graph evaluation to identify a condition result object to update with
+// the result of check rule evaluation.
+//
+// The check address is not distinct from resource traversals, and check rule
+// values are not intended to be available to the language, so the address is
+// not Referenceable.
+//
+// Note also that the check address is only relevant within the scope of a run,
+// as reordering check blocks between runs will result in their addresses
+// changing. CheckRule is therefore for internal use only and should not be
+// exposed in durable artifacts such as state snapshots.
+type CheckRule struct {
+	Container Checkable
+	Type      CheckRuleType
+	Index     int
+}
+
+func NewCheckRule(container Checkable, typ CheckRuleType, index int) CheckRule {
+	return CheckRule{
+		Container: container,
+		Type:      typ,
+		Index:     index,
+	}
+}
+
+func (c CheckRule) String() string {
+	container := c.Container.String()
+	switch c.Type {
+	case ResourcePrecondition:
+		return fmt.Sprintf("%s.precondition[%d]", container, c.Index)
+	case ResourcePostcondition:
+		return fmt.Sprintf("%s.postcondition[%d]", container, c.Index)
+	case OutputPrecondition:
+		return fmt.Sprintf("%s.precondition[%d]", container, c.Index)
+	case CheckDataResource:
+		return fmt.Sprintf("%s.data[%d]", container, c.Index)
+	case CheckAssertion:
+		return fmt.Sprintf("%s.assert[%d]", container, c.Index)
+	case InputValidation:
+		return fmt.Sprintf("%s.validation[%d]", container, c.Index)
+	default:
+		// This should not happen
+		return fmt.Sprintf("%s.condition[%d]", container, c.Index)
+	}
+}
+
+func (c CheckRule) UniqueKey() UniqueKey {
+	return checkRuleKey{
+		ContainerKey: c.Container.UniqueKey(),
+		Type:         c.Type,
+		Index:        c.Index,
+	}
+}
+
+type checkRuleKey struct {
+	ContainerKey UniqueKey
+	Type         CheckRuleType
+	Index        int
+}
+
+func (k checkRuleKey) uniqueKeySigil() {}
+
+// CheckRuleType describes a category of check. We use this only to establish
+// uniqueness for Check values, and do not expose this concept of "check types"
+// (which is subject to change in future) in any durable artifacts such as
+// state snapshots.
+//
+// (See [CheckableKind] for an enumeration that we _do_ use externally, to
+// describe the type of object being checked rather than the type of the check
+// itself.)
+type CheckRuleType int
+
+//go:generate go run golang.org/x/tools/cmd/stringer -type=CheckRuleType check_rule.go
+
+const (
+	InvalidCondition      CheckRuleType = 0
+	ResourcePrecondition  CheckRuleType = 1
+	ResourcePostcondition CheckRuleType = 2
+	OutputPrecondition    CheckRuleType = 3
+	CheckDataResource     CheckRuleType = 4
+	CheckAssertion        CheckRuleType = 5
+	InputValidation       CheckRuleType = 6
+)
+
+// Description returns a human-readable description of the check type. This is
+// presented in the user interface through a diagnostic summary.
+func (c CheckRuleType) Description() string {
+	switch c {
+	case ResourcePrecondition:
+		return "Resource precondition"
+	case ResourcePostcondition:
+		return "Resource postcondition"
+	case OutputPrecondition:
+		return "Module output value precondition"
+	case CheckDataResource:
+		return "Check block data resource"
+	case CheckAssertion:
+		return "Check block assertion"
+	case InputValidation:
+		return "Input variable validation"
+	default:
+		// This should not happen
+		return "Condition"
+	}
+}

pkg/addrs/check_rule_diagnostic.go

@@ -0,0 +1,75 @@
+// Copyright (c) The OpenTofu Authors
+// SPDX-License-Identifier: MPL-2.0
+// Copyright (c) 2023 HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package addrs
+
+import "github.com/kubegems/opentofu/pkg/tfdiags"
+
+// DiagnosticExtraCheckRule provides an interface for diagnostic ExtraInfo to
+// retrieve an embedded CheckRule from within a tfdiags.Diagnostic.
+type DiagnosticExtraCheckRule interface {
+	// DiagnosticOriginatesFromCheckRule returns the CheckRule that the
+	// surrounding diagnostic originated from.
+	DiagnosticOriginatesFromCheckRule() CheckRule
+}
+
+// DiagnosticOriginatesFromCheckRule checks if the provided diagnostic contains
+// a CheckRule as ExtraInfo and returns that CheckRule and true if it does. This
+// function returns an empty CheckRule and false if the diagnostic does not
+// contain a CheckRule.
+func DiagnosticOriginatesFromCheckRule(diag tfdiags.Diagnostic) (CheckRule, bool) {
+	maybe := tfdiags.ExtraInfo[DiagnosticExtraCheckRule](diag)
+	if maybe == nil {
+		return CheckRule{}, false
+	}
+	return maybe.DiagnosticOriginatesFromCheckRule(), true
+}
+
+// CheckRuleDiagnosticExtra is an object that can be attached to diagnostics
+// that originate from check rules.
+//
+// It implements the DiagnosticExtraCheckRule interface for retrieving the
+// concrete CheckRule that spawned the diagnostic.
+//
+// It also implements the tfdiags.DiagnosticExtraDoNotConsolidate interface, to
+// stop diagnostics created by check blocks being consolidated.
+//
+// It also implements the tfdiags.DiagnosticExtraUnwrapper interface, as nested
+// data blocks will attach this struct but do want to lose any extra info
+// embedded in the original diagnostic.
+type CheckRuleDiagnosticExtra struct {
+	CheckRule CheckRule
+
+	wrapped interface{}
+}
+
+var (
+	_ DiagnosticExtraCheckRule                = (*CheckRuleDiagnosticExtra)(nil)
+	_ tfdiags.DiagnosticExtraDoNotConsolidate = (*CheckRuleDiagnosticExtra)(nil)
+	_ tfdiags.DiagnosticExtraUnwrapper        = (*CheckRuleDiagnosticExtra)(nil)
+	_ tfdiags.DiagnosticExtraWrapper          = (*CheckRuleDiagnosticExtra)(nil)
+)
+
+func (c *CheckRuleDiagnosticExtra) UnwrapDiagnosticExtra() interface{} {
+	return c.wrapped
+}
+
+func (c *CheckRuleDiagnosticExtra) WrapDiagnosticExtra(inner interface{}) {
+	if c.wrapped != nil {
+		// This is a logical inconsistency, the caller should know whether they
+		// have already wrapped an extra or not.
+		panic("Attempted to wrap a diagnostic extra into a CheckRuleDiagnosticExtra that is already wrapping a different extra. This is a bug in OpenTofu, please report it.")
+	}
+	c.wrapped = inner
+}
+
+func (c *CheckRuleDiagnosticExtra) DoNotConsolidateDiagnostic() bool {
+	// Do not consolidate warnings from check blocks.
+	return c.CheckRule.Container.CheckableKind() == CheckableCheck
+}
+
+func (c *CheckRuleDiagnosticExtra) DiagnosticOriginatesFromCheckRule() CheckRule {
+	return c.CheckRule
+}