diff --git a/cue/query.go b/cue/query.go
new file mode 100644
index 0000000..7ffc020
--- /dev/null
+++ b/cue/query.go
@@ -0,0 +1,54 @@
+// Copyright 2021 CUE Authors
+//
+// 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 cue
+
+import (
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/ast/astutil"
+	"cuelang.org/go/cue/token"
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/compile"
+)
+
+// This file contains query-related code.
+
+// getScopePrefix finds the Vertex that exists in v for the longest prefix of p.
+//
+// It is used to make the parent scopes visible when resolving expressions.
+func getScopePrefix(v Value, p Path) *adt.Vertex {
+	for _, sel := range p.Selectors() {
+		w := v.LookupPath(MakePath(sel))
+		if !w.Exists() {
+			break
+		}
+		v = w
+	}
+	return v.v
+}
+
+func errFn(pos token.Pos, msg string, args ...interface{}) {}
+
+// resolveExpr binds unresolved expressions to values in the expression or v.
+func resolveExpr(ctx *context, v *adt.Vertex, x ast.Expr) adt.Value {
+	cfg := &compile.Config{Scope: v}
+
+	astutil.ResolveExpr(x, errFn)
+
+	c, err := compile.Expr(cfg, ctx.opCtx, pkgID(), x)
+	if err != nil {
+		return &adt.Bottom{Err: err}
+	}
+	return adt.Resolve(ctx.opCtx, c)
+}
diff --git a/cue/types.go b/cue/types.go
index d3f0dc8..da5e1e2 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -1539,6 +1539,8 @@
 				continue outer
 			}
 		}
+		// TODO: if optional, look up template for name.
+
 		var x *adt.Bottom
 		if err, ok := sel.sel.(pathError); ok {
 			x = &adt.Bottom{Err: err.Error}
@@ -1555,6 +1557,8 @@
 // LookupDef reports the definition with the given name within struct v. The
 // Exists method of the returned value will report false if the definition did
 // not exist. The Err method reports if any error occurred during evaluation.
+//
+// Deprecated: use lookupPath.
 func (v Value) LookupDef(name string) Value {
 	ctx := v.ctx()
 	o, err := v.structValFull(ctx)
@@ -1649,9 +1653,14 @@
 // FillPath creates a new value by unifying v with the value of x at the given
 // path.
 //
-// Values may be any Go value that can be converted to CUE, an ast.Expr or a
-// Value. In the latter case, it will panic if the Value is not from the same
-// Runtime.
+// If x is an cue/ast.Expr, it will be evaluated within the context of the
+// given path: identifiers that are not resolved within the expression are
+// resolved as if they were defined at the path position.
+//
+// If x is a Value, it will be used as is. It panics if x is not created
+// from the same Runtime as v.
+//
+// Otherwise, the given Go value will be converted to CUE.
 //
 // Any reference in v referring to the value at the given path will resolve to x
 // in the newly created value. The resulting value is not validated.
@@ -1659,13 +1668,28 @@
 // List paths are not supported at this time.
 func (v Value) FillPath(p Path, x interface{}) Value {
 	if v.v == nil {
+		// TODO: panic here?
 		return v
 	}
 	ctx := v.ctx()
 	if err := p.Err(); err != nil {
 		return newErrValue(v, ctx.mkErr(nil, 0, "invalid path: %v", err))
 	}
-	var expr adt.Expr = convert.GoValueToValue(ctx.opCtx, x, true)
+	var expr adt.Expr
+	switch x := x.(type) {
+	case Value:
+		if v.idx != x.idx {
+			panic("values are not from the same runtime")
+		}
+		expr = x.v
+	case adt.Node, adt.Feature:
+		panic("cannot set internal Value or Feature type")
+	case ast.Expr:
+		n := getScopePrefix(v, p)
+		expr = resolveExpr(ctx, n, x)
+	default:
+		expr = convert.GoValueToValue(ctx.opCtx, x, true)
+	}
 	for i := len(p.path) - 1; i >= 0; i-- {
 		expr = &adt.StructLit{Decls: []adt.Decl{
 			&adt.Field{
diff --git a/cue/types_test.go b/cue/types_test.go
index f5ab493..4e74180 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -1068,6 +1068,67 @@
 		out: `
 		{foo: {bar: "baz"}}
 		`,
+	}, {
+		// Resolve to enclosing
+		in: `
+		foo: _
+		x: 1
+		`,
+		x:    ast.NewIdent("x"),
+		path: ParsePath("foo"),
+		out: `
+		{foo: 1, x: 1}
+		`,
+	}, {
+		in: `
+		foo: {
+			bar: _
+			x: 1
+		}
+		`,
+		x:    ast.NewIdent("x"),
+		path: ParsePath("foo.bar"),
+		out: `
+		{foo: {bar: 1, x: 1}}
+		`,
+	}, {
+		// Resolve one scope up
+		in: `
+		x: 1
+		foo: {
+			bar: _
+		}
+		`,
+		x:    ast.NewIdent("x"),
+		path: ParsePath("foo.bar"),
+		out: `
+		{foo: {bar: 1}, x: 1}
+		`,
+	}, {
+		// Resolve within ast expression
+		in: `
+		foo: {
+			bar: _
+		}
+		`,
+		x: ast.NewStruct(
+			ast.NewIdent("x"), ast.NewString("1"),
+			ast.NewIdent("y"), ast.NewIdent("x"),
+		),
+		path: ParsePath("foo.bar"),
+		out: `
+			{foo: {bar: {x: "1", y: "1"}}}
+			`,
+	}, {
+		// Resolve in non-existing
+		in: `
+		foo: x: 1
+		`,
+		x:    ast.NewIdent("x"),
+		path: ParsePath("foo.bar.baz"),
+		out: `
+		{foo: {x: 1, bar: baz: 1}}
+		`,
 	}}
 
 	for _, tc := range testCases {
diff --git a/internal/core/compile/compile.go b/internal/core/compile/compile.go
index 14ea284..ff30412 100644
--- a/internal/core/compile/compile.go
+++ b/internal/core/compile/compile.go
@@ -30,8 +30,6 @@
 	// Scope specifies a node in which to look up unresolved references. This
 	// is useful for evaluating expressions within an already evaluated
 	// configuration.
-	//
-	// TODO
 	Scope *adt.Vertex
 
 	// Imports allows unresolved identifiers to resolve to imports.
@@ -249,21 +247,6 @@
 		}
 	}
 
-	// TODO: Assume that the other context is unified with the newly compiled
-	// files. This is not the same behavior as the old functionality, but we
-	// wanted to nix this anyway. For instance by allowing pkg_tool to be
-	// treated differently.
-	if v := c.Config.Scope; v != nil {
-		for _, arc := range v.Arcs {
-			if _, ok := c.fileScope[arc.Label]; !ok {
-				c.fileScope[arc.Label] = true
-			}
-		}
-
-		c.pushScope(nil, 0, v.Source()) // File scope
-		defer c.popScope()
-	}
-
 	// TODO: set doc.
 	res := &adt.Vertex{}
 
@@ -281,17 +264,6 @@
 }
 
 func (c *compiler) compileExpr(x ast.Expr) adt.Conjunct {
-	c.fileScope = map[adt.Feature]bool{}
-
-	if v := c.Config.Scope; v != nil {
-		for _, arc := range v.Arcs {
-			c.fileScope[arc.Label] = true
-		}
-
-		c.pushScope(nil, 0, v.Source()) // File scope
-		defer c.popScope()
-	}
-
 	expr := c.expr(x)
 
 	env := &adt.Environment{}
@@ -301,13 +273,6 @@
 		top.Vertex = p
 		top.Up = &adt.Environment{}
 		top = top.Up
-
-		// TODO: do something like this to allow multi-layered scopes.
-		// e := &adt.Environment{Vertex: p}
-		// if env != nil {
-		// 	env.Up = e
-		// }
-		// env = e
 	}
 
 	return adt.MakeRootConjunct(env, expr)
@@ -344,6 +309,18 @@
 				Label:   label,
 			}
 		}
+		for p := c.Scope; p != nil; p = p.Parent {
+			for _, a := range p.Arcs {
+				if a.Label == label {
+					return &adt.FieldReference{
+						Src:     n,
+						UpCount: upCount,
+						Label:   label,
+					}
+				}
+			}
+			upCount++
+		}
 
 		if c.Config.Imports != nil {
 			if pkgPath := c.Config.Imports(n); pkgPath != "" {