This "iterate through some things to find the first non `Representable` one" is repeated several times. I wonder if we can abstract it a little. One option would be another helper inner function like:

```rust
fn find_nonrepresentable<It: Iterator<t>>(iter: It, cx: ctxt, seen: &mut ~[ReprItem]) -> Repr {
    iter.map(|t| type_structurally_recursive(cx, *t, seen)
        .find(|r| *r != Representable)
        .unwrap_or(Representable)
}
```

(It'd be ok to write a plain for-loop instead of that iterator madness, if you feel like it.)

called like 

```rust
find_nonrepresentable(ts.iter().map(|t| *t))
find_nonrepresentable(fields.iter().map(|f| f.my.ty)
find_nonrepresentable(variant.args.iter().map(|aty| subst(cx, substs, *aty))
```

(Meh, looking at it written out just now, it's not my favourite abstraction...)