diff --git a/fec/src/lowerexp.c b/fec/src/lowerexp.c
index 40de08c..2b97662 100644
--- a/fec/src/lowerexp.c
+++ b/fec/src/lowerexp.c
@@ -151,9 +151,15 @@ Slot lower_expr_core(Lower *L, FeNode *n)
             return slot_place(fe_ir_at_temp(p, 0), it, ir_size(t));
         }
         /* `.n` is how many elements there are, which an array knows at
-           compile time and a slice carries beside its pointer. */
-        if (n->b && n->b->text && !strcmp(n->b->text, "n")) {
-            FeType *bt = n->a ? n->a->sem_type : 0;
+           compile time and a slice carries beside its pointer. Only for those:
+           a struct is free to have a field called `n`, and reading it as a
+           length would quietly hand back the wrong four bytes. */
+        if (n->b && n->b->text && !strcmp(n->b->text, "n") &&
+            n->a && n->a->sem_type &&
+            (n->a->sem_type->kind == FE_TYPE_ARRAY ||
+             n->a->sem_type->kind == FE_TYPE_SLICE ||
+             n->a->sem_type->kind == FE_TYPE_STR)) {
+            FeType *bt = n->a->sem_type;
             Slot base;
             if (bt && bt->kind == FE_TYPE_ARRAY)
                 return slot_value(fe_ir_const(L->m, L->b, FE_IR_I32,
diff --git a/fec/tests/exec/fieldn.fe b/fec/tests/exec/fieldn.fe
new file mode 100644
index 0000000..cfd148f
--- /dev/null
+++ b/fec/tests/exec/fieldn.fe
@@ -0,0 +1,49 @@
+// EXIT:0
+// OUTPUT:n 777 m 999
+// OUTPUT:len 12 first 7
+// OUTPUT:count 3
+// OUTPUT:balanced
+unit fieldn;
+
+import std.io;
+import std.sys;
+import std.mem;
+
+// `.n` on a slice is its length. On a struct it is whatever field is called
+// `n` -- and a struct is allowed to call a field that. Reading one as the
+// other hands back the four bytes beside the pointer, which is a plausible
+// number and so goes unnoticed.
+
+struct Box {
+    room: ^[]mut u8,
+    n: usize,
+    m: usize,
+}
+
+struct Counter {
+    n: usize,
+
+    fn bump(self: &mut Self) -> void { self.n = self.n + 1; return; }
+}
+
+fn run() -> !void {
+    let r: ^[]mut u8 = try mem.alloc_slice(u8, 12);
+    r.^[0] = 7;
+    let b: Box = Box{ room: r, n: 777, m: 999 };
+    @print("n {} m {}\n", b.n, b.m);
+    // The slice beside it still answers with its length.
+    @print("len {} first {}\n", b.room.^.n, b.room.^[0]);
+    var c: Counter = Counter{ n: 0 };
+    c.bump();
+    c.bump();
+    c.bump();
+    @print("count {}\n", c.n);
+    return;
+}
+
+fn main() -> i32 {
+    run() catch |e| { @print("failed\n"); return 1; };
+    if sys.allocs() == sys.frees() { @print("balanced\n"); }
+    else { @print("leaked\n"); }
+    return 0;
+}