Update valueshim to handle DynamicPseudoType

Author: t0yv0

pkg/valueshim/convert.go

@@ -0,0 +1,41 @@
+// Copyright 2016-2025, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package valueshim
+
+import (
+	"encoding/json"
+
+	"github.com/hashicorp/go-cty/cty"
+	ctyjson "github.com/hashicorp/go-cty/cty/json"
+	ctymsgpack "github.com/hashicorp/go-cty/cty/msgpack"
+	"github.com/hashicorp/terraform-plugin-go/tfprotov6"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+)
+
+func toCtyType(t tftypes.Type) (cty.Type, error) {
+	typeBytes, err := json.Marshal(t)
+	if err != nil {
+		return cty.NilType, err
+	}
+	return ctyjson.UnmarshalType(typeBytes)
+}
+
+func toCtyValue(schemaType tftypes.Type, schemaCtyType cty.Type, value tftypes.Value) (cty.Value, error) {
+	dv, err := tfprotov6.NewDynamicValue(schemaType, value)
+	if err != nil {
+		return cty.NilVal, err
+	}
+	return ctymsgpack.Unmarshal(dv.MsgPack, schemaCtyType)
+}

pkg/valueshim/cty.go

@@ -16,6 +16,7 @@ package valueshim
 
 import (
 	"encoding/json"
+	"fmt"
 
 	"github.com/hashicorp/go-cty/cty"
 	ctyjson "github.com/hashicorp/go-cty/cty/json"
@@ -97,18 +98,24 @@ func (v ctyValueShim) Remove(key string) Value {
 	}
 }
 
-func (v ctyValueShim) Marshal() (json.RawMessage, error) {
+func (v ctyValueShim) Marshal(schemaType Type) (json.RawMessage, error) {
 	vv := v.val()
-	raw, err := ctyjson.Marshal(vv, vv.Type())
+	tt, ok := schemaType.(ctyTypeShim)
+	if !ok {
+		return nil, fmt.Errorf("Cannot marshal to RawState: "+
+			"expected schemaType to be of type ctyTypeShim, got %#T",
+			schemaType)
+	}
+	raw, err := ctyjson.Marshal(vv, tt.ty())
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("Cannot marshal to RawState: %w", err)
 	}
 	return json.RawMessage(raw), nil
 }
 
 type ctyTypeShim cty.Type
 
-var _ Type = (*ctyTypeShim)(nil)
+var _ Type = ctyTypeShim{}
 
 func (t ctyTypeShim) ty() cty.Type {
 	return cty.Type(t)

pkg/valueshim/cty_test.go

@@ -109,8 +109,10 @@ func Test_HCtyValue_Marshal(t *testing.T) {
 	tupType := cty.Tuple([]cty.Type{cty.String, cty.Number})
 
 	type testCase struct {
-		v      cty.Value
-		expect autogold.Value
+		v             cty.Value
+		expect        autogold.Value
+		schemaType    cty.Type
+		hasSchemaType bool
 	}
 
 	testCases := []testCase{
@@ -210,10 +212,51 @@ func Test_HCtyValue_Marshal(t *testing.T) {
 			v:      cty.TupleVal([]cty.Value{ok, n42}),
 			expect: autogold.Expect(`["OK",42]`),
 		},
+		{
+			v:             cty.NullVal(cty.String),
+			schemaType:    cty.DynamicPseudoType,
+			hasSchemaType: true,
+			expect:        autogold.Expect(`{"value":null,"type":"string"}`),
+		},
+		{
+			v:             cty.StringVal("foo"),
+			schemaType:    cty.DynamicPseudoType,
+			hasSchemaType: true,
+			expect:        autogold.Expect(`{"value":"foo","type":"string"}`),
+		},
+		{
+			v:             cty.NumberIntVal(42),
+			schemaType:    cty.DynamicPseudoType,
+			hasSchemaType: true,
+			expect:        autogold.Expect(`{"value":42,"type":"number"}`),
+		},
+		{
+			v:             cty.BoolVal(true),
+			schemaType:    cty.DynamicPseudoType,
+			hasSchemaType: true,
+			expect:        autogold.Expect(`{"value":true,"type":"bool"}`),
+		},
+		{
+			v:             cty.ListVal([]cty.Value{cty.StringVal("A")}),
+			schemaType:    cty.DynamicPseudoType,
+			hasSchemaType: true,
+			expect:        autogold.Expect(`{"value":["A"],"type":["list","string"]}`),
+		},
+		{
+			v:             cty.MapVal(map[string]cty.Value{"x": ok, "y": ok2}),
+			schemaType:    cty.DynamicPseudoType,
+			hasSchemaType: true,
+			expect:        autogold.Expect(`{"value":{"x":"OK","y":"OK2"},"type":["map","string"]}`),
+		},
 	}
 
 	for _, tc := range testCases {
-		raw, err := valueshim.FromHCtyValue(tc.v).Marshal()
+		ty := tc.schemaType
+		if !tc.hasSchemaType {
+			ty = tc.v.Type()
+		}
+		vv := valueshim.FromHCtyValue(tc.v)
+		raw, err := vv.Marshal(valueshim.FromHCtyType(ty))
 		require.NoError(t, err)
 		tc.expect.Equal(t, string(raw))
 	}

pkg/valueshim/shim.go

@@ -28,7 +28,16 @@ type Value interface {
 	AsValueMap() map[string]Value
 
 	// Marshals into the "raw state" JSON representation.
-	Marshal() (json.RawMessage, error)
+	//
+	// This is the representation expected on the TF protocol UpgradeResourceState method.
+	//
+	// For correctly encoding DynamicPseudoType values to {"type": "...", "value": "..."} structures, the
+	// schemaType is needed. This encoding will be used when the schema a type is a DynamicPseudoType but
+	// the value type is a concrete type.
+	//
+	// In situations where the DynamicPseudoType encoding is not needed, you can also call Marshal with
+	// value.Type() to assume the intrinsic type of the value.
+	Marshal(schemaType Type) (json.RawMessage, error)
 
 	// Removes a top-level property from an Object.
 	Remove(key string) Value

pkg/valueshim/tfvalue.go

@@ -16,6 +16,8 @@ package valueshim
 
 import (
 	"encoding/json"
+	"errors"
+	"fmt"
 	"math/big"
 
 	"github.com/hashicorp/terraform-plugin-go/tftypes"
@@ -74,12 +76,20 @@ func (v tValueShim) AsValueMap() map[string]Value {
 	return res
 }
 
-func (v tValueShim) Marshal() (json.RawMessage, error) {
-	inmem, err := jsonMarshal(v.val(), tftypes.NewAttributePath())
+func (v tValueShim) Marshal(schemaType Type) (json.RawMessage, error) {
+	tt, ok := schemaType.(tTypeShim)
+	if !ok {
+		return nil, errors.New("Cannot marshal to RawState: expected schemaType to be of type tTypeShim")
+	}
+	ctyType, err := toCtyType(tt.ty())
+	if err != nil {
+		return nil, fmt.Errorf("Cannot marshal to RawState. Error converting to cty.Type: %w", err)
+	}
+	cty, err := toCtyValue(tt.ty(), ctyType, v.val())
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("Cannot marshal to RawState. Error converting to cty.Value: %w", err)
 	}
-	return json.Marshal(inmem)
+	return FromHCtyValue(cty).Marshal(FromHCtyType(ctyType))
 }
 
 func (v tValueShim) Remove(prop string) Value {
@@ -139,159 +149,11 @@ func (v tValueShim) StringValue() string {
 	return result
 }
 
-func jsonMarshal(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	if v.IsNull() {
-		return nil, nil
-	}
-	if !v.IsKnown() {
-		return nil, p.NewErrorf("unknown values cannot be serialized to JSON")
-	}
-	typ := v.Type()
-	switch {
-	case typ.Is(tftypes.String):
-		return jsonMarshalString(v, p)
-	case typ.Is(tftypes.Number):
-		return jsonMarshalNumber(v, p)
-	case typ.Is(tftypes.Bool):
-		return jsonMarshalBool(v, p)
-	case typ.Is(tftypes.List{}):
-		return jsonMarshalList(v, p)
-	case typ.Is(tftypes.Set{}):
-		return jsonMarshalSet(v, p)
-	case typ.Is(tftypes.Map{}):
-		return jsonMarshalMap(v, p)
-	case typ.Is(tftypes.Tuple{}):
-		return jsonMarshalTuple(v, p)
-	case typ.Is(tftypes.Object{}):
-		return jsonMarshalObject(v, p)
-	}
-
-	return nil, p.NewErrorf("unknown type %s", typ)
-}
-
-func jsonMarshalString(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var stringValue string
-	err := v.As(&stringValue)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	return stringValue, nil
-}
-
-func jsonMarshalNumber(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var n big.Float
-	err := v.As(&n)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	return json.Number(n.Text('f', -1)), nil
-}
-
-func jsonMarshalBool(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var b bool
-	err := v.As(&b)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	return b, nil
-}
-
-func jsonMarshalList(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var vs []tftypes.Value
-	err := v.As(&vs)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	res := make([]any, len(vs))
-	for i, v := range vs {
-		ep := p.WithElementKeyInt(i)
-		e, err := jsonMarshal(v, ep)
-		if err != nil {
-			return nil, ep.NewError(err)
-		}
-		res[i] = e
-	}
-	return res, nil
-}
-
-// Important to preserve original order of tftypes.Value here.
-func jsonMarshalSet(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var vs []tftypes.Value
-	err := v.As(&vs)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	res := make([]any, len(vs))
-	for i, v := range vs {
-		ep := p.WithElementKeyValue(v)
-		e, err := jsonMarshal(v, ep)
-		if err != nil {
-			return nil, ep.NewError(err)
-		}
-		res[i] = e
-	}
-	return res, nil
-}
-
-func jsonMarshalMap(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var vs map[string]tftypes.Value
-	err := v.As(&vs)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	res := make(map[string]any, len(vs))
-	for k, v := range vs {
-		ep := p.WithElementKeyValue(v)
-		e, err := jsonMarshal(v, ep)
-		if err != nil {
-			return nil, ep.NewError(err)
-		}
-		res[k] = e
-	}
-	return res, nil
-}
-
-func jsonMarshalTuple(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var vs []tftypes.Value
-	err := v.As(&vs)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	res := make([]any, len(vs))
-	for i, v := range vs {
-		ep := p.WithElementKeyInt(i)
-		e, err := jsonMarshal(v, ep)
-		if err != nil {
-			return nil, ep.NewError(err)
-		}
-		res[i] = e
-	}
-	return res, nil
-}
-
-func jsonMarshalObject(v tftypes.Value, p *tftypes.AttributePath) (interface{}, error) {
-	var vs map[string]tftypes.Value
-	err := v.As(&vs)
-	if err != nil {
-		return nil, p.NewError(err)
-	}
-	res := make(map[string]any, len(vs))
-	for k, v := range vs {
-		ep := p.WithAttributeName(k)
-		e, err := jsonMarshal(v, ep)
-		if err != nil {
-			return nil, ep.NewError(err)
-		}
-		res[k] = e
-	}
-	return res, nil
-}
-
 type tTypeShim struct {
 	t tftypes.Type
 }
 
-var _ Type = (*tTypeShim)(nil)
+var _ Type = tTypeShim{}
 
 func (t tTypeShim) ty() tftypes.Type {
 	return t.t