decoder: Enable validators to deal with unknown schema

decoder/internal/schemahelper/context.go

@@ -0,0 +1,26 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package schemahelper
+
+import "context"
+
+type unknownSchemaCtxKey struct{}
+
+// WithUnknownSchema attaches a flag indicating that the schema being passed
+// is not wholly known.
+func WithUnknownSchema(ctx context.Context) context.Context {
+	return context.WithValue(ctx, unknownSchemaCtxKey{}, true)
+}
+
+// HasUnknownSchema returns true if the schema being passed
+// is not wholly known. This allows each validator to decide
+// whether and how to validate the AST.
+func HasUnknownSchema(ctx context.Context) bool {
+	value := ctx.Value(unknownSchemaCtxKey{})
+	uSchema, ok := value.(bool)
+	if !ok {
+		return false
+	}
+	return uSchema
+}

decoder/internal/validator/attribute_unexpected.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/hashicorp/hcl-lang/decoder/internal/schemahelper"
 	"github.com/hashicorp/hcl-lang/schema"
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/hclsyntax"
@@ -15,6 +16,12 @@ import (
 type UnexpectedAttribute struct{}
 
 func (v UnexpectedAttribute) Visit(ctx context.Context, node hclsyntax.Node, nodeSchema schema.Schema) (diags hcl.Diagnostics) {
+	if schemahelper.HasUnknownSchema(ctx) {
+		// Avoid checking for unexpected attributes
+		// if we cannot tell which ones are expected.
+		return
+	}
+
 	attr, ok := node.(*hclsyntax.Attribute)
 	if !ok {
 		return

decoder/internal/validator/block_unexpected.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/hashicorp/hcl-lang/decoder/internal/schemahelper"
 	"github.com/hashicorp/hcl-lang/schema"
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/hclsyntax"
@@ -15,6 +16,12 @@ import (
 type UnexpectedBlock struct{}
 
 func (v UnexpectedBlock) Visit(ctx context.Context, node hclsyntax.Node, nodeSchema schema.Schema) (diags hcl.Diagnostics) {
+	if schemahelper.HasUnknownSchema(ctx) {
+		// Avoid checking for unexpected blocks
+		// if we cannot tell which ones are expected.
+		return
+	}
+
 	block, ok := node.(*hclsyntax.Block)
 	if !ok {
 		return

decoder/internal/walker/walker.go

@@ -70,7 +70,7 @@ func Walk(ctx context.Context, node hclsyntax.Node, nodeSchema schema.Schema, w
 		if ok && bSchema.Body != nil {
 			mergedSchema, ok := schemahelper.MergeBlockBodySchemas(nodeType.AsHCLBlock(), bSchema)
 			if !ok {
-				// TODO
+				ctx = schemahelper.WithUnknownSchema(ctx)
 			}
 			blockBodySchema = mergedSchema
 		}

decoder/validate_test.go

@@ -789,6 +789,117 @@ wakka = 2
 			}`,
 			map[string]hcl.Diagnostics{},
 		},
+		{
+			"missing dependent body",
+			// Eventually this should be a warning diagnostic but it's not appropriate yet
+			// At least in Terraform we don't yet have a way of easily addressing
+			// missing provider schemas (which are represented as dependent bodies).
+			&schema.BodySchema{
+				Blocks: map[string]*schema.BlockSchema{
+					"resource": {
+						Body: &schema.BodySchema{
+							Attributes: map[string]*schema.AttributeSchema{
+								"depends_on": {
+									IsOptional: true,
+									Constraint: schema.LiteralType{Type: cty.List(cty.String)},
+								},
+							},
+						},
+						Labels: []*schema.LabelSchema{
+							{
+								Name:     "key",
+								IsDepKey: true,
+							},
+						},
+						DependentBody: map[schema.SchemaKey]*schema.BodySchema{
+							schema.NewSchemaKey(schema.DependencyKeys{
+								Labels: []schema.LabelDependent{
+									{Index: 0, Value: "aws_instance"},
+								},
+							}): {
+								Attributes: map[string]*schema.AttributeSchema{
+									"size": {
+										IsOptional: true,
+										Constraint: schema.LiteralType{Type: cty.Number},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			`resource "google_instance" {
+				size = 42
+				moot = "moot"
+				depends_on = []
+			}
+			resource "aws_instance" {
+				size = 42
+				toot = "toot"
+				depends_on = []
+			}`,
+			map[string]hcl.Diagnostics{
+				"test.tf": {
+					&hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Unexpected attribute",
+						Detail:   `An attribute named "toot" is not expected here`,
+						Subject: &hcl.Range{
+							Filename: "test.tf",
+							Start:    hcl.Pos{Line: 8, Column: 5, Byte: 133},
+							End:      hcl.Pos{Line: 8, Column: 18, Byte: 146},
+						},
+					},
+				},
+			},
+		},
+		{
+			"missing dependent body with deprecated static attribute",
+			// Eventually this should be a warning diagnostic but it's not appropriate yet
+			// At least in Terraform we don't yet have a way of easily addressing
+			// missing provider schemas (which are represented as dependent bodies).
+			&schema.BodySchema{
+				Blocks: map[string]*schema.BlockSchema{
+					"resource": {
+						Body: &schema.BodySchema{
+							Attributes: map[string]*schema.AttributeSchema{
+								"depends_on": {
+									IsOptional:   true,
+									IsDeprecated: true,
+									Constraint:   schema.LiteralType{Type: cty.List(cty.String)},
+								},
+							},
+						},
+						Labels: []*schema.LabelSchema{
+							{
+								Name:     "key",
+								IsDepKey: true,
+							},
+						},
+						DependentBody: map[schema.SchemaKey]*schema.BodySchema{},
+					},
+				},
+			},
+			`resource "google_instance" {
+				size = 42
+				moot = "moot"
+				depends_on = []
+			}`,
+			map[string]hcl.Diagnostics{
+				"test.tf": {
+					&hcl.Diagnostic{
+						Severity: hcl.DiagWarning,
+						Summary:  `"depends_on" is deprecated`,
+						Detail:   `Reason: ""`,
+						Subject: &hcl.Range{
+							Filename: "test.tf",
+							Start:    hcl.Pos{Line: 4, Column: 5, Byte: 65},
+							End:      hcl.Pos{Line: 4, Column: 20, Byte: 80},
+						},
+					},
+				},
+			},
+		},
 	}
 
 	for i, tc := range testCases {