diff --git a/cue/binop.go b/cue/binop.go
index 278e251..d2ebfb6 100644
--- a/cue/binop.go
+++ b/cue/binop.go
@@ -605,7 +605,7 @@
 	}
 	lambda := ctx.deref(l).(*lambdaExpr)
 	if finalize {
-		lambda.value = wrapFinalize(lambda.value)
+		lambda.value = wrapFinalize(ctx, lambda.value)
 	}
 	return lambda, nil
 }
@@ -705,10 +705,10 @@
 				}
 				w := b.v
 				if x.closeStatus.shouldFinalize() {
-					w = wrapFinalize(w)
+					w = wrapFinalize(ctx, w)
 				}
 				if y.closeStatus.shouldFinalize() {
-					v = wrapFinalize(v)
+					v = wrapFinalize(ctx, v)
 				}
 				v = mkBin(ctx, src.Pos(), op, w, v)
 				obj.arcs[i].v = v
diff --git a/cue/builtin.go b/cue/builtin.go
index 7c667b7..3613b96 100644
--- a/cue/builtin.go
+++ b/cue/builtin.go
@@ -204,7 +204,7 @@
 		if len(d) == 0 {
 			// TODO(manifest): This should not be unconditionally incomplete,
 			// but it requires results from comprehensions and all to have
-			// some special status. Mayb this can be solved by having results
+			// some special status. Maybe this can be solved by having results
 			// of list comprehensions be open if they result from iterating over
 			// an open list or struct. This would actually be exactly what
 			// that means. The error here could then only add an incomplete
diff --git a/cue/eval.go b/cue/eval.go
index ba20f4a..01051f1 100644
--- a/cue/eval.go
+++ b/cue/eval.go
@@ -321,7 +321,7 @@
 
 func (x *closeIfStruct) evalPartial(ctx *context) evaluated {
 	v := x.value.evalPartial(ctx)
-	updateCloseStatus(v)
+	updateCloseStatus(ctx, v)
 	return v
 }
 
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index b48d5e1..7f1d4c9 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -1476,13 +1476,20 @@
 			}
 			...
 		}
+
+		E :: A & {
+			for k, v in { f3: int } {
+				"\(k)": v
+			}
+		}
 		`,
 		out: `<0>{` +
+			`E :: _|_(int:field "f3" not allowed in closed struct), ` +
 			`A :: <1>C{f1: int, f2: int}, ` +
-			`a: <2>C{f1: int, f2: int, f3: int}, ` +
-			`B :: <3>C{f1: int}, ` +
-			`C :: <4>C{f1: int}, ` +
-			`D :: <5>{f1: int, ...}` +
+			`a: _|_(int:field "f3" not allowed in closed struct), ` +
+			`B :: <2>C{f1: int}, ` +
+			`C :: <3>C{f1: int}, ` +
+			`D :: <4>{f1: int, ...}` +
 			`}`,
 	}, {
 		desc: "incomplete comprehensions",
@@ -2573,6 +2580,30 @@
 		}
 		`,
 		out: `<0>{Workflow :: <1>C{jobs: <2>{<>: <3>(jobID: string)-><4>C{}, }, JobID :: or ([ <5>for k, _ in <6>.jobs yield <5>.k ])}, foo: <7>C{jobs: <8>{<>: <9>(jobID: string)-><10>C{}, foo: <11>C{}}, JobID :: "foo"}}`,
+	}, {
+		desc: "Issue #153",
+		in: `
+		Foo: {
+			listOfCloseds: [...Closed]
+		}
+		
+		Closed :: {
+			a: int | *0
+		}
+		
+		Junk: {
+			b: 2
+		}
+		
+		Foo & {
+			listOfCloseds: [{
+				for k, v in Junk {
+					"\(k)": v
+				}
+			 }]
+		}
+		`,
+		out: `<0>{<1>{listOfCloseds: [_|_(2:field "b" not allowed in closed struct)]}, Foo: <2>{listOfCloseds: []}, Closed :: <3>C{a: 0}, Junk: <4>{b: 2}}`,
 	}}
 	rewriteHelper(t, testCases, evalFull)
 }
diff --git a/cue/rewrite.go b/cue/rewrite.go
index 3f81daf..f329f29 100644
--- a/cue/rewrite.go
+++ b/cue/rewrite.go
@@ -39,7 +39,7 @@
 	if v == x.value {
 		return x
 	}
-	return wrapFinalize(v)
+	return wrapFinalize(ctx, v)
 }
 
 func (x *structLit) rewrite(ctx *context, fn rewriteFunc) value {
diff --git a/cue/value.go b/cue/value.go
index 495f4d5..17a8ec2 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -796,7 +796,7 @@
 		// it is safe to cache the result.
 		ctx.cycleErr = false
 
-		updateCloseStatus(v)
+		updateCloseStatus(ctx, v)
 		x.arcs[i].cache = v
 		if doc != nil {
 			x.arcs[i].docs = &docNode{n: doc, left: x.arcs[i].docs}
@@ -862,7 +862,7 @@
 		orig := *x
 		orig.comprehensions = incomplete
 		orig.emit = nil
-		n = binOp(ctx, src, opUnifyUnchecked, &orig, n)
+		n = binOp(ctx, src, opUnify, &orig, n)
 
 	default:
 		if len(comprehensions) == len(incomplete) {
@@ -984,13 +984,13 @@
 	value
 }
 
-func wrapFinalize(v value) value {
+func wrapFinalize(ctx *context, v value) value {
 	if v.kind().isAnyOf(structKind | listKind) {
 		switch x := v.(type) {
 		case *top:
 			return v
 		case *structLit, *list, *disjunction:
-			updateCloseStatus(v)
+			updateCloseStatus(ctx, v)
 		case *closeIfStruct:
 			return x
 		}
@@ -999,23 +999,27 @@
 	return v
 }
 
-func updateCloseStatus(v value) {
+func updateCloseStatus(ctx *context, v value) {
 	switch x := v.(type) {
 	case *structLit:
-		if x.closeStatus.shouldClose() {
-			x.closeStatus = isClosed
+		y, err := x.expandFields(ctx)
+		if err == nil {
+			if x.closeStatus.shouldClose() {
+				x.closeStatus = isClosed
+			}
+			x.closeStatus |= shouldFinalize
+			y.closeStatus = x.closeStatus
 		}
-		x.closeStatus |= shouldFinalize
 
 	case *disjunction:
 		for _, d := range x.values {
-			d.val = wrapFinalize(d.val)
+			d.val = wrapFinalize(ctx, d.val)
 		}
 
 	case *list:
-		wrapFinalize(x.elem)
+		wrapFinalize(ctx, x.elem)
 		if x.typ != nil {
-			wrapFinalize(x.typ)
+			wrapFinalize(ctx, x.typ)
 		}
 	}
 }