nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-30 02:33:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Promote 'struct' from a restricted keyword to a strict keyword

Browse Source
This commit is contained in:
Brian Anderson 2012-09-11 16:20:31 -07:00
parent 1203da3b9d
commit 27cc0a36b6
42 changed files with 185 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libsyntax/parse/token.rs
View File

@ -415,7 +415,6 @@ fn restricted_keyword_table() -> HashMap<~str, ()> {
~"fail", ~"fn",
~"impl",
~"priv", ~"pub",
~"struct",
~"unsafe"
];
for keys.each |word| {
@ -438,6 +437,7 @@ fn strict_keyword_table() -> HashMap<~str, ()> {
~"match", ~"mod", ~"move", ~"mut",
~"pure",
~"ref", ~"return",
~"struct",
~"true", ~"trait", ~"type",
~"unchecked", ~"use",
~"while"

4
src/rustc/metadata/decoder.rs
View File

@ -584,7 +584,7 @@ fn get_enum_variants(intr: ident_interner, cdata: cmd, id: ast::node_id,
tcx, cdata);
let name = item_name(intr, item);
let mut arg_tys: ~[ty::t] = ~[];
match ty::get(ctor_ty).struct {
match ty::get(ctor_ty).sty {
ty::ty_fn(f) => {
for f.sig.inputs.each |a| { vec::push(arg_tys, a.ty); }
}
@ -696,7 +696,7 @@ fn get_trait_methods(intr: ident_interner, cdata: cmd, id: ast::node_id,
let bounds = item_ty_param_bounds(mth, tcx, cdata);
let name = item_name(intr, mth);
let ty = doc_type(mth, tcx, cdata);
let fty = match ty::get(ty).struct {
let fty = match ty::get(ty).sty {
ty::ty_fn(f) => f,
_ => {
tcx.diag.handler().bug(

4
src/rustc/metadata/tyencode.rs
View File

@ -47,7 +47,7 @@ fn enc_ty(w: io::Writer, cx: @ctxt, t: ty::t) {
Some(s) => *s,
None => {
let buf = io::mem_buffer();
enc_sty(io::mem_buffer_writer(buf), cx, ty::get(t).struct);
enc_sty(io::mem_buffer_writer(buf), cx, ty::get(t).sty);
cx.tcx.short_names_cache.insert(t, @io::mem_buffer_str(buf));
io::mem_buffer_str(buf)
}
@ -72,7 +72,7 @@ fn enc_ty(w: io::Writer, cx: @ctxt, t: ty::t) {
}
_ => {}
}
enc_sty(w, cx, ty::get(t).struct);
enc_sty(w, cx, ty::get(t).sty);
let end = w.tell();
let len = end - pos;
fn estimate_sz(u: uint) -> uint {

2
src/rustc/middle/borrowck/check_loans.rs
View File

@ -224,7 +224,7 @@ impl check_loan_ctxt {
}
let callee_ty = ty::node_id_to_type(tcx, callee_id);
match ty::get(callee_ty).struct {
match ty::get(callee_ty).sty {
ty::ty_fn(fn_ty) => {
match fn_ty.meta.purity {
ast::pure_fn => return, // case (c) above

14
src/rustc/middle/check_alt.rs
View File

@ -39,7 +39,7 @@ fn check_expr(tcx: ty::ctxt, ex: @expr, &&s: (), v: visit::vt<()>) {
// If the type *is* empty, it's vacuously exhaustive
return;
}
match ty::get(pat_ty).struct {
match ty::get(pat_ty).sty {
ty_enum(did, _) => {
if (*enum_variants(tcx, did)).is_empty() && arms.is_empty() {
@ -85,7 +85,7 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: ~[@pat]) {
not_useful => return, // This is good, wildcard pattern isn't reachable
useful_ => None,
useful(ty, ctor) => {
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_bool => {
match ctor {
val(const_bool(true)) => Some(~"true"),
@ -167,7 +167,7 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful {
None => {
match missing_ctor(tcx, m, left_ty) {
None => {
match ty::get(left_ty).struct {
match ty::get(left_ty).sty {
ty::ty_bool => {
match is_useful_specialized(tcx, m, v, val(const_bool(true)),
0u, left_ty){
@ -257,7 +257,7 @@ fn is_wild(tcx: ty::ctxt, p: @pat) -> bool {
}
fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option<ctor> {
match ty::get(left_ty).struct {
match ty::get(left_ty).sty {
ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(*) | ty::ty_tup(_) |
ty::ty_rec(_) | ty::ty_class(*) => {
for m.each |r| {
@ -302,7 +302,7 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option<ctor> {
}
fn ctor_arity(tcx: ty::ctxt, ctor: ctor, ty: ty::t) -> uint {
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_tup(fs) => fs.len(),
ty::ty_rec(fs) => fs.len(),
ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(*) => 1u,
@ -352,7 +352,7 @@ fn specialize(tcx: ty::ctxt, r: ~[@pat], ctor_id: ctor, arity: uint,
}
}
pat_rec(flds, _) => {
let ty_flds = match ty::get(left_ty).struct {
let ty_flds = match ty::get(left_ty).sty {
ty::ty_rec(flds) => flds,
_ => fail ~"bad type for pat_rec"
};
@ -367,7 +367,7 @@ fn specialize(tcx: ty::ctxt, r: ~[@pat], ctor_id: ctor, arity: uint,
pat_struct(_, flds, _) => {
// Grab the class data that we care about.
let class_fields, class_id;
match ty::get(left_ty).struct {
match ty::get(left_ty).sty {
ty::ty_class(cid, _) => {
class_id = cid;
class_fields = ty::lookup_class_fields(tcx, class_id);

2
src/rustc/middle/const_eval.rs
View File

@ -317,7 +317,7 @@ fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val {
expr_cast(base, _) => {
let ety = ty::expr_ty(tcx, e);
let base = eval_const_expr(tcx, base);
match ty::get(ety).struct {
match ty::get(ety).sty {
ty::ty_float(_) => {
match base {
const_uint(u) => const_float(u as f64),

8
src/rustc/middle/kind.rs
View File

@ -300,7 +300,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
Some(ex) => {
// All noncopyable fields must be overridden
let t = ty::expr_ty(cx.tcx, ex);
let ty_fields = match ty::get(t).struct {
let ty_fields = match ty::get(t).sty {
ty::ty_rec(f) => f,
_ => cx.tcx.sess.span_bug(ex.span, ~"bad expr type in record")
};
@ -504,7 +504,7 @@ fn check_send(cx: ctx, ty: ty::t, sp: span) -> bool {
// note: also used from middle::typeck::regionck!
fn check_owned(tcx: ty::ctxt, ty: ty::t, sp: span) -> bool {
if !ty::kind_is_owned(ty::type_kind(tcx, ty)) {
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_param(*) => {
tcx.sess.span_err(sp, ~"value may contain borrowed \
pointers; use `owned` bound");
@ -551,7 +551,7 @@ fn check_cast_for_escaping_regions(
// Determine what type we are casting to; if it is not an trait, then no
// worries.
let target_ty = ty::expr_ty(cx.tcx, target);
let target_substs = match ty::get(target_ty).struct {
let target_substs = match ty::get(target_ty).sty {
ty::ty_trait(_, substs, _) => {substs}
_ => { return; /* not a cast to a trait */ }
};
@ -574,7 +574,7 @@ fn check_cast_for_escaping_regions(
let target_params = ty::param_tys_in_type(target_ty);
let source_ty = ty::expr_ty(cx.tcx, source);
do ty::walk_ty(source_ty) |ty| {
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_param(source_param) => {
if target_params.contains(source_param) {
/* case (2) */

4
src/rustc/middle/lint.rs
View File

@ -498,7 +498,7 @@ fn check_item_heap(cx: ty::ctxt, it: @ast::item) {
let mut n_box = 0;
let mut n_uniq = 0;
ty::fold_ty(cx, ty, |t| {
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_box(_) => n_box += 1,
ty::ty_uniq(_) => n_uniq += 1,
_ => ()
@ -658,7 +658,7 @@ fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl,
}
let fn_ty = ty::node_id_to_type(tcx, id);
match ty::get(fn_ty).struct {
match ty::get(fn_ty).sty {
ty::ty_fn(fn_ty) => {
let mut counter = 0;
do vec::iter2(fn_ty.sig.inputs, decl.inputs) |arg_ty, arg_ast| {

8
src/rustc/middle/mem_categorization.rs
View File

@ -290,7 +290,7 @@ enum deref_kind {deref_ptr(ptr_kind), deref_comp(comp_kind)}
// derefable (we model an index as the combination of a deref and then a
// pointer adjustment).
fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_uniq(*) |
ty::ty_evec(_, ty::vstore_uniq) |
ty::ty_estr(ty::vstore_uniq) => {
@ -424,7 +424,7 @@ impl &mem_categorization_ctxt {
// Any expression can be borrowed (to account for auto-ref on method
// receivers), but @, ~, @vec, and ~vec are handled specially.
let expr_ty = ty::expr_ty(self.tcx, expr);
match ty::get(expr_ty).struct {
match ty::get(expr_ty).sty {
ty::ty_evec(*) | ty::ty_estr(*) => {
self.cat_index(expr, expr)
}
@ -1013,7 +1013,7 @@ impl &mem_categorization_ctxt {
cat_comp(_, comp_tuple) => ~"tuple content",
cat_comp(_, comp_variant(_)) => ~"enum content",
cat_comp(_, comp_index(t, _)) => {
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_evec(*) => mut_str + ~" vec content",
ty::ty_estr(*) => mut_str + ~" str content",
_ => mut_str + ~" indexed content"
@ -1034,7 +1034,7 @@ fn field_mutbl(tcx: ty::ctxt,
base_ty: ty::t,
f_name: ast::ident) -> Option<ast::mutability> {
// Need to refactor so that records/class fields can be treated uniformly.
match ty::get(base_ty).struct {
match ty::get(base_ty).sty {
ty::ty_rec(fields) => {
for fields.each |f| {
if f.ident == f_name {

6
src/rustc/middle/privacy.rs
View File

@ -154,7 +154,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
visit_expr: |expr, method_map: &method_map, visitor| {
match expr.node {
expr_field(base, ident, _) => {
match ty::get(ty::expr_ty(tcx, base)).struct {
match ty::get(ty::expr_ty(tcx, base)).sty {
ty_class(id, _)
if id.crate != local_crate ||
!privileged_items.contains(id.node) => {
@ -175,7 +175,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
}
}
expr_struct(_, fields, _) => {
match ty::get(ty::expr_ty(tcx, expr)).struct {
match ty::get(ty::expr_ty(tcx, expr)).sty {
ty_class(id, _) => {
if id.crate != local_crate ||
!privileged_items.contains(id.node) {
@ -202,7 +202,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
visit_pat: |pattern, method_map, visitor| {
match pattern.node {
pat_struct(_, fields, _) => {
match ty::get(ty::pat_ty(tcx, pattern)).struct {
match ty::get(ty::pat_ty(tcx, pattern)).sty {
ty_class(id, _) => {
if id.crate != local_crate ||
!privileged_items.contains(id.node) {

7
src/rustc/middle/trans/alt.rs
View File

@ -293,8 +293,7 @@ fn extract_variant_args(bcx: block, pat_id: ast::node_id,
{vals: ~[ValueRef], bcx: block} {
let _icx = bcx.insn_ctxt("alt::extract_variant_args");
let ccx = bcx.fcx.ccx;
let enum_ty_substs = match ty::get(node_id_type(bcx, pat_id))
.struct {
let enum_ty_substs = match ty::get(node_id_type(bcx, pat_id)).sty {
ty::ty_enum(id, substs) => { assert id == vdefs.enm; substs.tps }
_ => bcx.sess().bug(~"extract_variant_args: pattern has non-enum type")
};
@ -436,7 +435,7 @@ fn compare_values(cx: block, lhs: ValueRef, rhs: ValueRef, rhs_t: ty::t) ->
return rslt(rs.bcx, rs.val);
}
match ty::get(rhs_t).struct {
match ty::get(rhs_t).sty {
ty::ty_estr(ty::vstore_uniq) => {
let scratch_result = scratch_datum(cx, ty::mk_bool(cx.tcx()),
false);
@ -559,7 +558,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
if any_tup_pat(m, col) {
let tup_ty = node_id_type(bcx, pat_id);
let n_tup_elts = match ty::get(tup_ty).struct {
let n_tup_elts = match ty::get(tup_ty).sty {
ty::ty_tup(elts) => elts.len(),
_ => ccx.sess.bug(~"non-tuple type in tuple pattern")
};

12
src/rustc/middle/trans/base.rs
View File

@ -422,7 +422,7 @@ fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef,
t: ty::t, op: ast::binop) -> Result {
let f = |a| compare_scalar_values(cx, lhs, rhs, a, op);
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_nil => rslt(cx, f(nil_type)),
ty::ty_bool | ty::ty_ptr(_) => rslt(cx, f(unsigned_int)),
ty::ty_int(_) => rslt(cx, f(signed_int)),
@ -528,7 +528,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
let fn_ty = variant.ctor_ty;
let ccx = cx.ccx();
let mut cx = cx;
match ty::get(fn_ty).struct {
match ty::get(fn_ty).sty {
ty::ty_fn(ref fn_ty) => {
let mut j = 0u;
let v_id = variant.id;
@ -548,7 +548,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
Typestate constraint that shows the unimpl case doesn't happen?
*/
let mut cx = cx;
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_rec(*) | ty::ty_class(*) => {
do expr::with_field_tys(cx.tcx(), t) |_has_dtor, field_tys| {
for vec::eachi(field_tys) |i, field_ty| {
@ -655,7 +655,7 @@ fn fail_if_zero(cx: block, span: span, divmod: ast::binop,
} else {
~"modulo zero"
};
let is_zero = match ty::get(rhs_t).struct {
let is_zero = match ty::get(rhs_t).sty {
ty::ty_int(t) => {
let zero = C_integral(T_int_ty(cx.ccx(), t), 0u64, False);
ICmp(cx, lib::llvm::IntEQ, rhs, zero)
@ -681,7 +681,7 @@ fn null_env_ptr(bcx: block) -> ValueRef {
fn trans_external_path(ccx: @crate_ctxt, did: ast::def_id, t: ty::t)
-> ValueRef {
let name = csearch::get_symbol(ccx.sess.cstore, did);
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_fn(_) => {
let llty = type_of_fn_from_ty(ccx, t);
return get_extern_fn(ccx.externs, ccx.llmod, name,
@ -1956,7 +1956,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
let main_takes_argv =
// invariant!
match ty::get(main_node_type).struct {
match ty::get(main_node_type).sty {
ty::ty_fn(ref fn_ty) => fn_ty.sig.inputs.len() != 0u,
_ => ccx.sess.span_fatal(sp, ~"main has a non-function type")
};

2
src/rustc/middle/trans/callee.rs
View File

@ -620,7 +620,7 @@ fn adapt_borrowed_value(bcx: block,
datum.to_str(bcx.ccx()),
bcx.expr_to_str(expr));
match ty::get(datum.ty).struct {
match ty::get(datum.ty).sty {
ty::ty_uniq(_) | ty::ty_box(_) => {
let body_datum = datum.box_body(bcx);
let rptr_datum = body_datum.to_rptr(bcx);

8
src/rustc/middle/trans/consts.rs
View File

@ -10,7 +10,7 @@ fn const_lit(cx: @crate_ctxt, e: @ast::expr, lit: ast::lit)
ast::lit_uint(u, t) => C_integral(T_uint_ty(cx, t), u, False),
ast::lit_int_unsuffixed(i) => {
let lit_int_ty = ty::node_id_to_type(cx.tcx, e.id);
match ty::get(lit_int_ty).struct {
match ty::get(lit_int_ty).sty {
ty::ty_int(t) => {
C_integral(T_int_ty(cx, t), i as u64, True)
}
@ -76,7 +76,7 @@ fn const_autoderef(cx: @crate_ctxt, ty: ty::t, v: ValueRef)
let mut v1 = v;
loop {
// Only rptrs can be autoderef'ed in a const context.
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_rptr(_, mt) => {
t1 = mt.ty;
v1 = const_deref(cx, v1);
@ -184,7 +184,7 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
~"index is not an integer-constant \
expression")
};
let (arr, _len) = match ty::get(bt).struct {
let (arr, _len) = match ty::get(bt).sty {
ty::ty_evec(_, vstore) | ty::ty_estr(vstore) =>
match vstore {
ty::vstore_fixed(u) =>
@ -236,7 +236,7 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
// we can get the value (as a number) out of.
let len = llvm::LLVMGetArrayLength(val_ty(arr)) as u64;
let len = match ty::get(bt).struct {
let len = match ty::get(bt).sty {
ty::ty_estr(*) => {assert len > 0; len - 1},
_ => len
};

4
src/rustc/middle/trans/datum.rs
View File

@ -528,7 +528,7 @@ impl Datum {
* This datum must represent an @T or ~T box. Returns a new
* by-ref datum of type T, pointing at the contents. */
let content_ty = match ty::get(self.ty).struct {
let content_ty = match ty::get(self.ty).sty {
ty::ty_box(mt) | ty::ty_uniq(mt) => mt.ty,
_ => {
bcx.tcx().sess.bug(fmt!(
@ -583,7 +583,7 @@ impl Datum {
}
}
match ty::get(self.ty).struct {
match ty::get(self.ty).sty {
ty::ty_box(_) | ty::ty_uniq(_) => {
return Some(self.box_body(bcx));
}

8
src/rustc/middle/trans/expr.rs
View File

@ -447,7 +447,7 @@ fn trans_rvalue_dps(bcx: block, expr: @ast::expr, dest: Dest) -> block {
}
ast::expr_fn_block(decl, body, cap_clause) => {
let expr_ty = expr_ty(bcx, expr);
match ty::get(expr_ty).struct {
match ty::get(expr_ty).sty {
ty::ty_fn(ref fn_ty) => {
debug!("translating fn_block %s with type %s",
expr_to_str(expr, tcx.sess.intr()),
@ -464,7 +464,7 @@ fn trans_rvalue_dps(bcx: block, expr: @ast::expr, dest: Dest) -> block {
}
}
ast::expr_loop_body(blk) => {
match ty::get(expr_ty(bcx, expr)).struct {
match ty::get(expr_ty(bcx, expr)).sty {
ty::ty_fn(ref fn_ty) => {
match blk.node {
ast::expr_fn_block(decl, body, cap) => {
@ -774,7 +774,7 @@ fn fn_data_to_datum(bcx: block,
fn with_field_tys<R>(tcx: ty::ctxt, ty: ty::t,
op: fn(bool, (&[ty::field])) -> R) -> R {
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_rec(ref fields) => {
op(false, *fields)
}
@ -1279,7 +1279,7 @@ impl cast_kind : cmp::Eq {
}
fn cast_type_kind(t: ty::t) -> cast_kind {
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_float(*) => cast_float,
ty::ty_ptr(*) => cast_pointer,
ty::ty_rptr(*) => cast_pointer,

2
src/rustc/middle/trans/foreign.rs
View File

@ -440,7 +440,7 @@ type c_stack_tys = {
fn c_arg_and_ret_lltys(ccx: @crate_ctxt,
id: ast::node_id) -> (~[TypeRef], TypeRef, ty::t) {
match ty::get(ty::node_id_to_type(ccx.tcx, id)).struct {
match ty::get(ty::node_id_to_type(ccx.tcx, id)).sty {
ty::ty_fn(ref fn_ty) => {
let llargtys = type_of_explicit_args(ccx, fn_ty.sig.inputs);
let llretty = type_of::type_of(ccx, fn_ty.sig.output);

12
src/rustc/middle/trans/glue.rs
View File

@ -51,7 +51,7 @@ fn drop_ty_root(bcx: block, v: ValueRef, rooted: bool, t: ty::t) -> block {
fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block {
let _icx = bcx.insn_ctxt("drop_ty_immediate");
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_uniq(_) |
ty::ty_evec(_, ty::vstore_uniq) |
ty::ty_estr(ty::vstore_uniq) => {
@ -68,7 +68,7 @@ fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block {
fn take_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> Result {
let _icx = bcx.insn_ctxt("take_ty_immediate");
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_box(_) | ty::ty_opaque_box |
ty::ty_evec(_, ty::vstore_box) |
ty::ty_estr(ty::vstore_box) => {
@ -97,7 +97,7 @@ fn free_ty(cx: block, v: ValueRef, t: ty::t) -> block {
fn free_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block {
let _icx = bcx.insn_ctxt("free_ty_immediate");
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_uniq(_) |
ty::ty_evec(_, ty::vstore_uniq) |
ty::ty_estr(ty::vstore_uniq) |
@ -268,7 +268,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
// NB: v0 is an *alias* of type t here, not a direct value.
let _icx = bcx.insn_ctxt("make_free_glue");
let ccx = bcx.ccx();
let bcx = match ty::get(t).struct {
let bcx = match ty::get(t).sty {
ty::ty_box(body_mt) => {
let v = Load(bcx, v);
let body = GEPi(bcx, v, [0u, abi::box_field_body]);
@ -357,7 +357,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
// NB: v0 is an *alias* of type t here, not a direct value.
let _icx = bcx.insn_ctxt("make_drop_glue");
let ccx = bcx.ccx();
let bcx = match ty::get(t).struct {
let bcx = match ty::get(t).sty {
ty::ty_box(_) | ty::ty_opaque_box |
ty::ty_estr(ty::vstore_box) | ty::ty_evec(_, ty::vstore_box) => {
decr_refcnt_maybe_free(bcx, Load(bcx, v0), t)
@ -418,7 +418,7 @@ fn decr_refcnt_maybe_free(bcx: block, box_ptr: ValueRef, t: ty::t) -> block {
fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
let _icx = bcx.insn_ctxt("make_take_glue");
// NB: v is a *pointer* to type t here, not a direct value.
let bcx = match ty::get(t).struct {
let bcx = match ty::get(t).sty {
ty::ty_box(_) | ty::ty_opaque_box |
ty::ty_evec(_, ty::vstore_box) | ty::ty_estr(ty::vstore_box) => {
incr_refcnt_of_boxed(bcx, Load(bcx, v)); bcx

2
src/rustc/middle/trans/monomorphize.rs
View File

@ -198,7 +198,7 @@ fn monomorphic_fn(ccx: @crate_ctxt,
fn normalize_for_monomorphization(tcx: ty::ctxt, ty: ty::t) -> Option<ty::t> {
// FIXME[mono] could do this recursively. is that worthwhile? (#2529)
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_box(*) => {
Some(ty::mk_opaque_box(tcx))
}

2
src/rustc/middle/trans/reflect.rs
View File

@ -114,7 +114,7 @@ impl reflector {
debug!("reflect::visit_ty %s",
ty_to_str(bcx.ccx().tcx, t));
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_bot => self.leaf(~"bot"),
ty::ty_nil => self.leaf(~"nil"),
ty::ty_bool => self.leaf(~"bool"),

6
src/rustc/middle/trans/shape.rs
View File

@ -215,7 +215,7 @@ fn add_substr(&dest: ~[u8], src: ~[u8]) {
}
fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_nil | ty::ty_bool | ty::ty_uint(ast::ty_u8) |
ty::ty_bot => ~[shape_u8],
ty::ty_int(ast::ty_i) => ~[s_int(ccx.tcx)],
@ -719,7 +719,7 @@ fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
// Computes the size of the data part of an enum.
fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint {
if cx.enum_sizes.contains_key(t) { return cx.enum_sizes.get(t); }
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_enum(tid, ref substs) => {
// Compute max(variant sizes).
let mut max_size = 0u;
@ -753,7 +753,7 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm})
}
fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
match ty::get(typ).struct {
match ty::get(typ).sty {
ty::ty_box(_) | ty::ty_opaque_box | ty::ty_uniq(_) |
ty::ty_evec(_, ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_box) |
ty::ty_estr(ty::vstore_uniq) | ty::ty_estr(ty::vstore_box) |

4
src/rustc/middle/trans/tvec.rs
View File

@ -19,7 +19,7 @@ use util::common::indenter;
fn expand_boxed_vec_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
let unit_ty = ty::sequence_element_type(tcx, t);
let unboxed_vec_ty = ty::mk_mut_unboxed_vec(tcx, unit_ty);
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_estr(ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_uniq) => {
ty::mk_imm_uniq(tcx, unboxed_vec_ty)
}
@ -431,7 +431,7 @@ fn get_base_and_len(bcx: block,
let ccx = bcx.ccx();
let vt = vec_types(bcx, vec_ty);
let vstore = match ty::get(vt.vec_ty).struct {
let vstore = match ty::get(vt.vec_ty).sty {
ty::ty_estr(vst) | ty::ty_evec(_, vst) => vst,
_ => ty::vstore_uniq
};

6
src/rustc/middle/trans/type_of.rs
View File

@ -55,7 +55,7 @@ fn type_of_non_gc_box(cx: @crate_ctxt, t: ty::t) -> TypeRef {
if t != t_norm {
type_of_non_gc_box(cx, t_norm)
} else {
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_box(mt) => {
T_ptr(T_box(cx, type_of(cx, mt.ty)))
}
@ -88,7 +88,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
return llty;
}
let llty = match ty::get(t).struct {
let llty = match ty::get(t).sty {
ty::ty_nil | ty::ty_bot => T_nil(),
ty::ty_bool => T_bool(),
ty::ty_int(t) => T_int_ty(cx, t),
@ -178,7 +178,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
cx.lltypes.insert(t, llty);
// If this was an enum or class, fill in the type now.
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_enum(did, _) => {
fill_type_of_enum(cx, did, t, llty);
}

6
src/rustc/middle/trans/type_use.rs
View File

@ -45,7 +45,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
ccx.type_use_cache.insert(fn_id, vec::from_elem(n_tps, 3u));
let cx = {ccx: ccx, uses: vec::to_mut(vec::from_elem(n_tps, 0u))};
match ty::get(ty::lookup_item_type(cx.ccx.tcx, fn_id).ty).struct {
match ty::get(ty::lookup_item_type(cx.ccx.tcx, fn_id).ty).sty {
ty::ty_fn(ref fn_ty) => {
for vec::each(fn_ty.sig.inputs) |arg| {
if arg.mode == expl(by_val) { type_needs(cx, use_repr, arg.ty); }
@ -130,7 +130,7 @@ fn type_needs_inner(cx: ctx, use_: uint, ty: ty::t,
enums_seen: @List<def_id>) {
do ty::maybe_walk_ty(ty) |ty| {
if ty::type_has_params(ty) {
match ty::get(ty).struct {
match ty::get(ty).sty {
/*
This previously included ty_box -- that was wrong
because if we cast an @T to an trait (for example) and return
@ -178,7 +178,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
}
expr_cast(base, _) => {
let result_t = ty::node_id_to_type(cx.ccx.tcx, e.id);
match ty::get(result_t).struct {
match ty::get(result_t).sty {
ty::ty_trait(*) => {
// When we're casting to an trait, we need the
// tydesc for the expr that's being cast.

132
src/rustc/middle/ty.rs
View File

@ -247,18 +247,18 @@ impl creader_cache_key : to_bytes::IterBytes {
}
}
type intern_key = {struct: sty, o_def_id: Option<ast::def_id>};
type intern_key = {sty: sty, o_def_id: Option<ast::def_id>};
impl intern_key: cmp::Eq {
pure fn eq(&&other: intern_key) -> bool {
self.struct == other.struct && self.o_def_id == other.o_def_id
self.sty == other.sty && self.o_def_id == other.o_def_id
}
pure fn ne(&&other: intern_key) -> bool { !self.eq(other) }
}
impl intern_key : to_bytes::IterBytes {
fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.struct, &self.o_def_id, lsb0, f);
to_bytes::iter_bytes_2(&self.sty, &self.o_def_id, lsb0, f);
}
}
@ -356,7 +356,7 @@ enum tbox_flag {
needs_subst = 1 | 2 | 8
}
type t_box = @{struct: sty,
type t_box = @{sty: sty,
id: uint,
flags: uint,
o_def_id: Option<ast::def_id>};
@ -854,7 +854,7 @@ fn mk_t(cx: ctxt, +st: sty) -> t { mk_t_with_id(cx, st, None) }
// Interns a type/name combination, stores the resulting box in cx.interner,
// and returns the box as cast to an unsafe ptr (see comments for t above).
fn mk_t_with_id(cx: ctxt, +st: sty, o_def_id: Option<ast::def_id>) -> t {
let key = {struct: st, o_def_id: o_def_id};
let key = {sty: st, o_def_id: o_def_id};
match cx.interner.find(key) {
Some(t) => unsafe { return unsafe::reinterpret_cast(&t); },
_ => ()
@ -911,7 +911,7 @@ fn mk_t_with_id(cx: ctxt, +st: sty, o_def_id: Option<ast::def_id>) -> t {
flags |= get(f.sig.output).flags;
}
}
let t = @{struct: st, id: cx.next_id, flags: flags, o_def_id: o_def_id};
let t = @{sty: st, id: cx.next_id, flags: flags, o_def_id: o_def_id};
cx.interner.insert(key, t);
cx.next_id += 1u;
unsafe { unsafe::reinterpret_cast(&t) }
@ -1046,12 +1046,12 @@ fn mk_opaque_closure_ptr(cx: ctxt, ck: closure_kind) -> t {
fn mk_opaque_box(cx: ctxt) -> t { mk_t(cx, ty_opaque_box) }
fn mk_with_id(cx: ctxt, base: t, def_id: ast::def_id) -> t {
mk_t_with_id(cx, get(base).struct, Some(def_id))
mk_t_with_id(cx, get(base).sty, Some(def_id))
}
// Converts s to its machine type equivalent
pure fn mach_sty(cfg: @session::config, t: t) -> sty {
match get(t).struct {
match get(t).sty {
ty_int(ast::ty_i) => ty_int(cfg.int_type),
ty_uint(ast::ty_u) => ty_uint(cfg.uint_type),
ty_float(ast::ty_f) => ty_float(cfg.float_type),
@ -1079,7 +1079,7 @@ fn walk_ty(ty: t, f: fn(t)) {
fn maybe_walk_ty(ty: t, f: fn(t) -> bool) {
if !f(ty) { return; }
match get(ty).struct {
match get(ty).sty {
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_estr(_) | ty_type | ty_opaque_box | ty_self |
ty_opaque_closure_ptr(_) | ty_infer(_) | ty_param(_) => {
@ -1176,7 +1176,7 @@ fn fold_sty(sty: &sty, fldop: fn(t) -> t) -> sty {
// Folds types from the bottom up.
fn fold_ty(cx: ctxt, t0: t, fldop: fn(t) -> t) -> t {
let sty = fold_sty(&get(t0).struct, |t| fold_ty(cx, fldop(t), fldop));
let sty = fold_sty(&get(t0).sty, |t| fold_ty(cx, fldop(t), fldop));
fldop(mk_t(cx, sty))
}
@ -1213,7 +1213,7 @@ fn fold_regions_and_ty(
}
let tb = ty::get(ty);
match tb.struct {
match tb.sty {
ty::ty_rptr(r, mt) => {
let m_r = fldr(r);
let m_t = fldt(mt.ty);
@ -1288,7 +1288,7 @@ fn fold_region(cx: ctxt, t0: t, fldop: fn(region, bool) -> region) -> t {
fldop: fn(region, bool) -> region) -> t {
let tb = get(t0);
if !tbox_has_flag(tb, has_regions) { return t0; }
match tb.struct {
match tb.sty {
ty_rptr(r, {ty: t1, mutbl: m}) => {
let m_r = fldop(r, under_r);
let m_t1 = do_fold(cx, t1, true, fldop);
@ -1323,7 +1323,7 @@ fn subst_tps(cx: ctxt, tps: &[t], typ: t) -> t {
if tps.len() == 0u { return typ; }
let tb = ty::get(typ);
if !tbox_has_flag(tb, has_params) { return typ; }
match tb.struct {
match tb.sty {
ty_param(p) => tps[p.idx],
ref sty => fold_sty_to_ty(cx, sty, |t| subst_tps(cx, tps, t))
}
@ -1374,7 +1374,7 @@ fn subst(cx: ctxt,
typ: t) -> t {
let tb = get(typ);
if !tbox_has_flag(tb, needs_subst) { return typ; }
match tb.struct {
match tb.sty {
ty_param(p) => substs.tps[p.idx],
ty_self => substs.self_ty.get(),
_ => {
@ -1393,21 +1393,21 @@ fn subst(cx: ctxt,
// Type utilities
fn type_is_nil(ty: t) -> bool { get(ty).struct == ty_nil }
fn type_is_nil(ty: t) -> bool { get(ty).sty == ty_nil }
fn type_is_bot(ty: t) -> bool { get(ty).struct == ty_bot }
fn type_is_bot(ty: t) -> bool { get(ty).sty == ty_bot }
fn type_is_ty_var(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_infer(TyVar(_)) => true,
_ => false
}
}
fn type_is_bool(ty: t) -> bool { get(ty).struct == ty_bool }
fn type_is_bool(ty: t) -> bool { get(ty).sty == ty_bool }
fn type_is_structural(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_rec(_) | ty_class(*) | ty_tup(_) | ty_enum(*) | ty_fn(_) |
ty_trait(*) |
ty_evec(_, vstore_fixed(_)) | ty_estr(vstore_fixed(_)) |
@ -1422,21 +1422,21 @@ fn type_is_copyable(cx: ctxt, ty: t) -> bool {
}
fn type_is_sequence(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_estr(_) | ty_evec(_, _) => true,
_ => false
}
}
fn type_is_str(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_estr(_) => true,
_ => false
}
}
fn sequence_element_type(cx: ctxt, ty: t) -> t {
match get(ty).struct {
match get(ty).sty {
ty_estr(_) => return mk_mach_uint(cx, ast::ty_u8),
ty_evec(mt, _) | ty_unboxed_vec(mt) => return mt.ty,
_ => cx.sess.bug(
@ -1445,7 +1445,7 @@ fn sequence_element_type(cx: ctxt, ty: t) -> t {
}
fn get_element_type(ty: t, i: uint) -> t {
match get(ty).struct {
match get(ty).sty {
ty_rec(flds) => return flds[i].mt.ty,
ty_tup(ts) => return ts[i],
_ => fail ~"get_element_type called on invalid type"
@ -1453,14 +1453,14 @@ fn get_element_type(ty: t, i: uint) -> t {
}
pure fn type_is_box(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_box(_) => return true,
_ => return false
}
}
pure fn type_is_boxed(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_box(_) | ty_opaque_box |
ty_evec(_, vstore_box) | ty_estr(vstore_box) => true,
_ => false
@ -1468,35 +1468,35 @@ pure fn type_is_boxed(ty: t) -> bool {
}
pure fn type_is_region_ptr(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_rptr(_, _) => true,
_ => false
}
}
pure fn type_is_slice(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_evec(_, vstore_slice(_)) | ty_estr(vstore_slice(_)) => true,
_ => return false
}
}
pure fn type_is_unique_box(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_uniq(_) => return true,
_ => return false
}
}
pure fn type_is_unsafe_ptr(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_ptr(_) => return true,
_ => return false
}
}
pure fn type_is_vec(ty: t) -> bool {
return match get(ty).struct {
return match get(ty).sty {
ty_evec(_, _) | ty_unboxed_vec(_) => true,
ty_estr(_) => true,
_ => false
@ -1504,7 +1504,7 @@ pure fn type_is_vec(ty: t) -> bool {
}
pure fn type_is_unique(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_uniq(_) => return true,
ty_evec(_, vstore_uniq) => true,
ty_estr(vstore_uniq) => true,
@ -1518,7 +1518,7 @@ pure fn type_is_unique(ty: t) -> bool {
contents are abstract to rustc.)
*/
pure fn type_is_scalar(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_nil | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
ty_infer(IntVar(_)) | ty_type | ty_ptr(_) => true,
_ => false
@ -1537,7 +1537,7 @@ fn type_needs_drop(cx: ctxt, ty: t) -> bool {
}
let mut accum = false;
let result = match get(ty).struct {
let result = match get(ty).sty {
// scalar types
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
ty_type | ty_ptr(_) | ty_rptr(_, _) |
@ -1620,7 +1620,7 @@ fn type_needs_unwind_cleanup_(cx: ctxt, ty: t,
let mut needs_unwind_cleanup = false;
do maybe_walk_ty(ty) |ty| {
let old_encountered_box = encountered_box;
let result = match get(ty).struct {
let result = match get(ty).sty {
ty_box(_) | ty_opaque_box => {
encountered_box = true;
true
@ -1873,7 +1873,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
// Insert a default in case we loop back on self recursively.
cx.kind_cache.insert(ty, kind_top());
let mut result = match get(ty).struct {
let mut result = match get(ty).sty {
// Scalar and unique types are sendable, constant, and owned
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_ptr(_) => {
@ -2025,7 +2025,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
/// gives a rough estimate of how much space it takes to represent
/// an instance of `ty`. Used for the mode transition.
fn type_size(cx: ctxt, ty: t) -> uint {
match get(ty).struct {
match get(ty).sty {
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_ptr(_) | ty_box(_) | ty_uniq(_) | ty_estr(vstore_uniq) |
ty_trait(*) | ty_rptr(*) | ty_evec(_, vstore_uniq) |
@ -2093,7 +2093,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
ty_to_str(cx, ty));
let r = {
get(r_ty).struct == get(ty).struct ||
get(r_ty).sty == get(ty).sty ||
subtypes_require(cx, seen, r_ty, ty)
};
@ -2110,7 +2110,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
ty_to_str(cx, r_ty),
ty_to_str(cx, ty));
let r = match get(ty).struct {
let r = match get(ty).sty {
ty_nil |
ty_bot |
ty_bool |
@ -2197,7 +2197,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
fn type_structurally_contains(cx: ctxt, ty: t, test: fn(x: &sty) -> bool) ->
bool {
let sty = &get(ty).struct;
let sty = &get(ty).sty;
debug!("type_structurally_contains: %s", ty_to_str(cx, ty));
if test(sty) { return true; }
match *sty {
@ -2251,14 +2251,14 @@ fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool {
}
fn type_is_integral(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_infer(IntVar(_)) | ty_int(_) | ty_uint(_) | ty_bool => true,
_ => false
}
}
fn type_is_fp(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_float(_) => true,
_ => false
}
@ -2269,7 +2269,7 @@ fn type_is_numeric(ty: t) -> bool {
}
fn type_is_signed(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_int(_) => true,
_ => false
}
@ -2279,7 +2279,7 @@ fn type_is_signed(ty: t) -> bool {
// that the cycle collector might care about.
fn type_is_pod(cx: ctxt, ty: t) -> bool {
let mut result = true;
match get(ty).struct {
match get(ty).sty {
// Scalar types
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
ty_type | ty_ptr(_) => result = true,
@ -2334,7 +2334,7 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool {
}
fn type_is_enum(ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_enum(_, _) => return true,
_ => return false
}
@ -2343,7 +2343,7 @@ fn type_is_enum(ty: t) -> bool {
// Whether a type is enum like, that is a enum type with only nullary
// constructors
fn type_is_c_like_enum(cx: ctxt, ty: t) -> bool {
match get(ty).struct {
match get(ty).sty {
ty_enum(did, _) => {
let variants = enum_variants(cx, did);
let some_n_ary = vec::any(*variants, |v| vec::len(v.args) > 0u);
@ -2354,7 +2354,7 @@ fn type_is_c_like_enum(cx: ctxt, ty: t) -> bool {
}
fn type_param(ty: t) -> Option<uint> {
match get(ty).struct {
match get(ty).sty {
ty_param(p) => return Some(p.idx),
_ => {/* fall through */ }
}
@ -2366,7 +2366,7 @@ fn type_param(ty: t) -> Option<uint> {
// The parameter `expl` indicates if this is an *explicit* dereference. Some
// types---notably unsafe ptrs---can only be dereferenced explicitly.
fn deref(cx: ctxt, t: t, expl: bool) -> Option<mt> {
deref_sty(cx, &get(t).struct, expl)
deref_sty(cx, &get(t).sty, expl)
}
fn deref_sty(cx: ctxt, sty: &sty, expl: bool) -> Option<mt> {
match *sty {
@ -2404,7 +2404,7 @@ fn type_autoderef(cx: ctxt, t: t) -> t {
// Returns the type and mutability of t[i]
fn index(cx: ctxt, t: t) -> Option<mt> {
index_sty(cx, &get(t).struct)
index_sty(cx, &get(t).sty)
}
fn index_sty(cx: ctxt, sty: &sty) -> Option<mt> {
@ -2714,49 +2714,49 @@ fn node_id_has_type_params(cx: ctxt, id: ast::node_id) -> bool {
// Type accessors for substructures of types
fn ty_fn_args(fty: t) -> ~[arg] {
match get(fty).struct {
match get(fty).sty {
ty_fn(ref f) => f.sig.inputs,
_ => fail ~"ty_fn_args() called on non-fn type"
}
}
fn ty_fn_proto(fty: t) -> fn_proto {
match get(fty).struct {
match get(fty).sty {
ty_fn(ref f) => f.meta.proto,
_ => fail ~"ty_fn_proto() called on non-fn type"
}
}
fn ty_fn_purity(fty: t) -> ast::purity {
match get(fty).struct {
match get(fty).sty {
ty_fn(ref f) => f.meta.purity,
_ => fail ~"ty_fn_purity() called on non-fn type"
}
}
pure fn ty_fn_ret(fty: t) -> t {
match get(fty).struct {
match get(fty).sty {
ty_fn(ref f) => f.sig.output,
_ => fail ~"ty_fn_ret() called on non-fn type"
}
}
fn ty_fn_ret_style(fty: t) -> ast::ret_style {
match get(fty).struct {
match get(fty).sty {
ty_fn(ref f) => f.meta.ret_style,
_ => fail ~"ty_fn_ret_style() called on non-fn type"
}
}
fn is_fn_ty(fty: t) -> bool {
match get(fty).struct {
match get(fty).sty {
ty_fn(_) => true,
_ => false
}
}
fn ty_region(ty: t) -> region {
match get(ty).struct {
match get(ty).sty {
ty_rptr(r, _) => r,
s => fail fmt!("ty_region() invoked on non-rptr: %?", s)
}
@ -2775,14 +2775,14 @@ fn is_pred_ty(fty: t) -> bool {
/*
fn ty_var_id(typ: t) -> TyVid {
match get(typ).struct {
match get(typ).sty {
ty_infer(TyVar(vid)) => return vid,
_ => { error!("ty_var_id called on non-var ty"); fail; }
}
}
fn int_var_id(typ: t) -> IntVid {
match get(typ).struct {
match get(typ).sty {
ty_infer(IntVar(vid)) => return vid,
_ => { error!("ty_var_integral_id called on ty other than \
ty_var_integral");
@ -3036,7 +3036,7 @@ fn get_field(tcx: ctxt, rec_ty: t, id: ast::ident) -> field {
}
fn get_fields(rec_ty:t) -> ~[field] {
match get(rec_ty).struct {
match get(rec_ty).sty {
ty_rec(fields) => fields,
// Can we check at the caller?
_ => fail ~"get_fields: not a record type"
@ -3055,7 +3055,7 @@ fn method_idx(id: ast::ident, meths: &[method]) -> Option<uint> {
fn param_tys_in_type(ty: t) -> ~[param_ty] {
let mut rslt = ~[];
do walk_ty(ty) |ty| {
match get(ty).struct {
match get(ty).sty {
ty_param(p) => {
vec::push(rslt, p);
}
@ -3072,7 +3072,7 @@ fn occurs_check(tcx: ctxt, sp: span, vid: TyVid, rt: t) {
fn vars_in_type(ty: t) -> ~[TyVid] {
let mut rslt = ~[];
do walk_ty(ty) |ty| {
match get(ty).struct {
match get(ty).sty {
ty_infer(TyVar(v)) => vec::push(rslt, v),
_ => ()
}
@ -3170,7 +3170,7 @@ fn set_default_mode(cx: ctxt, m: ast::mode, m_def: ast::rmode) {
}
fn ty_sort_str(cx: ctxt, t: t) -> ~str {
match get(t).struct {
match get(t).sty {
ty_nil | ty_bot | ty_bool | ty_int(_) |
ty_uint(_) | ty_float(_) | ty_estr(_) |
ty_type | ty_opaque_box | ty_opaque_closure_ptr(_) => {
@ -3405,7 +3405,7 @@ fn impl_traits(cx: ctxt, id: ast::def_id) -> ~[t] {
}
fn ty_to_def_id(ty: t) -> Option<ast::def_id> {
match get(ty).struct {
match get(ty).sty {
ty_trait(id, _, _) | ty_class(id, _) | ty_enum(id, _) => Some(id),
_ => None
}
@ -3512,7 +3512,7 @@ fn enum_is_univariant(cx: ctxt, id: ast::def_id) -> bool {
}
fn type_is_empty(cx: ctxt, t: t) -> bool {
match ty::get(t).struct {
match ty::get(t).sty {
ty_enum(did, _) => (*enum_variants(cx, did)).is_empty(),
_ => false
}
@ -3816,7 +3816,7 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool {
}
fn tycat(ty: t) -> int {
match get(ty).struct {
match get(ty).sty {
ty_bool => tycat_bool,
ty_int(_) | ty_uint(_) | ty_infer(IntVar(_)) => tycat_int,
ty_float(_) => tycat_float,
@ -3866,7 +3866,7 @@ fn normalize_ty(cx: ctxt, t: t) -> t {
None => ()
}
let t = match get(t).struct {
let t = match get(t).sty {
ty_evec(mt, vstore) =>
// This type has a vstore. Get rid of it
mk_evec(cx, normalize_mt(cx, mt), normalize_vstore(vstore)),
@ -3917,7 +3917,7 @@ fn normalize_ty(cx: ctxt, t: t) -> t {
// types, which isn't necessary after #2187
let t = mk_t(cx, mach_sty(cx.sess.targ_cfg, t));
let sty = fold_sty(&get(t).struct, |t| { normalize_ty(cx, t) });
let sty = fold_sty(&get(t).sty, |t| { normalize_ty(cx, t) });
let t_norm = mk_t(cx, sty);
cx.normalized_cache.insert(t, t_norm);
return t_norm;

6
src/rustc/middle/typeck.rs
View File

@ -261,10 +261,10 @@ fn require_same_types(
}
fn arg_is_argv_ty(_tcx: ty::ctxt, a: ty::arg) -> bool {
match ty::get(a.ty).struct {
match ty::get(a.ty).sty {
ty::ty_evec(mt, vstore_uniq) => {
if mt.mutbl != ast::m_imm { return false; }
match ty::get(mt.ty).struct {
match ty::get(mt.ty).sty {
ty::ty_estr(vstore_uniq) => return true,
_ => return false
}
@ -279,7 +279,7 @@ fn check_main_fn_ty(ccx: @crate_ctxt,
let tcx = ccx.tcx;
let main_t = ty::node_id_to_type(tcx, main_id);
match ty::get(main_t).struct {
match ty::get(main_t).sty {
ty::ty_fn(fn_ty) => {
match tcx.items.find(main_id) {
Some(ast_map::node_item(it,_)) => {

4
src/rustc/middle/typeck/astconv.rs
View File

@ -185,7 +185,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope Copy Owned>(
Some(ast::def_ty(type_def_id)) => {
let result = ast_path_to_substs_and_ty(self, rscope,
type_def_id, path);
match ty::get(result.ty).struct {
match ty::get(result.ty).sty {
ty::ty_trait(trait_def_id, substs, _) => {
if vst != ty::vstore_box {
tcx.sess.span_unimpl(path.span,
@ -419,7 +419,7 @@ fn ty_of_arg<AC: ast_conv, RS: region_scope Copy Owned>(
found: a.mode}))
}
ast::infer(_) => {
match ty::get(ty).struct {
match ty::get(ty).sty {
// If the type is not specified, then this must be a fn expr.
// Leave the mode as infer(_), it will get inferred based
// on constraints elsewhere.

22
src/rustc/middle/typeck/check.rs
View File

@ -201,7 +201,7 @@ fn check_bare_fn(ccx: @crate_ctxt,
id: ast::node_id,
self_info: Option<self_info>) {
let fty = ty::node_id_to_type(ccx.tcx, id);
match ty::get(fty).struct {
match ty::get(fty).sty {
ty::ty_fn(ref fn_ty) => {
check_fn(ccx, self_info, fn_ty, decl, body, false, None)
}
@ -763,7 +763,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> ty::t {
match sty {
ty::ty_box(inner) | ty::ty_uniq(inner) |
ty::ty_rptr(_, inner) => {
match ty::get(t1).struct {
match ty::get(t1).sty {
ty::ty_infer(ty::TyVar(v1)) => {
ty::occurs_check(fcx.ccx.tcx, sp, v1,
ty::mk_box(fcx.ccx.tcx, inner));
@ -1127,7 +1127,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
}
let lhs_t = structurally_resolved_type(fcx, lhs.span, lhs_t);
return match (op, ty::get(lhs_t).struct) {
return match (op, ty::get(lhs_t).sty) {
(_, _) if ty::type_is_integral(lhs_t) &&
ast_util::is_shift_binop(op) => {
// Shift is a special case: rhs can be any integral type
@ -1191,7 +1191,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
// If the or operator is used it might be that the user forgot to
// supply the do keyword. Let's be more helpful in that situation.
if op == ast::or {
match ty::get(lhs_resolved_t).struct {
match ty::get(lhs_resolved_t).sty {
ty::ty_fn(_) => {
tcx.sess.span_note(
ex.span, ~"did you forget the 'do' keyword for the call?");
@ -1227,7 +1227,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
match expected {
Some(t) => {
match resolve_type(fcx.infcx(), t, force_tvar) {
Ok(t) => unpack(ty::get(t).struct),
Ok(t) => unpack(ty::get(t).sty),
_ => None
}
}
@ -1500,7 +1500,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
ast::not => {
oprnd_t = structurally_resolved_type(fcx, oprnd.span, oprnd_t);
if !(ty::type_is_integral(oprnd_t) ||
ty::get(oprnd_t).struct == ty::ty_bool) {
ty::get(oprnd_t).sty == ty::ty_bool) {
oprnd_t = check_user_unop(fcx, ~"!", ~"not", expr,
oprnd, oprnd_t);
}
@ -1678,7 +1678,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
}
let block_ty = structurally_resolved_type(
fcx, expr.span, fcx.node_ty(b.id));
match ty::get(block_ty).struct {
match ty::get(block_ty).sty {
ty::ty_fn(fty) => {
fcx.write_ty(expr.id, ty::mk_fn(tcx, FnTyBase {
meta: fty.meta,
@ -1714,7 +1714,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
}
let block_ty = structurally_resolved_type(
fcx, expr.span, fcx.node_ty(b.id));
match ty::get(block_ty).struct {
match ty::get(block_ty).sty {
ty::ty_fn(fty) => {
fcx.write_ty(expr.id, ty::mk_fn(tcx, fty));
}
@ -1742,7 +1742,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
debug!("t_1=%s", fcx.infcx().ty_to_str(t_1));
debug!("t_e=%s", fcx.infcx().ty_to_str(t_e));
match ty::get(t_1).struct {
match ty::get(t_1).sty {
// This will be looked up later on
ty::ty_trait(*) => (),
@ -2461,7 +2461,7 @@ fn structurally_resolved_type(fcx: @fn_ctxt, sp: span, tp: ty::t) -> ty::t {
// Returns the one-level-deep structure of the given type.
fn structure_of(fcx: @fn_ctxt, sp: span, typ: ty::t) -> ty::sty {
ty::get(structurally_resolved_type(fcx, sp, typ)).struct
ty::get(structurally_resolved_type(fcx, sp, typ)).sty
}
fn type_is_integral(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool {
@ -2511,7 +2511,7 @@ fn check_bounds_are_used(ccx: @crate_ctxt,
ccx.tcx, ty,
|_r| {},
|t| {
match ty::get(t).struct {
match ty::get(t).sty {
ty::ty_param({idx, _}) => { tps_used[idx] = true; }
_ => ()
}

12
src/rustc/middle/typeck/check/method.rs
View File

@ -114,7 +114,7 @@ impl lookup {
debug!("method lookup(m_name=%s, self_ty=%s, %?)",
self.fcx.tcx().sess.str_of(self.m_name),
self.fcx.infcx().ty_to_str(self.self_ty),
ty::get(self.self_ty).struct);
ty::get(self.self_ty).sty);
// Determine if there are any inherent methods we can call.
// (An inherent method is one that belongs to no trait, but is
@ -155,7 +155,7 @@ impl lookup {
// autoderef.
// Try each of the possible matching semantics in turn.
for matching_modes.each |mode| {
match ty::get(self.self_ty).struct {
match ty::get(self.self_ty).sty {
ty::ty_box(mt) | ty::ty_uniq(mt) | ty::ty_rptr(_, mt) => {
self.add_candidates_from_type(mt.ty, mode);
}
@ -260,7 +260,7 @@ impl lookup {
}
fn add_candidates_from_type(inner_ty: ty::t, mode: method_lookup_mode) {
match ty::get(inner_ty).struct {
match ty::get(inner_ty).sty {
// First, see whether this is a bounded parameter.
ty::ty_param(p) => {
self.add_candidates_from_param(inner_ty, mode, p.idx, p.def_id);
@ -304,7 +304,7 @@ impl lookup {
loop; /* ok */
}
ty::bound_trait(bound_t) => {
match ty::get(bound_t).struct {
match ty::get(bound_t).sty {
ty::ty_trait(i, substs, _) => (i, substs),
_ => fail ~"add_candidates_from_param: non-trait bound"
}
@ -413,7 +413,7 @@ impl lookup {
}
fn ty_from_did(did: ast::def_id) -> ty::t {
match ty::get(ty::lookup_item_type(self.tcx(), did).ty).struct {
match ty::get(ty::lookup_item_type(self.tcx(), did).ty).sty {
ty::ty_fn(ref fty) => {
ty::mk_fn(self.tcx(), FnTyBase {
meta: FnMeta {proto: ty::proto_vstore(ty::vstore_box),
@ -434,7 +434,7 @@ impl lookup {
}
} else {
match check ty::get(csearch::get_type(self.tcx(), did).ty)
.struct {
.sty {
ty::ty_fn(fty) {
ty::mk_fn(self.tcx(), {proto: ast::proto_box with fty})

4
src/rustc/middle/typeck/check/regionck.rs
View File

@ -189,7 +189,7 @@ fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) {
match rcx.resolve_node_type(e.id) {
result::Err(_) => { return; /* typeck will fail anyhow */ }
result::Ok(target_ty) => {
match ty::get(target_ty).struct {
match ty::get(target_ty).sty {
ty::ty_trait(_, substs, _) => {
let trait_region = match substs.self_r {
Some(r) => {r}
@ -215,7 +215,7 @@ fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) {
match rcx.resolve_node_type(e.id) {
result::Err(_) => return, // Typechecking will fail anyhow.
result::Ok(function_type) => {
match ty::get(function_type).struct {
match ty::get(function_type).sty {
ty::ty_fn(ref fn_ty) => {
match fn_ty.meta.proto {
proto_vstore(vstore_slice(region)) => {

2
src/rustc/middle/typeck/check/regionmanip.rs
View File

@ -66,7 +66,7 @@ fn replace_bound_regions_in_fn_ty(
return {isr: isr,
self_info: new_self_info,
fn_ty: match ty::get(t_fn).struct { ty::ty_fn(o) => o,
fn_ty: match ty::get(t_fn).sty { ty::ty_fn(o) => o,
_ => tcx.sess.bug(~"replace_bound_regions_in_fn_ty: impossible")}};

16
src/rustc/middle/typeck/check/vtable.rs
View File

@ -69,7 +69,7 @@ fn fixup_substs(fcx: @fn_ctxt, expr: @ast::expr,
// use a dummy type just to package up the substs that need fixing up
let t = ty::mk_trait(tcx, id, substs, ty::vstore_slice(ty::re_static));
do fixup_ty(fcx, expr, t, is_early).map |t_f| {
match ty::get(t_f).struct {
match ty::get(t_f).sty {
ty::ty_trait(_, substs_f, _) => substs_f,
_ => fail ~"t_f should be a trait"
}
@ -99,7 +99,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
let _i = indenter();
let tcx = fcx.ccx.tcx;
let (trait_id, trait_substs) = match ty::get(trait_ty).struct {
let (trait_id, trait_substs) = match ty::get(trait_ty).sty {
ty::ty_trait(did, substs, _) => (did, substs),
_ => tcx.sess.impossible_case(expr.span,
"lookup_vtable: \
@ -117,7 +117,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
}
};
match ty::get(ty).struct {
match ty::get(ty).sty {
ty::ty_param({idx: n, def_id: did}) => {
let mut n_bound = 0;
for vec::each(*tcx.ty_param_bounds.get(did.node)) |bound| {
@ -127,7 +127,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
/* ignore */
}
ty::bound_trait(ity) => {
match ty::get(ity).struct {
match ty::get(ity).sty {
ty::ty_trait(idid, _, _) => {
if trait_id == idid {
debug!("(checking vtable) @0 relating \
@ -214,7 +214,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
// unify it with trait_ty in order to get all
// the ty vars sorted out.
for vec::each(ty::impl_traits(tcx, im.did)) |of_ty| {
match ty::get(of_ty).struct {
match ty::get(of_ty).sty {
ty::ty_trait(id, _, _) => {
// Not the trait we're looking for
if id != trait_id { loop; }
@ -389,8 +389,8 @@ fn connect_trait_tps(fcx: @fn_ctxt, expr: @ast::expr, impl_tys: ~[ty::t],
let ity = ty::impl_traits(tcx, impl_did)[0];
let trait_ty = ty::subst_tps(tcx, impl_tys, ity);
debug!("(connect trait tps) trait type is %?, impl did is %?",
ty::get(trait_ty).struct, impl_did);
match ty::get(trait_ty).struct {
ty::get(trait_ty).sty, impl_did);
match ty::get(trait_ty).sty {
ty::ty_trait(_, substs, _) => {
vec::iter2(substs.tps, trait_tys,
|a, b| demand::suptype(fcx, expr.span, a, b));
@ -450,7 +450,7 @@ fn early_resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, is_early: bool) {
}
ast::expr_cast(src, _) => {
let target_ty = fcx.expr_ty(ex);
match ty::get(target_ty).struct {
match ty::get(target_ty).sty {
ty::ty_trait(*) => {
/*
Look up vtables for the type we're casting to,

8
src/rustc/middle/typeck/coherence.rs
View File

@ -55,7 +55,7 @@ fn get_base_type(inference_context: infer_ctxt, span: span, original_type: t)
}
}
match get(resolved_type).struct {
match get(resolved_type).sty {
ty_box(base_mutability_and_type) |
ty_uniq(base_mutability_and_type) |
ty_ptr(base_mutability_and_type) |
@ -76,7 +76,7 @@ fn get_base_type(inference_context: infer_ctxt, span: span, original_type: t)
ty_param(*) | ty_self | ty_type | ty_opaque_box |
ty_opaque_closure_ptr(*) | ty_unboxed_vec(*) => {
debug!("(getting base type) no base type; found %?",
get(original_type).struct);
get(original_type).sty);
None
}
}
@ -93,7 +93,7 @@ fn get_base_type_def_id(inference_context: infer_ctxt,
return None;
}
Some(base_type) => {
match get(base_type).struct {
match get(base_type).sty {
ty_enum(def_id, _) |
ty_class(def_id, _) |
ty_trait(def_id, _, _) => {
@ -694,7 +694,7 @@ impl CoherenceChecker {
// Record all the trait methods.
for associated_traits.each |trait_type| {
match get(trait_type).struct {
match get(trait_type).sty {
ty_trait(trait_id, _, _) => {
self.add_trait_method(trait_id, implementation);
}

4
src/rustc/middle/typeck/collect.rs
View File

@ -603,7 +603,7 @@ fn instantiate_trait_ref(ccx: @crate_ctxt, t: @ast::trait_ref,
ast::def_ty(t_id) => {
let tpt = astconv::ast_path_to_ty(ccx, rscope, t_id, t.path,
t.ref_id);
match ty::get(tpt.ty).struct {
match ty::get(tpt.ty).sty {
ty::ty_trait(*) => {
(t_id, tpt)
}
@ -732,7 +732,7 @@ fn compute_bounds(ccx: @crate_ctxt,
ast::bound_owned => ~[ty::bound_owned],
ast::bound_trait(t) => {
let ity = ast_ty_to_ty(ccx, empty_rscope, t);
match ty::get(ity).struct {
match ty::get(ity).sty {
ty::ty_trait(*) => {
~[ty::bound_trait(ity)]
}

4
src/rustc/middle/typeck/infer/assignment.rs
View File

@ -70,7 +70,7 @@ impl Assign {
b.to_str(self.infcx));
let _r = indenter();
match (ty::get(a).struct, ty::get(b).struct) {
match (ty::get(a).sty, ty::get(b).sty) {
(ty::ty_bot, _) => {
Ok(None)
}
@ -130,7 +130,7 @@ priv impl Assign {
(Some(a_bnd), Some(b_bnd)) => {
// check for a case where a non-region pointer (@, ~) is
// being assigned to a region pointer:
match (ty::get(a_bnd).struct, ty::get(b_bnd).struct) {
match (ty::get(a_bnd).sty, ty::get(b_bnd).sty) {
(ty::ty_box(_), ty::ty_rptr(r_b, mt_b)) => {
let nr_b = ty::mk_box(self.infcx.tcx,
{ty: mt_b.ty, mutbl: m_const});

6
src/rustc/middle/typeck/infer/combine.rs
View File

@ -354,7 +354,7 @@ fn super_tys<C:combine>(
self: &C, a: ty::t, b: ty::t) -> cres<ty::t> {
let tcx = self.infcx().tcx;
match (ty::get(a).struct, ty::get(b).struct) {
match (ty::get(a).sty, ty::get(b).sty) {
// The "subtype" ought to be handling cases involving bot or var:
(ty::ty_bot, _) |
(_, ty::ty_bot) |
@ -383,8 +383,8 @@ fn super_tys<C:combine>(
(ty::ty_int(_), _) |
(ty::ty_uint(_), _) |
(ty::ty_float(_), _) => {
let as_ = ty::get(a).struct;
let bs = ty::get(b).struct;
let as_ = ty::get(a).sty;
let bs = ty::get(b).sty;
if as_ == bs {
Ok(a)
} else {

2
src/rustc/middle/typeck/infer/integral.rs
View File

@ -55,7 +55,7 @@ fn single_type_contained_in(tcx: ty::ctxt, a: int_ty_set) ->
fn convert_integral_ty_to_int_ty_set(tcx: ty::ctxt, t: ty::t)
-> int_ty_set {
match get(t).struct {
match get(t).sty {
ty_int(int_ty) => match int_ty {
ast::ty_i8 => int_ty_set(INT_TY_SET_i8),
ast::ty_i16 => int_ty_set(INT_TY_SET_i16),

2
src/rustc/middle/typeck/infer/lattice.rs
View File

@ -42,7 +42,7 @@ fn lattice_tys<L:lattice_ops combine>(
b.to_str(self.infcx()));
if a == b { return Ok(a); }
do indent {
match (ty::get(a).struct, ty::get(b).struct) {
match (ty::get(a).sty, ty::get(b).sty) {
(ty::ty_bot, _) => self.ty_bot(b),
(_, ty::ty_bot) => self.ty_bot(a),

2
src/rustc/middle/typeck/infer/resolve.rs
View File

@ -112,7 +112,7 @@ impl resolve_state {
indent(fn&() -> ty::t {
if !ty::type_needs_infer(typ) { return typ; }
match ty::get(typ).struct {
match ty::get(typ).sty {
ty::ty_infer(TyVar(vid)) => {
self.resolve_ty_var(vid)
}

2
src/rustc/middle/typeck/infer/sub.rs
View File

@ -101,7 +101,7 @@ impl Sub: combine {
a.to_str(self.infcx), b.to_str(self.infcx));
if a == b { return Ok(a); }
do indent {
match (ty::get(a).struct, ty::get(b).struct) {
match (ty::get(a).sty, ty::get(b).sty) {
(ty::ty_bot, _) => {
Ok(a)
}

4
src/rustc/util/ppaux.rs
View File

@ -284,7 +284,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
for inputs.each |a| { vec::push(strs, fn_input_to_str(cx, a)); }
s += str::connect(strs, ~", ");
s += ~")";
if ty::get(output).struct != ty_nil {
if ty::get(output).sty != ty_nil {
s += ~" -> ";
match cf {
ast::noreturn => { s += ~"!"; }
@ -310,7 +310,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
}
// pretty print the structural type representation:
return match ty::get(typ).struct {
return match ty::get(typ).sty {
ty_nil => ~"()",
ty_bot => ~"_|_",
ty_bool => ~"bool",

4
src/test/run-pass/alias-uninit-value.rs
View File

@ -6,10 +6,10 @@ use option::None;
enum sty { ty_nil, }
type raw_t = {struct: sty, cname: Option<~str>, hash: uint};
type raw_t = {struct_: sty, cname: Option<~str>, hash: uint};
fn mk_raw_ty(st: sty, cname: Option<~str>) -> raw_t {
return {struct: st, cname: cname, hash: 0u};
return {struct_: st, cname: cname, hash: 0u};
}
fn main() { mk_raw_ty(ty_nil, None::<~str>); }