---

yaml
---
r: 5521
b: refs/heads/master
c: 3b5b29c
h: refs/heads/master
i:
  5519: e775a93
v: v3

Author: jruderman

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 0125532106bceab9dcf7ffd81e8a351c587f53c4
+refs/heads/master: 3b5b29c7ec2c28c53bf480a77472f39d939cc72b

trunk/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 }

trunk/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; }

trunk/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); }