evalv3: empty disjunction regression involving let fields

[mvdan]

# With the old evaluator.
env CUE_EXPERIMENT=evalv3=0
exec cue vet -c

# With the new evaluator.
env CUE_EXPERIMENT=evalv3=1
env CUE_DEBUG=openinline=0
exec cue vet -c

-- input.cue --
package p

#Resource: {
    someMsg: string
    obs: {} | *{missing: true}

    let pickMsg = [
        if obs.missing {msg: "\(someMsg)"},
        {msg: "bar"},
    ][0]
    patches: [{
        op:    "add"
        path:  "/metadata"
        value: pickMsg.msg
    }]
}

#Patches: [string]: _
#JSONPatch: {
    namespace?: string
    patch: [...#JSONOp]
    output: #Patches & {(namespace): patch}
}
#JSONOp: {
    op:    "add"
    path:  string
    value: _
} | {
    op:   "remove"
    path: string
}

#Main: {
    NS=namespace: string

    output: jsonPatch.output

    let jsonPatch = #JSONPatch & {
        let base = #Resource & {}
        let withMsg = base & {someMsg: "foo"}

        namespace: NS

        patch: withMsg.patches
    }
}
out: (#Main & {namespace: "ns1"}).output

As of 5d2da07, this gives:

# With the old evaluator. (0.010s)
> env CUE_EXPERIMENT=evalv3=0
> exec cue vet -c
# With the new evaluator. (0.047s)
> env CUE_EXPERIMENT=evalv3=1
> env CUE_DEBUG=openinline=0
> exec cue vet -c
[stderr]
jsonPatch.output.ns1.0: 2 errors in empty disjunction:
jsonPatch.output.ns1.0.op: conflicting values "remove" and "add":
    ./input.cue:12:16
    ./input.cue:29:11
jsonPatch.output.ns1.0.value: invalid interpolation: non-concrete value string (type string):
    ./input.cue:8:30
    ./input.cue:4:14
[exit status 1]

Reduced from @nyarly's project in Unity.

[mvdan]

Note that I left the reproducer relatively large so that it retains much of the original structure and logic, so that it can act as a "full" reproducer for both the "conflicting values" and "non-concrete value" errors.

[mpvl]

FTR, here is a reduction:

let F = { // must be a let.
    // moving this one level up fixes it.
    base: {
        in: string
        let X = [ {msg: "\(in)"} ][0]
        out: X.msg
    }
    XXX: base & {in: "foo"} // failure is here
}
output: F.XXX.out // confirm that it does not work outside let.

[mvdan]

The reduction I shared here was resolved by https://review.gerrithub.io/c/cue-lang/cue/+/1211647, but Judson's original code still fails. I have reduced the regression once again after your fix:

# With the old evaluator.
env CUE_EXPERIMENT=evalv3=0
exec cue export

# With the new evaluator.
env CUE_EXPERIMENT=evalv3=1
exec cue export

-- input.cue --
package p

#Output: {
	NS=namespace: string
	output: (#SubOutput & {
		namespace: NS
		let base2 = {
			let base = #Base & {}
			output: base & {val0: "foo"}
		}
		patch: base2.output.value
	}).output
}
out: (#Output & {namespace: "ns1"}).output

#SubOutput: {
	namespace?: string

	patch: _
	output: (namespace): patch
}

#Base: {
	val0: string
	let msgObj = [val0][0]
	value: msgObj
}

# With the old evaluator. (0.011s)
> env CUE_EXPERIMENT=evalv3=0
> exec cue export
[stdout]
{
    "out": {
        "ns1": "foo"
    }
}
# With the new evaluator. (0.024s)
> env CUE_EXPERIMENT=evalv3=1
> exec cue export
[stderr]
output.ns1: incomplete value string:
    ./input.cue:24:8
[exit status 1]

[mpvl]

I reduced it to this:

#Output: output: {
	#base: {
		val0: string
		msgObj: {a: val0}.a
		value: msgObj
	}
	out: #base & {val0: "foo"}
}
out: (#Output & {}).output // non-concrete

The thing it has in common with the let variant is that most of the intermediate values are marked as "non-rooted".