hclsyntax: TemplateExpr can refine its unknown results

If we encounter an interpolated unknown value during template rendering,
we can report the partial buffer we've completed so far as the refined
prefix of the resulting unknown value, which can then potentially allow
downstream comparisons to produce a known false result instead of unknown
if the prefix is sufficient to satisfy them.

Author: apparentlymart

hclsyntax/expression_template.go

@@ -38,11 +38,9 @@ func (e *TemplateExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics)
 
 		if partVal.IsNull() {
 			diags = append(diags, &hcl.Diagnostic{
-				Severity: hcl.DiagError,
-				Summary:  "Invalid template interpolation value",
-				Detail: fmt.Sprintf(
-					"The expression result is null. Cannot include a null value in a string template.",
-				),
+				Severity:    hcl.DiagError,
+				Summary:     "Invalid template interpolation value",
+				Detail:      "The expression result is null. Cannot include a null value in a string template.",
 				Subject:     part.Range().Ptr(),
 				Context:     &e.SrcRange,
 				Expression:  part,
@@ -83,16 +81,29 @@ func (e *TemplateExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics)
 			continue
 		}
 
-		buf.WriteString(strVal.AsString())
+		// If we're just continuing to validate after we found an unknown value
+		// then we'll skip appending so that "buf" will contain only the
+		// known prefix of the result.
+		if isKnown && !diags.HasErrors() {
+			buf.WriteString(strVal.AsString())
+		}
 	}
 
 	var ret cty.Value
 	if !isKnown {
 		ret = cty.UnknownVal(cty.String)
+		if !diags.HasErrors() { // Invalid input means our partial result buffer is suspect
+			if knownPrefix := buf.String(); knownPrefix != "" {
+				ret = ret.Refine().StringPrefix(knownPrefix).NewValue()
+			}
+		}
 	} else {
 		ret = cty.StringVal(buf.String())
 	}
 
+	// A template rendering result is never null.
+	ret = ret.RefineNotNull()
+
 	// Apply the full set of marks to the returned value
 	return ret.WithMarks(marks), diags
 }

hclsyntax/expression_template_test.go

@@ -177,7 +177,7 @@ trim`,
 		{
 			`%{ of true ~} hello %{~ endif}`,
 			nil,
-			cty.UnknownVal(cty.String),
+			cty.UnknownVal(cty.String).RefineNotNull(),
 			2, // "of" is not a valid control keyword, and "endif" is therefore also unexpected
 		},
 		{
@@ -277,15 +277,36 @@ trim`,
 		{
 			`%{ endif }`,
 			nil,
-			cty.UnknownVal(cty.String),
+			cty.UnknownVal(cty.String).RefineNotNull(),
 			1, // Unexpected endif directive
 		},
 		{
 			`%{ endfor }`,
 			nil,
-			cty.UnknownVal(cty.String),
+			cty.UnknownVal(cty.String).RefineNotNull(),
 			1, // Unexpected endfor directive
 		},
+		{ // can preserve a static prefix as a refinement of an unknown result
+			`test_${unknown}`,
+			&hcl.EvalContext{
+				Variables: map[string]cty.Value{
+					"unknown": cty.UnknownVal(cty.String),
+				},
+			},
+			cty.UnknownVal(cty.String).Refine().NotNull().StringPrefixFull("test_").NewValue(),
+			0,
+		},
+		{ // can preserve a dynamic known prefix as a refinement of an unknown result
+			`test_${known}_${unknown}`,
+			&hcl.EvalContext{
+				Variables: map[string]cty.Value{
+					"known":   cty.StringVal("known"),
+					"unknown": cty.UnknownVal(cty.String),
+				},
+			},
+			cty.UnknownVal(cty.String).Refine().NotNull().StringPrefixFull("test_known_").NewValue(),
+			0,
+		},
 		{ // marks from uninterpolated values are ignored
 			`hello%{ if false } ${target}%{ endif }`,
 			&hcl.EvalContext{
@@ -368,7 +389,7 @@ trim`,
 					"target": cty.UnknownVal(cty.String).Mark("sensitive"),
 				},
 			},
-			cty.UnknownVal(cty.String).Mark("sensitive"),
+			cty.UnknownVal(cty.String).Mark("sensitive").Refine().NotNull().StringPrefixFull("test_").NewValue(),
 			0,
 		},
 	}
@@ -377,7 +398,14 @@ trim`,
 		t.Run(test.input, func(t *testing.T) {
 			expr, parseDiags := ParseTemplate([]byte(test.input), "", hcl.Pos{Line: 1, Column: 1, Byte: 0})
 
-			got, valDiags := expr.Value(test.ctx)
+			// We'll skip evaluating if there were parse errors because it
+			// isn't reasonable to evaluate a syntactically-invalid template;
+			// it'll produce strange results that we don't care about.
+			got := test.want
+			var valDiags hcl.Diagnostics
+			if !parseDiags.HasErrors() {
+				got, valDiags = expr.Value(test.ctx)
+			}
 
 			diagCount := len(parseDiags) + len(valDiags)
 

json/structure_test.go

@@ -1433,7 +1433,7 @@ func TestExpressionValue_Diags(t *testing.T) {
 		{
 			name:     "string: unhappy",
 			src:      `{"v": "happy ${UNKNOWN}"}`,
-			expected: cty.UnknownVal(cty.String),
+			expected: cty.UnknownVal(cty.String).RefineNotNull(),
 			error:    "Unknown variable",
 		},
 		{
@@ -1447,7 +1447,7 @@ func TestExpressionValue_Diags(t *testing.T) {
 			name: "object_val: unhappy",
 			src:  `{"v": {"key": "happy ${UNKNOWN}"}}`,
 			expected: cty.ObjectVal(map[string]cty.Value{
-				"key": cty.UnknownVal(cty.String),
+				"key": cty.UnknownVal(cty.String).RefineNotNull(),
 			}),
 			error: "Unknown variable",
 		},
@@ -1472,7 +1472,7 @@ func TestExpressionValue_Diags(t *testing.T) {
 		{
 			name:     "array: unhappy",
 			src:      `{"v": ["happy ${UNKNOWN}"]}`,
-			expected: cty.TupleVal([]cty.Value{cty.UnknownVal(cty.String)}),
+			expected: cty.TupleVal([]cty.Value{cty.UnknownVal(cty.String).RefineNotNull()}),
 			error:    "Unknown variable",
 		},
 	}