diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs
index b0c64b1d474f..80bab14170de 100644
--- a/src/comp/middle/trans_common.rs
+++ b/src/comp/middle/trans_common.rs
@@ -833,10 +833,7 @@ pure fn type_has_static_size(cx: @crate_ctxt, t: ty::t) -> bool {
 }
 
 pure fn non_ty_var(cx: @crate_ctxt, t: ty::t) -> bool {
-    // Not obviously referentially transparent, but
-    // type interner shouldn't be changing at this point.
-    // FIXME: how to make that clearer?
-    let st = unchecked { ty::struct(cx.tcx, t) };
+    let st = ty::struct(cx.tcx, t);
     alt st {
       ty::ty_var(_) { false }
       _          { true }
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index a91f7946c7d3..1f3b58c00ce9 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -841,7 +841,7 @@ fn sequence_element_type(cx: ctxt, ty: t) -> t {
 }
 
 pure fn type_is_tup_like(cx: ctxt, ty: t) -> bool {
-    let sty = unchecked { struct(cx, ty) };
+    let sty = struct(cx, ty);
     alt sty {
       ty_box(_) | ty_rec(_) | ty_tup(_) | ty_tag(_,_) { true }
       _ { false }
@@ -1624,9 +1624,7 @@ fn ty_fn_abi(cx: ctxt, fty: t) -> ast::native_abi {
 }
 
 pure fn ty_fn_ret(cx: ctxt, fty: t) -> t {
-    // Should be pure, as type interner contents
-    // shouldn't change once set...
-    let sty = unchecked { struct(cx, fty) };
+    let sty = struct(cx, fty);
     alt sty {
       ty::ty_fn(_, _, r, _, _) { ret r; }
       ty::ty_native_fn(_, _, r) { ret r; }
diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs
index 164b38fe8705..67324491267d 100644
--- a/src/comp/syntax/util/interner.rs
+++ b/src/comp/syntax/util/interner.rs
@@ -28,7 +28,13 @@ fn intern<@T>(itr: interner<T>, val: T) -> uint {
     }
 }
 
-pure fn get<@T>(itr: interner<T>, idx: uint) -> T { ret itr.vect[idx]; }
-
-pure fn len<T>(itr: interner<T>) -> uint { ret vec::len(itr.vect); }
+// |get| isn't "pure" in the traditional sense, because it can go from
+// failing to returning a value as items are interned. But for typestate,
+// where we first check a pred and then rely on it, ceasing to fail is ok.
+pure fn get<@T>(itr: interner<T>, idx: uint) -> T {
+    unchecked {
+        itr.vect[idx]
+    }
+}
 
+fn len<T>(itr: interner<T>) -> uint { ret vec::len(itr.vect); }