Adding support for dynamic providers

Signed-off-by: Diogenes Fernandes <[email protected]>

Author: diofeher

opentofu/opentofu.go

@@ -1,11 +1,16 @@
 package opentofu
 
 import (
+	"fmt"
+
 	"github.com/hashicorp/go-version"
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/gohcl"
 	"github.com/hashicorp/hcl/v2/hclsyntax"
+	hcljson "github.com/hashicorp/hcl/v2/json"
+	regaddr "github.com/opentofu/registry-address"
 	"github.com/terraform-linters/tflint-plugin-sdk/hclext"
+	"github.com/zclconf/go-cty/cty"
 )
 
 // ModuleCall represents a "module" block.
@@ -66,26 +71,208 @@ type Local struct {
 
 // ProviderRef represents a reference to a provider like `provider = google.europe` in a resource or module.
 type ProviderRef struct {
-	Name     string
-	DefRange hcl.Range
+	Name          string
+	Alias         string
+	AliasRange    *hcl.Range
+	KeyExpression hcl.Expression
+	DefRange      hcl.Range
 }
 
-// @see https://github.com/hashicorp/terraform/blob/v1.2.7/internal/configs/resource.go#L624-L695
-func decodeProviderRef(expr hcl.Expression, defRange hcl.Range) (*ProviderRef, hcl.Diagnostics) {
-	expr, diags := shimTraversalInString(expr)
+func ExprIsNativeQuotedString(expr hcl.Expression) bool {
+	_, ok := expr.(*hclsyntax.TemplateExpr)
+	return ok
+}
+
+func IsProviderPartNormalized(str string) (bool, error) {
+	normalized, err := regaddr.ParseProviderPart(str)
+	if err != nil {
+		return false, err
+	}
+	if str == normalized {
+		return true, nil
+	}
+	return false, nil
+}
+
+func checkProviderNameNormalized(name string, declrange hcl.Range) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+	// verify that the provider local name is normalized
+	normalized, err := IsProviderPartNormalized(name)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid provider local name",
+			Detail:   fmt.Sprintf("%s is an invalid provider local name: %s", name, err),
+			Subject:  &declrange,
+		})
+		return diags
+	}
+	if !normalized {
+		// we would have returned this error already
+		normalizedProvider, _ := regaddr.ParseProviderPart(name)
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid provider local name",
+			Detail:   fmt.Sprintf("Provider names must be normalized. Replace %q with %q to fix this error.", name, normalizedProvider),
+			Subject:  &declrange,
+		})
+	}
+	return diags
+}
+
+func ConvertJSONExpressionToHCL(expr hcl.Expression) (hcl.Expression, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	// We can abuse the hcl json api and rely on the fact that calling
+	// Value on a json expression with no EvalContext will return the
+	// raw string. We can then parse that as normal hcl syntax, and
+	// continue with the decoding.
+	value, ds := expr.Value(nil)
+	diags = append(diags, ds...)
 	if diags.HasErrors() {
 		return nil, diags
 	}
 
-	traversal, diags := hcl.AbsTraversalForExpr(expr)
+	if value.Type() != cty.String || value.IsNull() {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Expected string expression",
+			Detail:   fmt.Sprintf("This value must be a string, but got %s.", value.Type().FriendlyName()),
+			Subject:  expr.Range().Ptr(),
+		})
+		return nil, diags
+	}
+
+	expr, ds = hclsyntax.ParseExpression([]byte(value.AsString()), expr.Range().Filename, expr.Range().Start)
+	diags = append(diags, ds...)
+	if diags.HasErrors() {
+		return nil, diags
+	}
+
+	return expr, diags
+}
+
+// @see https://github.com/opentofu/opentofu/blob/3258c673194ecba26d856fb825d4eb4a7e36ab34/internal/configs/resource.go#L903
+func decodeProviderRef(expr hcl.Expression, defRange hcl.Range) (*ProviderRef, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	var keyExpr hcl.Expression
+	const (
+		// name.alias[const_key]
+		nameIndex  = 0
+		aliasIndex = 1
+		keyIndex   = 2
+	)
+
+	var maxTraversalLength = keyIndex + 1
+
+	if ok := hcljson.IsJSONExpression(expr); ok {
+		expr, diags = ConvertJSONExpressionToHCL(expr)
+		if diags.HasErrors() {
+			return nil, diags
+		}
+	}
+
+	// name.alias[expr_key]
+	if iex, ok := expr.(*hclsyntax.IndexExpr); ok {
+		maxTraversalLength = aliasIndex + 1 // expr key found, no const key allowed
+
+		keyExpr = iex.Key
+		expr = iex.Collection
+	}
+
+	var shimDiags hcl.Diagnostics
+	expr, shimDiags = shimTraversalInString(expr)
+	diags = append(diags, shimDiags...)
+
+	traversal, travDiags := hcl.AbsTraversalForExpr(expr)
+
+	// AbsTraversalForExpr produces only generic errors, so we'll discard
+	// the errors given and produce our own with extra context. If we didn't
+	// get any errors then we might still have warnings, though.
+	if !travDiags.HasErrors() {
+		diags = append(diags, travDiags...)
+	}
+
+	if len(traversal) == 0 || len(traversal) > maxTraversalLength {
+		// A provider reference was given as a string literal in the legacy
+		// configuration language and there are lots of examples out there
+		// showing that usage, so we'll sniff for that situation here and
+		// produce a specialized error message for it to help users find
+		// the new correct form.
+		if ExprIsNativeQuotedString(expr) {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid provider configuration reference",
+				Detail:   "A provider configuration reference must not be given in quotes.",
+				Subject:  expr.Range().Ptr(),
+			})
+			return nil, diags
+		}
+
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid provider configuration reference",
+			Detail:   fmt.Sprintf("The provider argument requires a provider type name, optionally followed by a period and then a configuration alias and optional instance key."),
+			Subject:  expr.Range().Ptr(),
+		})
+		return nil, diags
+	}
+
+	// verify that the provider local name is normalized
+	name := traversal.RootName()
+	nameDiags := checkProviderNameNormalized(name, traversal[nameIndex].SourceRange())
+	diags = append(diags, nameDiags...)
 	if diags.HasErrors() {
 		return nil, diags
 	}
 
-	return &ProviderRef{
-		Name:     traversal.RootName(),
-		DefRange: defRange,
-	}, nil
+	ret := &ProviderRef{
+		Name:          traversal.RootName(),
+		DefRange:      defRange,
+		KeyExpression: keyExpr,
+		AliasRange:    nil,
+	}
+
+	if len(traversal) > aliasIndex {
+		aliasStep, ok := traversal[aliasIndex].(hcl.TraverseAttr)
+		if !ok {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid provider configuration reference",
+				Detail:   "Provider name must either stand alone or be followed by a period and then a configuration alias.",
+				Subject:  traversal[aliasIndex].SourceRange().Ptr(),
+			})
+			return ret, diags
+		}
+
+		ret.Alias = aliasStep.Name
+		ret.AliasRange = aliasStep.SourceRange().Ptr()
+	}
+
+	if len(traversal) > keyIndex {
+		indexStep, ok := traversal[keyIndex].(hcl.TraverseIndex)
+		if !ok {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid provider configuration reference",
+				Detail:   "Provider name must either stand alone or be followed by a period and then a configuration alias.",
+				Subject:  traversal[keyIndex].SourceRange().Ptr(),
+			})
+			return ret, diags
+		}
+
+		ret.KeyExpression = hcl.StaticExpr(indexStep.Key, traversal.SourceRange())
+	}
+
+	if len(ret.Alias) == 0 && ret.KeyExpression != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid provider configuration reference",
+			Detail:   "Provider assignment requires an alias when specifying an instance key, in the form of provider.name[instance_key]",
+			Subject:  traversal.SourceRange().Ptr(),
+		})
+	}
+
+	return ret, nil
 }
 
 // @see https://github.com/hashicorp/terraform/blob/v1.2.5/internal/configs/compat_shim.go#L34

opentofu/runner.go

@@ -230,6 +230,7 @@ func (r *Runner) GetProviderRefs() (map[string]*ProviderRef, hcl.Diagnostics) {
 			for _, data := range block.Body.Blocks {
 				if attr, exists := data.Body.Attributes["provider"]; exists {
 					ref, decodeDiags := decodeProviderRef(attr.Expr, data.DefRange)
+
 					diags = diags.Extend(decodeDiags)
 					if decodeDiags.HasErrors() {
 						continue

rules/opentofu_required_providers.go

@@ -18,7 +18,7 @@ type OpentofuRequiredProvidersRule struct {
 	tflint.DefaultRule
 }
 
-type terraformRequiredProvidersRuleConfig struct {
+type opentofuRequiredProvidersRuleConfig struct {
 	// Source specifies whether the rule should assert the presence of a `source` attribute
 	Source *bool `hclext:"source,optional"`
 	// Version specifies whether the rule should assert the presence of a `version` attribute
@@ -51,8 +51,8 @@ func (r *OpentofuRequiredProvidersRule) Link() string {
 }
 
 // config returns the rule config, with defaults
-func (r *OpentofuRequiredProvidersRule) config(runner tflint.Runner) (*terraformRequiredProvidersRuleConfig, error) {
-	config := &terraformRequiredProvidersRuleConfig{}
+func (r *OpentofuRequiredProvidersRule) config(runner tflint.Runner) (*opentofuRequiredProvidersRuleConfig, error) {
+	config := &opentofuRequiredProvidersRuleConfig{}
 
 	if err := runner.DecodeRuleConfig(r.Name(), config); err != nil {
 		return nil, err
@@ -107,12 +107,12 @@ func (r *OpentofuRequiredProvidersRule) Check(rr tflint.Runner) error {
 
 	for _, provider := range body.Blocks {
 		if _, exists := provider.Body.Attributes["version"]; exists {
-			if err := runner.EmitIssue(
+			if runErr := runner.EmitIssue(
 				r,
 				"provider version constraint should be specified via `required_providers`",
 				provider.DefRange,
 			); err != nil {
-				return err
+				return runErr
 			}
 		}
 	}
@@ -214,6 +214,7 @@ func (r *OpentofuRequiredProvidersRule) Check(rr tflint.Runner) error {
 
 		if source, exists := vm["source"]; exists {
 			p, err := tfaddr.ParseProviderSource(source.AsString())
+
 			if err != nil {
 				return err
 			}