tools/fix: add test for selector, call, and default embedding flags

The explicitopen fix classifies embedded expressions in two places:
openEmbedExpr for whole embeddings and collectEmbedFlags for operands of
conjunctions and disjunctions as well as comprehension field values. The
latter misses selectors, index expressions, and()/or() calls, and
defaulted operands (*X), all of which may resolve to closed structs. As
a result, embedding a conjunction with a selector operand or a
disjunction with a defaulted definition operand adds no wrapper to the
enclosing struct, and comprehension field values of those shapes are not
opened, changing behavior in both cases.

The tests document the current, broken output; TODOs mark the intended
rewrites.

Signed-off-by: Daniel Martí <mvdan@mvdan.cc>
Change-Id: Ib85689a441740cf4b61fe301e3df312e10a33192
Reviewed-on: https://cue.gerrithub.io/c/cue-lang/cue/+/1242611
Reviewed-by: Marcel van Lohuizen <mpvl@gmail.com>
TryBot-Result: CUEcueckoo <cueckoo@cuelang.org>
Unity-Result: CUE porcuepine <cue.porcuepine@gmail.com>

Author: mvdan

tools/fix/fix_test.go

@@ -206,6 +206,129 @@ package foo
 `,
 		},
 
+		{
+			// Selectors may resolve to closed values just like plain
+			// references, so a conjunction with a selector operand needs
+			// a runtime __reclose check on the enclosing struct.
+			// TODO: the enclosing struct is left unwrapped; it should be
+			// wrapped in __reclose to preserve the old behavior.
+			name: "reclose embeddings of selector conjunctions (fixExplicitOpen)",
+			exps: []string{"explicitopen"},
+			in: `package foo
+
+#A: a: int
+h: inner: #A
+
+v: {
+	h.inner & {a: 1}
+	extra: 2
+}
+`,
+			out: `@experiment(explicitopen)
+
+package foo
+
+#A: a:    int
+h: inner: #A
+
+v: {
+	(h.inner & {a: 1})...
+	extra: 2
+}
+`,
+		},
+
+		{
+			// Comprehension field values that may resolve to closed
+			// structs via a selector conjunction or an and() call must
+			// be opened like plain references.
+			// TODO: the field values are left untouched; they should
+			// become "(lib.v & {hc: port: 1})..." and "and([lib.v])..."
+			// to preserve the old behavior.
+			name: "open selector and call field values in comprehensions (fixExplicitOpen)",
+			exps: []string{"explicitopen"},
+			in: `package foo
+
+#HC: hc: {port: 1}
+lib: v: #HC
+
+#Service: {
+	enable: bool
+	egress?: [string]: {...}
+	if enable {
+		egress: lib.v & {hc: port: 1}
+	}
+	if enable {
+		egress2: and([lib.v])
+	}
+}
+`,
+			out: `package foo
+
+#HC: hc: {port: 1}
+lib: v:  #HC
+
+#Service: {
+	enable: bool
+	egress?: [string]: {...}
+	if enable {
+		egress: lib.v & {hc: port: 1}
+	}
+	if enable {
+		egress2: and([lib.v])
+	}
+}
+`,
+		},
+
+		{
+			// The default marker *X takes on X's closedness: a disjunction
+			// with a defaulted definition operand needs a runtime __reclose
+			// check when embedded, and must be opened as a comprehension
+			// field value.
+			// TODO: the enclosing struct is left unwrapped and the field
+			// value untouched; they should get __reclose and "..." to
+			// preserve the old behavior.
+			name: "default marker embedding flags (fixExplicitOpen)",
+			exps: []string{"explicitopen"},
+			in: `package foo
+
+#A: {a: int}
+
+v: {
+	*#A | {}
+	extra: 1
+}
+
+#S: {
+	enable: bool
+	x?: {...}
+	if enable {
+		x: *#A | {}
+	}
+}
+`,
+			out: `@experiment(explicitopen)
+
+package foo
+
+#A: {a: int}
+
+v: {
+	(*#A | {})...
+	extra: 1
+}
+
+#S: {
+	enable: bool
+	x?:     {...}
+	if enable {
+		x: *#A | {}
+	}
+}
+`,
+		},
+
 		{
 			// The old comprehension opening also overrides an explicit
 			// close() in a field value: sibling entries added elsewhere