auto merge of #6022 : catamorphism/rust/warning-police, r=catamorphism
This commit is contained in:
commit
88ccee78a8
29 changed files with 312 additions and 330 deletions
|
@ -17,9 +17,9 @@ pub fn stdout() -> StdWriter { fail!() }
|
||||||
|
|
||||||
pub fn stderr() -> StdReader { fail!() }
|
pub fn stderr() -> StdReader { fail!() }
|
||||||
|
|
||||||
pub fn print(s: &str) { fail!() }
|
pub fn print(_s: &str) { fail!() }
|
||||||
|
|
||||||
pub fn println(s: &str) { fail!() }
|
pub fn println(_s: &str) { fail!() }
|
||||||
|
|
||||||
pub enum StdStream {
|
pub enum StdStream {
|
||||||
StdIn,
|
StdIn,
|
||||||
|
|
|
@ -11,7 +11,7 @@
|
||||||
use option::*;
|
use option::*;
|
||||||
use result::*;
|
use result::*;
|
||||||
|
|
||||||
use super::io::net::ip::{IpAddr, Ipv4};
|
use super::io::net::ip::{IpAddr, Ipv4}; // n.b. Ipv4 is used only in tests
|
||||||
use super::uv::*;
|
use super::uv::*;
|
||||||
use super::rtio::*;
|
use super::rtio::*;
|
||||||
use ops::Drop;
|
use ops::Drop;
|
||||||
|
|
|
@ -549,7 +549,7 @@ pub fn spawn_raw(opts: TaskOpts, f: ~fn()) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn spawn_raw_newsched(opts: TaskOpts, f: ~fn()) {
|
fn spawn_raw_newsched(_opts: TaskOpts, f: ~fn()) {
|
||||||
use rt::sched::*;
|
use rt::sched::*;
|
||||||
|
|
||||||
let mut sched = local_sched::take();
|
let mut sched = local_sched::take();
|
||||||
|
|
|
@ -247,7 +247,7 @@ fn doc_transformed_self_ty(doc: ebml::Doc,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn item_type(item_id: ast::def_id, item: ebml::Doc,
|
pub fn item_type(_item_id: ast::def_id, item: ebml::Doc,
|
||||||
tcx: ty::ctxt, cdata: cmd) -> ty::t {
|
tcx: ty::ctxt, cdata: cmd) -> ty::t {
|
||||||
doc_type(item, tcx, cdata)
|
doc_type(item, tcx, cdata)
|
||||||
}
|
}
|
||||||
|
|
|
@ -279,28 +279,28 @@ fn parse_trait_ref(st: @mut PState, conv: conv_did) -> ty::TraitRef {
|
||||||
|
|
||||||
fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
|
fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
|
||||||
match next(st) {
|
match next(st) {
|
||||||
'n' => return ty::mk_nil(st.tcx),
|
'n' => return ty::mk_nil(),
|
||||||
'z' => return ty::mk_bot(st.tcx),
|
'z' => return ty::mk_bot(),
|
||||||
'b' => return ty::mk_bool(st.tcx),
|
'b' => return ty::mk_bool(),
|
||||||
'i' => return ty::mk_int(st.tcx),
|
'i' => return ty::mk_int(),
|
||||||
'u' => return ty::mk_uint(st.tcx),
|
'u' => return ty::mk_uint(),
|
||||||
'l' => return ty::mk_float(st.tcx),
|
'l' => return ty::mk_float(),
|
||||||
'M' => {
|
'M' => {
|
||||||
match next(st) {
|
match next(st) {
|
||||||
'b' => return ty::mk_mach_uint(st.tcx, ast::ty_u8),
|
'b' => return ty::mk_mach_uint(ast::ty_u8),
|
||||||
'w' => return ty::mk_mach_uint(st.tcx, ast::ty_u16),
|
'w' => return ty::mk_mach_uint(ast::ty_u16),
|
||||||
'l' => return ty::mk_mach_uint(st.tcx, ast::ty_u32),
|
'l' => return ty::mk_mach_uint(ast::ty_u32),
|
||||||
'd' => return ty::mk_mach_uint(st.tcx, ast::ty_u64),
|
'd' => return ty::mk_mach_uint(ast::ty_u64),
|
||||||
'B' => return ty::mk_mach_int(st.tcx, ast::ty_i8),
|
'B' => return ty::mk_mach_int(ast::ty_i8),
|
||||||
'W' => return ty::mk_mach_int(st.tcx, ast::ty_i16),
|
'W' => return ty::mk_mach_int(ast::ty_i16),
|
||||||
'L' => return ty::mk_mach_int(st.tcx, ast::ty_i32),
|
'L' => return ty::mk_mach_int(ast::ty_i32),
|
||||||
'D' => return ty::mk_mach_int(st.tcx, ast::ty_i64),
|
'D' => return ty::mk_mach_int(ast::ty_i64),
|
||||||
'f' => return ty::mk_mach_float(st.tcx, ast::ty_f32),
|
'f' => return ty::mk_mach_float(ast::ty_f32),
|
||||||
'F' => return ty::mk_mach_float(st.tcx, ast::ty_f64),
|
'F' => return ty::mk_mach_float(ast::ty_f64),
|
||||||
_ => fail!(~"parse_ty: bad numeric type")
|
_ => fail!(~"parse_ty: bad numeric type")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
'c' => return ty::mk_char(st.tcx),
|
'c' => return ty::mk_char(),
|
||||||
't' => {
|
't' => {
|
||||||
assert!((next(st) == '['));
|
assert!((next(st) == '['));
|
||||||
let def = parse_def(st, NominalType, conv);
|
let def = parse_def(st, NominalType, conv);
|
||||||
|
|
|
@ -211,7 +211,7 @@ pub fn is_useful(cx: @MatchCheckCtxt, m: &matrix, v: &[@pat]) -> useful {
|
||||||
let real_pat = match m.find(|r| r[0].id != 0) {
|
let real_pat = match m.find(|r| r[0].id != 0) {
|
||||||
Some(r) => r[0], None => v[0]
|
Some(r) => r[0], None => v[0]
|
||||||
};
|
};
|
||||||
let left_ty = if real_pat.id == 0 { ty::mk_nil(cx.tcx) }
|
let left_ty = if real_pat.id == 0 { ty::mk_nil() }
|
||||||
else { ty::node_id_to_type(cx.tcx, real_pat.id) };
|
else { ty::node_id_to_type(cx.tcx, real_pat.id) };
|
||||||
|
|
||||||
match pat_ctor_id(cx, v[0]) {
|
match pat_ctor_id(cx, v[0]) {
|
||||||
|
|
|
@ -749,7 +749,7 @@ pub impl mem_categorization_ctxt {
|
||||||
fn cat_index<N:ast_node>(&self,
|
fn cat_index<N:ast_node>(&self,
|
||||||
elt: N,
|
elt: N,
|
||||||
base_cmt: cmt) -> cmt {
|
base_cmt: cmt) -> cmt {
|
||||||
let mt = match ty::index(self.tcx, base_cmt.ty) {
|
let mt = match ty::index(base_cmt.ty) {
|
||||||
Some(mt) => mt,
|
Some(mt) => mt,
|
||||||
None => {
|
None => {
|
||||||
self.tcx.sess.span_bug(
|
self.tcx.sess.span_bug(
|
||||||
|
|
|
@ -1073,8 +1073,7 @@ pub fn compare_values(cx: block,
|
||||||
|
|
||||||
match ty::get(rhs_t).sty {
|
match ty::get(rhs_t).sty {
|
||||||
ty::ty_estr(ty::vstore_uniq) => {
|
ty::ty_estr(ty::vstore_uniq) => {
|
||||||
let scratch_result = scratch_datum(cx, ty::mk_bool(cx.tcx()),
|
let scratch_result = scratch_datum(cx, ty::mk_bool(), false);
|
||||||
false);
|
|
||||||
let scratch_lhs = alloca(cx, val_ty(lhs));
|
let scratch_lhs = alloca(cx, val_ty(lhs));
|
||||||
Store(cx, lhs, scratch_lhs);
|
Store(cx, lhs, scratch_lhs);
|
||||||
let scratch_rhs = alloca(cx, val_ty(rhs));
|
let scratch_rhs = alloca(cx, val_ty(rhs));
|
||||||
|
@ -1092,8 +1091,7 @@ pub fn compare_values(cx: block,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
ty::ty_estr(_) => {
|
ty::ty_estr(_) => {
|
||||||
let scratch_result = scratch_datum(cx, ty::mk_bool(cx.tcx()),
|
let scratch_result = scratch_datum(cx, ty::mk_bool(), false);
|
||||||
false);
|
|
||||||
let did = cx.tcx().lang_items.str_eq_fn();
|
let did = cx.tcx().lang_items.str_eq_fn();
|
||||||
let bcx = callee::trans_lang_call(cx, did,
|
let bcx = callee::trans_lang_call(cx, did,
|
||||||
~[lhs, rhs],
|
~[lhs, rhs],
|
||||||
|
|
|
@ -50,7 +50,6 @@ use core::option::{Option, Some, None};
|
||||||
use core::vec;
|
use core::vec;
|
||||||
|
|
||||||
use lib::llvm::{ValueRef, TypeRef, True, IntEQ, IntNE};
|
use lib::llvm::{ValueRef, TypeRef, True, IntEQ, IntNE};
|
||||||
use lib::llvm::llvm::LLVMDumpValue;
|
|
||||||
use middle::trans::_match;
|
use middle::trans::_match;
|
||||||
use middle::trans::build::*;
|
use middle::trans::build::*;
|
||||||
use middle::trans::common::*;
|
use middle::trans::common::*;
|
||||||
|
@ -136,7 +135,7 @@ fn represent_type_uncached(cx: @CrateContext, t: ty::t) -> Repr {
|
||||||
let packed = ty::lookup_packed(cx.tcx, def_id);
|
let packed = ty::lookup_packed(cx.tcx, def_id);
|
||||||
let dtor = ty::ty_dtor(cx.tcx, def_id).is_present();
|
let dtor = ty::ty_dtor(cx.tcx, def_id).is_present();
|
||||||
let ftys =
|
let ftys =
|
||||||
if dtor { ftys + [ty::mk_bool(cx.tcx)] } else { ftys };
|
if dtor { ftys + [ty::mk_bool()] } else { ftys };
|
||||||
return Univariant(mk_struct(cx, ftys, packed), dtor)
|
return Univariant(mk_struct(cx, ftys, packed), dtor)
|
||||||
}
|
}
|
||||||
ty::ty_enum(def_id, ref substs) => {
|
ty::ty_enum(def_id, ref substs) => {
|
||||||
|
@ -204,7 +203,7 @@ fn represent_type_uncached(cx: @CrateContext, t: ty::t) -> Repr {
|
||||||
}
|
}
|
||||||
|
|
||||||
// The general case.
|
// The general case.
|
||||||
let discr = ~[ty::mk_int(cx.tcx)];
|
let discr = ~[ty::mk_int()];
|
||||||
return General(cases.map(|c| mk_struct(cx, discr + c.tys, false)))
|
return General(cases.map(|c| mk_struct(cx, discr + c.tys, false)))
|
||||||
}
|
}
|
||||||
_ => cx.sess.bug(~"adt::represent_type called on non-ADT type")
|
_ => cx.sess.bug(~"adt::represent_type called on non-ADT type")
|
||||||
|
|
|
@ -707,7 +707,7 @@ pub fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
|
||||||
substs.tps, f);
|
substs.tps, f);
|
||||||
}
|
}
|
||||||
(_match::switch, Some(lldiscrim_a)) => {
|
(_match::switch, Some(lldiscrim_a)) => {
|
||||||
cx = f(cx, lldiscrim_a, ty::mk_int(cx.tcx()));
|
cx = f(cx, lldiscrim_a, ty::mk_int());
|
||||||
let unr_cx = sub_block(cx, ~"enum-iter-unr");
|
let unr_cx = sub_block(cx, ~"enum-iter-unr");
|
||||||
Unreachable(unr_cx);
|
Unreachable(unr_cx);
|
||||||
let llswitch = Switch(cx, lldiscrim_a, unr_cx.llbb,
|
let llswitch = Switch(cx, lldiscrim_a, unr_cx.llbb,
|
||||||
|
@ -2361,7 +2361,7 @@ pub fn create_entry_wrapper(ccx: @CrateContext,
|
||||||
}
|
}
|
||||||
|
|
||||||
fn create_main(ccx: @CrateContext, main_llfn: ValueRef) -> ValueRef {
|
fn create_main(ccx: @CrateContext, main_llfn: ValueRef) -> ValueRef {
|
||||||
let nt = ty::mk_nil(ccx.tcx);
|
let nt = ty::mk_nil();
|
||||||
let llfty = type_of_fn(ccx, ~[], nt);
|
let llfty = type_of_fn(ccx, ~[], nt);
|
||||||
let llfdecl = decl_fn(ccx.llmod, ~"_rust_main",
|
let llfdecl = decl_fn(ccx.llmod, ~"_rust_main",
|
||||||
lib::llvm::CCallConv, llfty);
|
lib::llvm::CCallConv, llfty);
|
||||||
|
@ -2407,9 +2407,8 @@ pub fn create_entry_wrapper(ccx: @CrateContext,
|
||||||
unsafe {
|
unsafe {
|
||||||
llvm::LLVMPositionBuilderAtEnd(bld, llbb);
|
llvm::LLVMPositionBuilderAtEnd(bld, llbb);
|
||||||
|
|
||||||
let crate_map = ccx.crate_map;
|
|
||||||
let start_def_id = ccx.tcx.lang_items.start_fn();
|
let start_def_id = ccx.tcx.lang_items.start_fn();
|
||||||
let start_fn = if start_def_id.crate == ast::local_crate {
|
if start_def_id.crate == ast::local_crate {
|
||||||
ccx.sess.bug(~"start lang item is never in the local crate")
|
ccx.sess.bug(~"start lang item is never in the local crate")
|
||||||
} else {
|
} else {
|
||||||
let start_fn_type = csearch::get_type(ccx.tcx,
|
let start_fn_type = csearch::get_type(ccx.tcx,
|
||||||
|
@ -2727,7 +2726,7 @@ pub fn trans_constant(ccx: @CrateContext, it: @ast::item) {
|
||||||
path_name(variant.node.name),
|
path_name(variant.node.name),
|
||||||
path_name(special_idents::descrim)
|
path_name(special_idents::descrim)
|
||||||
]);
|
]);
|
||||||
let s = @mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx));
|
let s = @mangle_exported_name(ccx, p, ty::mk_int());
|
||||||
let disr_val = vi[i].disr_val;
|
let disr_val = vi[i].disr_val;
|
||||||
note_unique_llvm_symbol(ccx, s);
|
note_unique_llvm_symbol(ccx, s);
|
||||||
let discrim_gvar = str::as_c_str(*s, |buf| {
|
let discrim_gvar = str::as_c_str(*s, |buf| {
|
||||||
|
|
|
@ -261,8 +261,7 @@ pub fn build_closure(bcx0: block,
|
||||||
include_ret_handle: Option<ValueRef>) -> ClosureResult {
|
include_ret_handle: Option<ValueRef>) -> ClosureResult {
|
||||||
let _icx = bcx0.insn_ctxt("closure::build_closure");
|
let _icx = bcx0.insn_ctxt("closure::build_closure");
|
||||||
// If we need to, package up the iterator body to call
|
// If we need to, package up the iterator body to call
|
||||||
let bcx = bcx0;;
|
let bcx = bcx0;
|
||||||
let ccx = bcx.ccx(), tcx = ccx.tcx;
|
|
||||||
|
|
||||||
// Package up the captured upvars
|
// Package up the captured upvars
|
||||||
let mut env_vals = ~[];
|
let mut env_vals = ~[];
|
||||||
|
@ -290,7 +289,7 @@ pub fn build_closure(bcx0: block,
|
||||||
// variables:
|
// variables:
|
||||||
for include_ret_handle.each |flagptr| {
|
for include_ret_handle.each |flagptr| {
|
||||||
// Flag indicating we have returned (a by-ref bool):
|
// Flag indicating we have returned (a by-ref bool):
|
||||||
let flag_datum = Datum {val: *flagptr, ty: ty::mk_bool(tcx),
|
let flag_datum = Datum {val: *flagptr, ty: ty::mk_bool(),
|
||||||
mode: ByRef, source: ZeroMem};
|
mode: ByRef, source: ZeroMem};
|
||||||
env_vals.push(EnvValue {action: EnvRef,
|
env_vals.push(EnvValue {action: EnvRef,
|
||||||
datum: flag_datum});
|
datum: flag_datum});
|
||||||
|
@ -302,7 +301,7 @@ pub fn build_closure(bcx0: block,
|
||||||
None => bcx.fcx.llretptr.get()
|
None => bcx.fcx.llretptr.get()
|
||||||
};
|
};
|
||||||
let ret_casted = PointerCast(bcx, ret_true, T_ptr(T_nil()));
|
let ret_casted = PointerCast(bcx, ret_true, T_ptr(T_nil()));
|
||||||
let ret_datum = Datum {val: ret_casted, ty: ty::mk_nil(tcx),
|
let ret_datum = Datum {val: ret_casted, ty: ty::mk_nil(),
|
||||||
mode: ByRef, source: ZeroMem};
|
mode: ByRef, source: ZeroMem};
|
||||||
env_vals.push(EnvValue {action: EnvRef,
|
env_vals.push(EnvValue {action: EnvRef,
|
||||||
datum: ret_datum});
|
datum: ret_datum});
|
||||||
|
@ -420,7 +419,7 @@ pub fn trans_expr_fn(bcx: block,
|
||||||
}
|
}
|
||||||
|
|
||||||
let real_return_type = if is_loop_body.is_some() {
|
let real_return_type = if is_loop_body.is_some() {
|
||||||
ty::mk_bool(bcx.tcx())
|
ty::mk_bool()
|
||||||
} else {
|
} else {
|
||||||
ty::ty_fn_ret(fty)
|
ty::ty_fn_ret(fty)
|
||||||
};
|
};
|
||||||
|
|
|
@ -999,9 +999,9 @@ pub fn T_opaque_vec(targ_cfg: @session::config) -> TypeRef {
|
||||||
pub fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
|
pub fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
|
||||||
let ptr = ty::mk_ptr(
|
let ptr = ty::mk_ptr(
|
||||||
tcx,
|
tcx,
|
||||||
ty::mt {ty: ty::mk_nil(tcx), mutbl: ast::m_imm}
|
ty::mt {ty: ty::mk_nil(), mutbl: ast::m_imm}
|
||||||
);
|
);
|
||||||
return ty::mk_tup(tcx, ~[ty::mk_uint(tcx), ty::mk_type(tcx),
|
return ty::mk_tup(tcx, ~[ty::mk_uint(), ty::mk_type(tcx),
|
||||||
ptr, ptr,
|
ptr, ptr,
|
||||||
t]);
|
t]);
|
||||||
}
|
}
|
||||||
|
|
|
@ -560,7 +560,7 @@ fn create_boxed_type(cx: @CrateContext, contents: ty::t,
|
||||||
let fname = filename_from_span(cx, span);
|
let fname = filename_from_span(cx, span);
|
||||||
let file_node = create_file(cx, fname);
|
let file_node = create_file(cx, fname);
|
||||||
//let cu_node = create_compile_unit_metadata(cx, fname);
|
//let cu_node = create_compile_unit_metadata(cx, fname);
|
||||||
let int_t = ty::mk_int(cx.tcx);
|
let int_t = ty::mk_int();
|
||||||
let refcount_type = create_basic_type(cx, int_t, span);
|
let refcount_type = create_basic_type(cx, int_t, span);
|
||||||
let name = ty_to_str(cx.tcx, contents);
|
let name = ty_to_str(cx.tcx, contents);
|
||||||
let scx = create_structure(file_node, @fmt!("box<%s>", name), 0);
|
let scx = create_structure(file_node, @fmt!("box<%s>", name), 0);
|
||||||
|
@ -643,7 +643,7 @@ fn create_boxed_vec(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t,
|
||||||
let elem_ty_md = create_ty(cx, elem_t, vec_ty_span);
|
let elem_ty_md = create_ty(cx, elem_t, vec_ty_span);
|
||||||
let vec_scx = create_structure(file_node,
|
let vec_scx = create_structure(file_node,
|
||||||
@/*bad*/ copy ty_to_str(cx.tcx, vec_t), 0);
|
@/*bad*/ copy ty_to_str(cx.tcx, vec_t), 0);
|
||||||
let size_t_type = create_basic_type(cx, ty::mk_uint(cx.tcx), vec_ty_span);
|
let size_t_type = create_basic_type(cx, ty::mk_uint(), vec_ty_span);
|
||||||
add_member(vec_scx, ~"fill", 0, sys::size_of::<libc::size_t>() as int,
|
add_member(vec_scx, ~"fill", 0, sys::size_of::<libc::size_t>() as int,
|
||||||
sys::min_align_of::<libc::size_t>() as int, size_t_type.node);
|
sys::min_align_of::<libc::size_t>() as int, size_t_type.node);
|
||||||
add_member(vec_scx, ~"alloc", 0, sys::size_of::<libc::size_t>() as int,
|
add_member(vec_scx, ~"alloc", 0, sys::size_of::<libc::size_t>() as int,
|
||||||
|
@ -666,7 +666,7 @@ fn create_boxed_vec(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t,
|
||||||
};
|
};
|
||||||
|
|
||||||
let box_scx = create_structure(file_node, @fmt!("box<%s>", name), 0);
|
let box_scx = create_structure(file_node, @fmt!("box<%s>", name), 0);
|
||||||
let int_t = ty::mk_int(cx.tcx);
|
let int_t = ty::mk_int();
|
||||||
let refcount_type = create_basic_type(cx, int_t, vec_ty_span);
|
let refcount_type = create_basic_type(cx, int_t, vec_ty_span);
|
||||||
add_member(box_scx, ~"refcnt", 0, sys::size_of::<uint>() as int,
|
add_member(box_scx, ~"refcnt", 0, sys::size_of::<uint>() as int,
|
||||||
sys::min_align_of::<uint>() as int, refcount_type.node);
|
sys::min_align_of::<uint>() as int, refcount_type.node);
|
||||||
|
@ -692,7 +692,7 @@ fn create_vec_slice(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t, span: span)
|
||||||
let fname = filename_from_span(cx, span);
|
let fname = filename_from_span(cx, span);
|
||||||
let file_node = create_file(cx, fname);
|
let file_node = create_file(cx, fname);
|
||||||
let elem_ty_md = create_ty(cx, elem_t, span);
|
let elem_ty_md = create_ty(cx, elem_t, span);
|
||||||
let uint_type = create_basic_type(cx, ty::mk_uint(cx.tcx), span);
|
let uint_type = create_basic_type(cx, ty::mk_uint(), span);
|
||||||
let elem_ptr = create_pointer_type(cx, elem_t, span, elem_ty_md);
|
let elem_ptr = create_pointer_type(cx, elem_t, span, elem_ty_md);
|
||||||
let scx = create_structure(file_node, @ty_to_str(cx.tcx, vec_t), 0);
|
let scx = create_structure(file_node, @ty_to_str(cx.tcx, vec_t), 0);
|
||||||
let (_, ptr_size, ptr_align) = voidptr();
|
let (_, ptr_size, ptr_align) = voidptr();
|
||||||
|
@ -744,7 +744,7 @@ fn create_ty(cx: @CrateContext, t: ty::t, span: span)
|
||||||
ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_int(_) | ty::ty_uint(_)
|
ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_int(_) | ty::ty_uint(_)
|
||||||
| ty::ty_float(_) => create_basic_type(cx, t, span),
|
| ty::ty_float(_) => create_basic_type(cx, t, span),
|
||||||
ty::ty_estr(ref vstore) => {
|
ty::ty_estr(ref vstore) => {
|
||||||
let i8_t = ty::mk_i8(cx.tcx);
|
let i8_t = ty::mk_i8();
|
||||||
match *vstore {
|
match *vstore {
|
||||||
ty::vstore_fixed(len) => {
|
ty::vstore_fixed(len) => {
|
||||||
create_fixed_vec(cx, t, i8_t, len as int + 1, span)
|
create_fixed_vec(cx, t, i8_t, len as int + 1, span)
|
||||||
|
|
|
@ -791,7 +791,7 @@ fn trans_def_datum_unadjusted(bcx: block,
|
||||||
let rust_ty = ty::mk_ptr(
|
let rust_ty = ty::mk_ptr(
|
||||||
bcx.tcx(),
|
bcx.tcx(),
|
||||||
ty::mt {
|
ty::mt {
|
||||||
ty: ty::mk_mach_uint(bcx.tcx(), ast::ty_u8),
|
ty: ty::mk_mach_uint(ast::ty_u8),
|
||||||
mutbl: ast::m_imm
|
mutbl: ast::m_imm
|
||||||
}); // *u8
|
}); // *u8
|
||||||
(rust_ty, PointerCast(bcx, fn_data.llfn, T_ptr(T_i8())))
|
(rust_ty, PointerCast(bcx, fn_data.llfn, T_ptr(T_i8())))
|
||||||
|
|
|
@ -768,7 +768,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
|
||||||
let frameaddress_val = Call(bcx, frameaddress, ~[C_i32(0i32)]);
|
let frameaddress_val = Call(bcx, frameaddress, ~[C_i32(0i32)]);
|
||||||
let star_u8 = ty::mk_imm_ptr(
|
let star_u8 = ty::mk_imm_ptr(
|
||||||
bcx.tcx(),
|
bcx.tcx(),
|
||||||
ty::mk_mach_uint(bcx.tcx(), ast::ty_u8));
|
ty::mk_mach_uint(ast::ty_u8));
|
||||||
let fty = ty::mk_closure(bcx.tcx(), ty::ClosureTy {
|
let fty = ty::mk_closure(bcx.tcx(), ty::ClosureTy {
|
||||||
purity: ast::impure_fn,
|
purity: ast::impure_fn,
|
||||||
sigil: ast::BorrowedSigil,
|
sigil: ast::BorrowedSigil,
|
||||||
|
@ -777,13 +777,13 @@ pub fn trans_intrinsic(ccx: @CrateContext,
|
||||||
sig: FnSig {bound_lifetime_names: opt_vec::Empty,
|
sig: FnSig {bound_lifetime_names: opt_vec::Empty,
|
||||||
inputs: ~[arg {mode: ast::expl(ast::by_copy),
|
inputs: ~[arg {mode: ast::expl(ast::by_copy),
|
||||||
ty: star_u8}],
|
ty: star_u8}],
|
||||||
output: ty::mk_nil(bcx.tcx())}
|
output: ty::mk_nil()}
|
||||||
});
|
});
|
||||||
let datum = Datum {val: get_param(decl, first_real_arg),
|
let datum = Datum {val: get_param(decl, first_real_arg),
|
||||||
mode: ByRef, ty: fty, source: ZeroMem};
|
mode: ByRef, ty: fty, source: ZeroMem};
|
||||||
let arg_vals = ~[frameaddress_val];
|
let arg_vals = ~[frameaddress_val];
|
||||||
bcx = trans_call_inner(
|
bcx = trans_call_inner(
|
||||||
bcx, None, fty, ty::mk_nil(bcx.tcx()),
|
bcx, None, fty, ty::mk_nil(),
|
||||||
|bcx| Callee {bcx: bcx, data: Closure(datum)},
|
|bcx| Callee {bcx: bcx, data: Closure(datum)},
|
||||||
ArgVals(arg_vals), Ignore, DontAutorefArg);
|
ArgVals(arg_vals), Ignore, DontAutorefArg);
|
||||||
}
|
}
|
||||||
|
@ -791,7 +791,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
|
||||||
// XXX This is a hack to grab the address of this particular
|
// XXX This is a hack to grab the address of this particular
|
||||||
// native function. There should be a general in-language
|
// native function. There should be a general in-language
|
||||||
// way to do this
|
// way to do this
|
||||||
let llfty = type_of_fn(bcx.ccx(), ~[], ty::mk_nil(bcx.tcx()));
|
let llfty = type_of_fn(bcx.ccx(), ~[], ty::mk_nil());
|
||||||
let morestack_addr = decl_cdecl_fn(
|
let morestack_addr = decl_cdecl_fn(
|
||||||
bcx.ccx().llmod, ~"__morestack", llfty);
|
bcx.ccx().llmod, ~"__morestack", llfty);
|
||||||
let morestack_addr = PointerCast(bcx, morestack_addr,
|
let morestack_addr = PointerCast(bcx, morestack_addr,
|
||||||
|
|
|
@ -168,19 +168,19 @@ pub fn simplified_glue_type(tcx: ty::ctxt, field: uint, t: ty::t) -> ty::t {
|
||||||
field == abi::tydesc_field_drop_glue ||
|
field == abi::tydesc_field_drop_glue ||
|
||||||
field == abi::tydesc_field_free_glue) &&
|
field == abi::tydesc_field_free_glue) &&
|
||||||
! ty::type_needs_drop(tcx, t) {
|
! ty::type_needs_drop(tcx, t) {
|
||||||
return ty::mk_u32(tcx);
|
return ty::mk_u32();
|
||||||
}
|
}
|
||||||
|
|
||||||
if field == abi::tydesc_field_take_glue {
|
if field == abi::tydesc_field_take_glue {
|
||||||
match ty::get(t).sty {
|
match ty::get(t).sty {
|
||||||
ty::ty_unboxed_vec(*) => { return ty::mk_u32(tcx); }
|
ty::ty_unboxed_vec(*) => { return ty::mk_u32(); }
|
||||||
_ => ()
|
_ => ()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if field == abi::tydesc_field_take_glue &&
|
if field == abi::tydesc_field_take_glue &&
|
||||||
ty::type_is_boxed(t) {
|
ty::type_is_boxed(t) {
|
||||||
return ty::mk_imm_box(tcx, ty::mk_u32(tcx));
|
return ty::mk_imm_box(tcx, ty::mk_u32());
|
||||||
}
|
}
|
||||||
|
|
||||||
if field == abi::tydesc_field_free_glue {
|
if field == abi::tydesc_field_free_glue {
|
||||||
|
@ -193,7 +193,7 @@ pub fn simplified_glue_type(tcx: ty::ctxt, field: uint, t: ty::t) -> ty::t {
|
||||||
ty::ty_evec(_, ty::vstore_uniq) | ty::ty_estr(ty::vstore_uniq) |
|
ty::ty_evec(_, ty::vstore_uniq) | ty::ty_estr(ty::vstore_uniq) |
|
||||||
ty::ty_evec(_, ty::vstore_box) | ty::ty_estr(ty::vstore_box) |
|
ty::ty_evec(_, ty::vstore_box) | ty::ty_estr(ty::vstore_box) |
|
||||||
ty::ty_opaque_closure_ptr(*) => (),
|
ty::ty_opaque_closure_ptr(*) => (),
|
||||||
_ => { return ty::mk_u32(tcx); }
|
_ => { return ty::mk_u32(); }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -203,12 +203,12 @@ pub fn simplified_glue_type(tcx: ty::ctxt, field: uint, t: ty::t) -> ty::t {
|
||||||
ty::ty_box(mt) |
|
ty::ty_box(mt) |
|
||||||
ty::ty_evec(mt, ty::vstore_box)
|
ty::ty_evec(mt, ty::vstore_box)
|
||||||
if ! ty::type_needs_drop(tcx, mt.ty) =>
|
if ! ty::type_needs_drop(tcx, mt.ty) =>
|
||||||
return ty::mk_imm_box(tcx, ty::mk_u32(tcx)),
|
return ty::mk_imm_box(tcx, ty::mk_u32()),
|
||||||
|
|
||||||
ty::ty_uniq(mt) |
|
ty::ty_uniq(mt) |
|
||||||
ty::ty_evec(mt, ty::vstore_uniq)
|
ty::ty_evec(mt, ty::vstore_uniq)
|
||||||
if ! ty::type_needs_drop(tcx, mt.ty) =>
|
if ! ty::type_needs_drop(tcx, mt.ty) =>
|
||||||
return ty::mk_imm_uniq(tcx, ty::mk_u32(tcx)),
|
return ty::mk_imm_uniq(tcx, ty::mk_u32()),
|
||||||
|
|
||||||
_ => ()
|
_ => ()
|
||||||
}
|
}
|
||||||
|
@ -736,7 +736,7 @@ pub fn make_generic_glue_inner(ccx: @CrateContext,
|
||||||
helper: glue_helper)
|
helper: glue_helper)
|
||||||
-> ValueRef {
|
-> ValueRef {
|
||||||
let _icx = ccx.insn_ctxt("make_generic_glue_inner");
|
let _icx = ccx.insn_ctxt("make_generic_glue_inner");
|
||||||
let fcx = new_fn_ctxt(ccx, ~[], llfn, ty::mk_nil(ccx.tcx), None);
|
let fcx = new_fn_ctxt(ccx, ~[], llfn, ty::mk_nil(), None);
|
||||||
lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
|
lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
|
||||||
ccx.stats.n_glues_created += 1u;
|
ccx.stats.n_glues_created += 1u;
|
||||||
// All glue functions take values passed *by alias*; this is a
|
// All glue functions take values passed *by alias*; this is a
|
||||||
|
|
|
@ -307,7 +307,7 @@ pub fn normalize_for_monomorphization(tcx: ty::ctxt,
|
||||||
abis: AbiSet::Rust(),
|
abis: AbiSet::Rust(),
|
||||||
sig: FnSig {bound_lifetime_names: opt_vec::Empty,
|
sig: FnSig {bound_lifetime_names: opt_vec::Empty,
|
||||||
inputs: ~[],
|
inputs: ~[],
|
||||||
output: ty::mk_nil(tcx)}}))
|
output: ty::mk_nil()}}))
|
||||||
}
|
}
|
||||||
ty::ty_closure(ref fty) => {
|
ty::ty_closure(ref fty) => {
|
||||||
Some(normalized_closure_ty(tcx, fty.sigil))
|
Some(normalized_closure_ty(tcx, fty.sigil))
|
||||||
|
@ -323,7 +323,7 @@ pub fn normalize_for_monomorphization(tcx: ty::ctxt,
|
||||||
Some(normalized_closure_ty(tcx, sigil))
|
Some(normalized_closure_ty(tcx, sigil))
|
||||||
}
|
}
|
||||||
ty::ty_ptr(_) => {
|
ty::ty_ptr(_) => {
|
||||||
Some(ty::mk_uint(tcx))
|
Some(ty::mk_uint())
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
None
|
None
|
||||||
|
@ -342,7 +342,7 @@ pub fn normalize_for_monomorphization(tcx: ty::ctxt,
|
||||||
region: ty::re_static,
|
region: ty::re_static,
|
||||||
sig: ty::FnSig {bound_lifetime_names: opt_vec::Empty,
|
sig: ty::FnSig {bound_lifetime_names: opt_vec::Empty,
|
||||||
inputs: ~[],
|
inputs: ~[],
|
||||||
output: ty::mk_nil(tcx)}})
|
output: ty::mk_nil()}})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -95,7 +95,7 @@ fn traverse_public_mod(cx: &ctx, mod_id: node_id, m: &_mod) {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn traverse_public_item(cx: &ctx, item: @item) {
|
fn traverse_public_item(cx: &ctx, item: @item) {
|
||||||
// XXX: it shouldn't be necessary to do this
|
// FIXME #6021: naming rmap shouldn't be necessary
|
||||||
let rmap: &mut HashSet<node_id> = cx.rmap;
|
let rmap: &mut HashSet<node_id> = cx.rmap;
|
||||||
if rmap.contains(&item.id) { return; }
|
if rmap.contains(&item.id) { return; }
|
||||||
rmap.insert(item.id);
|
rmap.insert(item.id);
|
||||||
|
@ -150,7 +150,7 @@ fn traverse_public_item(cx: &ctx, item: @item) {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn traverse_ty<'a, 'b>(ty: @Ty, cx: &'b ctx<'a>, v: visit::vt<&'b ctx<'a>>) {
|
fn traverse_ty<'a, 'b>(ty: @Ty, cx: &'b ctx<'a>, v: visit::vt<&'b ctx<'a>>) {
|
||||||
// XXX: it shouldn't be necessary to do this
|
// FIXME #6021: naming rmap shouldn't be necessary
|
||||||
let rmap: &mut HashSet<node_id> = cx.rmap;
|
let rmap: &mut HashSet<node_id> = cx.rmap;
|
||||||
if rmap.contains(&ty.id) { return; }
|
if rmap.contains(&ty.id) { return; }
|
||||||
rmap.insert(ty.id);
|
rmap.insert(ty.id);
|
||||||
|
|
|
@ -98,7 +98,7 @@ pub impl Reflector {
|
||||||
for args.eachi |i, a| {
|
for args.eachi |i, a| {
|
||||||
debug!("arg %u: %s", i, val_str(bcx.ccx().tn, *a));
|
debug!("arg %u: %s", i, val_str(bcx.ccx().tn, *a));
|
||||||
}
|
}
|
||||||
let bool_ty = ty::mk_bool(tcx);
|
let bool_ty = ty::mk_bool();
|
||||||
let scratch = scratch_datum(bcx, bool_ty, false);
|
let scratch = scratch_datum(bcx, bool_ty, false);
|
||||||
// XXX: Should not be BoxTraitStore!
|
// XXX: Should not be BoxTraitStore!
|
||||||
let bcx = callee::trans_call_inner(
|
let bcx = callee::trans_call_inner(
|
||||||
|
@ -283,7 +283,7 @@ pub impl Reflector {
|
||||||
let sym = mangle_internal_name_by_path_and_seq(ccx, sub_path, ~"get_disr");
|
let sym = mangle_internal_name_by_path_and_seq(ccx, sub_path, ~"get_disr");
|
||||||
let args = [ty::arg { mode: ast::expl(ast::by_copy),
|
let args = [ty::arg { mode: ast::expl(ast::by_copy),
|
||||||
ty: opaqueptrty }];
|
ty: opaqueptrty }];
|
||||||
let llfty = type_of_fn(ccx, args, ty::mk_int(ccx.tcx));
|
let llfty = type_of_fn(ccx, args, ty::mk_int());
|
||||||
let llfdecl = decl_internal_cdecl_fn(ccx.llmod, sym, llfty);
|
let llfdecl = decl_internal_cdecl_fn(ccx.llmod, sym, llfty);
|
||||||
let arg = unsafe {
|
let arg = unsafe {
|
||||||
llvm::LLVMGetParam(llfdecl, first_real_arg as c_uint)
|
llvm::LLVMGetParam(llfdecl, first_real_arg as c_uint)
|
||||||
|
@ -291,7 +291,7 @@ pub impl Reflector {
|
||||||
let fcx = new_fn_ctxt(ccx,
|
let fcx = new_fn_ctxt(ccx,
|
||||||
~[],
|
~[],
|
||||||
llfdecl,
|
llfdecl,
|
||||||
ty::mk_uint(ccx.tcx),
|
ty::mk_uint(),
|
||||||
None);
|
None);
|
||||||
let bcx = top_scope_block(fcx, None);
|
let bcx = top_scope_block(fcx, None);
|
||||||
let arg = BitCast(bcx, arg, llptrty);
|
let arg = BitCast(bcx, arg, llptrty);
|
||||||
|
|
|
@ -949,12 +949,12 @@ pub fn mk_ctxt(s: session::Session,
|
||||||
fn mk_t(cx: ctxt, st: sty) -> t {
|
fn mk_t(cx: ctxt, st: sty) -> t {
|
||||||
// Check for primitive types.
|
// Check for primitive types.
|
||||||
match st {
|
match st {
|
||||||
ty_nil => return mk_nil(cx),
|
ty_nil => return mk_nil(),
|
||||||
ty_err => return mk_err(cx),
|
ty_err => return mk_err(),
|
||||||
ty_bool => return mk_bool(cx),
|
ty_bool => return mk_bool(),
|
||||||
ty_int(i) => return mk_mach_int(cx, i),
|
ty_int(i) => return mk_mach_int(i),
|
||||||
ty_uint(u) => return mk_mach_uint(cx, u),
|
ty_uint(u) => return mk_mach_uint(u),
|
||||||
ty_float(f) => return mk_mach_float(cx, f),
|
ty_float(f) => return mk_mach_float(f),
|
||||||
_ => {}
|
_ => {}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -1052,94 +1052,94 @@ fn mk_t(cx: ctxt, st: sty) -> t {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_prim_t(cx: ctxt, primitive: &'static t_box_) -> t {
|
pub fn mk_prim_t(primitive: &'static t_box_) -> t {
|
||||||
unsafe {
|
unsafe {
|
||||||
cast::transmute::<&'static t_box_, t>(primitive)
|
cast::transmute::<&'static t_box_, t>(primitive)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_nil(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_NIL) }
|
pub fn mk_nil() -> t { mk_prim_t(&primitives::TY_NIL) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_err(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_ERR) }
|
pub fn mk_err() -> t { mk_prim_t(&primitives::TY_ERR) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_bot(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_BOT) }
|
pub fn mk_bot() -> t { mk_prim_t(&primitives::TY_BOT) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_bool(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_BOOL) }
|
pub fn mk_bool() -> t { mk_prim_t(&primitives::TY_BOOL) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_int(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_INT) }
|
pub fn mk_int() -> t { mk_prim_t(&primitives::TY_INT) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_i8(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_I8) }
|
pub fn mk_i8() -> t { mk_prim_t(&primitives::TY_I8) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_i16(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_I16) }
|
pub fn mk_i16() -> t { mk_prim_t(&primitives::TY_I16) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_i32(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_I32) }
|
pub fn mk_i32() -> t { mk_prim_t(&primitives::TY_I32) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_i64(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_I64) }
|
pub fn mk_i64() -> t { mk_prim_t(&primitives::TY_I64) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_float(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_FLOAT) }
|
pub fn mk_float() -> t { mk_prim_t(&primitives::TY_FLOAT) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_f32(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_F32) }
|
pub fn mk_f32() -> t { mk_prim_t(&primitives::TY_F32) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_f64(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_F64) }
|
pub fn mk_f64() -> t { mk_prim_t(&primitives::TY_F64) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_uint(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_UINT) }
|
pub fn mk_uint() -> t { mk_prim_t(&primitives::TY_UINT) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_u8(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_U8) }
|
pub fn mk_u8() -> t { mk_prim_t(&primitives::TY_U8) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_u16(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_U16) }
|
pub fn mk_u16() -> t { mk_prim_t(&primitives::TY_U16) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_u32(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_U32) }
|
pub fn mk_u32() -> t { mk_prim_t(&primitives::TY_U32) }
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_u64(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_U64) }
|
pub fn mk_u64() -> t { mk_prim_t(&primitives::TY_U64) }
|
||||||
|
|
||||||
pub fn mk_mach_int(cx: ctxt, tm: ast::int_ty) -> t {
|
pub fn mk_mach_int(tm: ast::int_ty) -> t {
|
||||||
match tm {
|
match tm {
|
||||||
ast::ty_i => mk_int(cx),
|
ast::ty_i => mk_int(),
|
||||||
ast::ty_char => mk_char(cx),
|
ast::ty_char => mk_char(),
|
||||||
ast::ty_i8 => mk_i8(cx),
|
ast::ty_i8 => mk_i8(),
|
||||||
ast::ty_i16 => mk_i16(cx),
|
ast::ty_i16 => mk_i16(),
|
||||||
ast::ty_i32 => mk_i32(cx),
|
ast::ty_i32 => mk_i32(),
|
||||||
ast::ty_i64 => mk_i64(cx),
|
ast::ty_i64 => mk_i64(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn mk_mach_uint(cx: ctxt, tm: ast::uint_ty) -> t {
|
pub fn mk_mach_uint(tm: ast::uint_ty) -> t {
|
||||||
match tm {
|
match tm {
|
||||||
ast::ty_u => mk_uint(cx),
|
ast::ty_u => mk_uint(),
|
||||||
ast::ty_u8 => mk_u8(cx),
|
ast::ty_u8 => mk_u8(),
|
||||||
ast::ty_u16 => mk_u16(cx),
|
ast::ty_u16 => mk_u16(),
|
||||||
ast::ty_u32 => mk_u32(cx),
|
ast::ty_u32 => mk_u32(),
|
||||||
ast::ty_u64 => mk_u64(cx),
|
ast::ty_u64 => mk_u64(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn mk_mach_float(cx: ctxt, tm: ast::float_ty) -> t {
|
pub fn mk_mach_float(tm: ast::float_ty) -> t {
|
||||||
match tm {
|
match tm {
|
||||||
ast::ty_f => mk_float(cx),
|
ast::ty_f => mk_float(),
|
||||||
ast::ty_f32 => mk_f32(cx),
|
ast::ty_f32 => mk_f32(),
|
||||||
ast::ty_f64 => mk_f64(cx),
|
ast::ty_f64 => mk_f64(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn mk_char(cx: ctxt) -> t { mk_prim_t(cx, &primitives::TY_CHAR) }
|
pub fn mk_char() -> t { mk_prim_t(&primitives::TY_CHAR) }
|
||||||
|
|
||||||
pub fn mk_estr(cx: ctxt, t: vstore) -> t {
|
pub fn mk_estr(cx: ctxt, t: vstore) -> t {
|
||||||
mk_t(cx, ty_estr(t))
|
mk_t(cx, ty_estr(t))
|
||||||
|
@ -1182,7 +1182,7 @@ pub fn mk_imm_ptr(cx: ctxt, ty: t) -> t {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn mk_nil_ptr(cx: ctxt) -> t {
|
pub fn mk_nil_ptr(cx: ctxt) -> t {
|
||||||
mk_ptr(cx, mt {ty: mk_nil(cx), mutbl: ast::m_imm})
|
mk_ptr(cx, mt {ty: mk_nil(), mutbl: ast::m_imm})
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn mk_evec(cx: ctxt, tm: mt, t: vstore) -> t {
|
pub fn mk_evec(cx: ctxt, tm: mt, t: vstore) -> t {
|
||||||
|
@ -1610,7 +1610,7 @@ pub fn type_is_str(ty: t) -> bool {
|
||||||
|
|
||||||
pub fn sequence_element_type(cx: ctxt, ty: t) -> t {
|
pub fn sequence_element_type(cx: ctxt, ty: t) -> t {
|
||||||
match get(ty).sty {
|
match get(ty).sty {
|
||||||
ty_estr(_) => return mk_mach_uint(cx, ast::ty_u8),
|
ty_estr(_) => return mk_mach_uint(ast::ty_u8),
|
||||||
ty_evec(mt, _) | ty_unboxed_vec(mt) => return mt.ty,
|
ty_evec(mt, _) | ty_unboxed_vec(mt) => return mt.ty,
|
||||||
_ => cx.sess.bug(
|
_ => cx.sess.bug(
|
||||||
~"sequence_element_type called on non-sequence value"),
|
~"sequence_element_type called on non-sequence value"),
|
||||||
|
@ -2614,14 +2614,14 @@ pub fn type_autoderef(cx: ctxt, t: t) -> t {
|
||||||
}
|
}
|
||||||
|
|
||||||
// Returns the type and mutability of t[i]
|
// Returns the type and mutability of t[i]
|
||||||
pub fn index(cx: ctxt, t: t) -> Option<mt> {
|
pub fn index(t: t) -> Option<mt> {
|
||||||
index_sty(cx, &get(t).sty)
|
index_sty(&get(t).sty)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn index_sty(cx: ctxt, sty: &sty) -> Option<mt> {
|
pub fn index_sty(sty: &sty) -> Option<mt> {
|
||||||
match *sty {
|
match *sty {
|
||||||
ty_evec(mt, _) => Some(mt),
|
ty_evec(mt, _) => Some(mt),
|
||||||
ty_estr(_) => Some(mt {ty: mk_u8(cx), mutbl: ast::m_imm}),
|
ty_estr(_) => Some(mt {ty: mk_u8(), mutbl: ast::m_imm}),
|
||||||
_ => None
|
_ => None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -4164,14 +4164,6 @@ pub fn lookup_struct_field(cx: ctxt,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn is_public(f: field_ty) -> bool {
|
|
||||||
// XXX: This is wrong.
|
|
||||||
match f.vis {
|
|
||||||
public | inherited => true,
|
|
||||||
private => false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn struct_field_tys(fields: &[@struct_field]) -> ~[field_ty] {
|
fn struct_field_tys(fields: &[@struct_field]) -> ~[field_ty] {
|
||||||
do fields.map |field| {
|
do fields.map |field| {
|
||||||
match field.node.kind {
|
match field.node.kind {
|
||||||
|
|
|
@ -352,8 +352,8 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
|
||||||
|
|
||||||
tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_unresolved);
|
tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_unresolved);
|
||||||
let typ = match ast_ty.node {
|
let typ = match ast_ty.node {
|
||||||
ast::ty_nil => ty::mk_nil(tcx),
|
ast::ty_nil => ty::mk_nil(),
|
||||||
ast::ty_bot => ty::mk_bot(tcx),
|
ast::ty_bot => ty::mk_bot(),
|
||||||
ast::ty_box(ref mt) => {
|
ast::ty_box(ref mt) => {
|
||||||
mk_pointer(self, rscope, mt, ty::vstore_box,
|
mk_pointer(self, rscope, mt, ty::vstore_box,
|
||||||
|tmt| ty::mk_box(tcx, tmt))
|
|tmt| ty::mk_box(tcx, tmt))
|
||||||
|
@ -413,7 +413,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
|
||||||
fmt!("reference to trait `%s` where a type is expected; \
|
fmt!("reference to trait `%s` where a type is expected; \
|
||||||
try `@%s`, `~%s`, or `&%s`",
|
try `@%s`, `~%s`, or `&%s`",
|
||||||
path_str, path_str, path_str, path_str));
|
path_str, path_str, path_str, path_str));
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
}
|
}
|
||||||
ast::def_ty(did) | ast::def_struct(did) => {
|
ast::def_ty(did) | ast::def_struct(did) => {
|
||||||
ast_path_to_ty(self, rscope, did, path).ty
|
ast_path_to_ty(self, rscope, did, path).ty
|
||||||
|
@ -422,19 +422,19 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
|
||||||
match nty {
|
match nty {
|
||||||
ast::ty_bool => {
|
ast::ty_bool => {
|
||||||
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
||||||
ty::mk_bool(tcx)
|
ty::mk_bool()
|
||||||
}
|
}
|
||||||
ast::ty_int(it) => {
|
ast::ty_int(it) => {
|
||||||
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
||||||
ty::mk_mach_int(tcx, it)
|
ty::mk_mach_int(it)
|
||||||
}
|
}
|
||||||
ast::ty_uint(uit) => {
|
ast::ty_uint(uit) => {
|
||||||
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
||||||
ty::mk_mach_uint(tcx, uit)
|
ty::mk_mach_uint(uit)
|
||||||
}
|
}
|
||||||
ast::ty_float(ft) => {
|
ast::ty_float(ft) => {
|
||||||
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
||||||
ty::mk_mach_float(tcx, ft)
|
ty::mk_mach_float(ft)
|
||||||
}
|
}
|
||||||
ast::ty_str => {
|
ast::ty_str => {
|
||||||
tcx.sess.span_err(ast_ty.span,
|
tcx.sess.span_err(ast_ty.span,
|
||||||
|
|
|
@ -56,7 +56,7 @@ pub fn check_match(fcx: @mut FnCtxt,
|
||||||
let mut guard_bot = false;
|
let mut guard_bot = false;
|
||||||
match arm.guard {
|
match arm.guard {
|
||||||
Some(e) => {
|
Some(e) => {
|
||||||
check_expr_has_type(fcx, e, ty::mk_bool(tcx));
|
check_expr_has_type(fcx, e, ty::mk_bool());
|
||||||
let e_ty = fcx.expr_ty(e);
|
let e_ty = fcx.expr_ty(e);
|
||||||
if ty::type_is_error(e_ty) {
|
if ty::type_is_error(e_ty) {
|
||||||
guard_err = true;
|
guard_err = true;
|
||||||
|
@ -84,10 +84,10 @@ pub fn check_match(fcx: @mut FnCtxt,
|
||||||
demand::suptype(fcx, arm.body.span, result_ty, bty);
|
demand::suptype(fcx, arm.body.span, result_ty, bty);
|
||||||
}
|
}
|
||||||
if saw_err {
|
if saw_err {
|
||||||
result_ty = ty::mk_err(tcx);
|
result_ty = ty::mk_err();
|
||||||
}
|
}
|
||||||
else if !arm_non_bot {
|
else if !arm_non_bot {
|
||||||
result_ty = ty::mk_bot(tcx);
|
result_ty = ty::mk_bot();
|
||||||
}
|
}
|
||||||
fcx.write_ty(expr.id, result_ty);
|
fcx.write_ty(expr.id, result_ty);
|
||||||
}
|
}
|
||||||
|
@ -230,11 +230,9 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
|
||||||
}
|
}
|
||||||
|
|
||||||
if error_happened {
|
if error_happened {
|
||||||
let tcx = pcx.fcx.ccx.tcx;
|
|
||||||
|
|
||||||
for subpats.each |pats| {
|
for subpats.each |pats| {
|
||||||
for pats.each |pat| {
|
for pats.each |pat| {
|
||||||
check_pat(pcx, *pat, ty::mk_err(tcx));
|
check_pat(pcx, *pat, ty::mk_err());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -753,13 +753,13 @@ pub impl FnCtxt {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write_nil(&self, node_id: ast::node_id) {
|
fn write_nil(&self, node_id: ast::node_id) {
|
||||||
self.write_ty(node_id, ty::mk_nil(self.tcx()));
|
self.write_ty(node_id, ty::mk_nil());
|
||||||
}
|
}
|
||||||
fn write_bot(&self, node_id: ast::node_id) {
|
fn write_bot(&self, node_id: ast::node_id) {
|
||||||
self.write_ty(node_id, ty::mk_bot(self.tcx()));
|
self.write_ty(node_id, ty::mk_bot());
|
||||||
}
|
}
|
||||||
fn write_error(@mut self, node_id: ast::node_id) {
|
fn write_error(@mut self, node_id: ast::node_id) {
|
||||||
self.write_ty(node_id, ty::mk_err(self.tcx()));
|
self.write_ty(node_id, ty::mk_err());
|
||||||
}
|
}
|
||||||
|
|
||||||
fn to_ty(&self, ast_t: @ast::Ty) -> ty::t {
|
fn to_ty(&self, ast_t: @ast::Ty) -> ty::t {
|
||||||
|
@ -1008,21 +1008,21 @@ pub fn check_lit(fcx: @mut FnCtxt, lit: @ast::lit) -> ty::t {
|
||||||
|
|
||||||
match lit.node {
|
match lit.node {
|
||||||
ast::lit_str(*) => ty::mk_estr(tcx, ty::vstore_slice(ty::re_static)),
|
ast::lit_str(*) => ty::mk_estr(tcx, ty::vstore_slice(ty::re_static)),
|
||||||
ast::lit_int(_, t) => ty::mk_mach_int(tcx, t),
|
ast::lit_int(_, t) => ty::mk_mach_int(t),
|
||||||
ast::lit_uint(_, t) => ty::mk_mach_uint(tcx, t),
|
ast::lit_uint(_, t) => ty::mk_mach_uint(t),
|
||||||
ast::lit_int_unsuffixed(_) => {
|
ast::lit_int_unsuffixed(_) => {
|
||||||
// An unsuffixed integer literal could have any integral type,
|
// An unsuffixed integer literal could have any integral type,
|
||||||
// so we create an integral type variable for it.
|
// so we create an integral type variable for it.
|
||||||
ty::mk_int_var(tcx, fcx.infcx().next_int_var_id())
|
ty::mk_int_var(tcx, fcx.infcx().next_int_var_id())
|
||||||
}
|
}
|
||||||
ast::lit_float(_, t) => ty::mk_mach_float(tcx, t),
|
ast::lit_float(_, t) => ty::mk_mach_float(t),
|
||||||
ast::lit_float_unsuffixed(_) => {
|
ast::lit_float_unsuffixed(_) => {
|
||||||
// An unsuffixed floating point literal could have any floating point
|
// An unsuffixed floating point literal could have any floating point
|
||||||
// type, so we create a floating point type variable for it.
|
// type, so we create a floating point type variable for it.
|
||||||
ty::mk_float_var(tcx, fcx.infcx().next_float_var_id())
|
ty::mk_float_var(tcx, fcx.infcx().next_float_var_id())
|
||||||
}
|
}
|
||||||
ast::lit_nil => ty::mk_nil(tcx),
|
ast::lit_nil => ty::mk_nil(),
|
||||||
ast::lit_bool(_) => ty::mk_bool(tcx)
|
ast::lit_bool(_) => ty::mk_bool()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1146,7 +1146,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
deref_args: DerefArgs) -> ty::t
|
deref_args: DerefArgs) -> ty::t
|
||||||
{
|
{
|
||||||
if ty::type_is_error(method_fn_ty) {
|
if ty::type_is_error(method_fn_ty) {
|
||||||
let err_inputs = err_args(fcx.tcx(), args.len());
|
let err_inputs = err_args(args.len());
|
||||||
check_argument_types(fcx, sp, err_inputs, callee_expr,
|
check_argument_types(fcx, sp, err_inputs, callee_expr,
|
||||||
args, sugar, deref_args);
|
args, sugar, deref_args);
|
||||||
method_fn_ty
|
method_fn_ty
|
||||||
|
@ -1209,7 +1209,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
|
|
||||||
tcx.sess.span_err(sp, msg);
|
tcx.sess.span_err(sp, msg);
|
||||||
|
|
||||||
vec::from_elem(supplied_arg_count, ty::mk_err(tcx))
|
vec::from_elem(supplied_arg_count, ty::mk_err())
|
||||||
};
|
};
|
||||||
|
|
||||||
debug!("check_argument_types: formal_tys=%?",
|
debug!("check_argument_types: formal_tys=%?",
|
||||||
|
@ -1265,9 +1265,9 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn err_args(tcx: ty::ctxt, len: uint) -> ~[ty::arg] {
|
fn err_args(len: uint) -> ~[ty::arg] {
|
||||||
vec::from_fn(len, |_| ty::arg {mode: ast::expl(ast::by_copy),
|
vec::from_fn(len, |_| ty::arg {mode: ast::expl(ast::by_copy),
|
||||||
ty: ty::mk_err(tcx)})
|
ty: ty::mk_err()})
|
||||||
}
|
}
|
||||||
|
|
||||||
// A generic function for checking assignment expressions
|
// A generic function for checking assignment expressions
|
||||||
|
@ -1278,7 +1278,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
check_expr(fcx, lhs);
|
check_expr(fcx, lhs);
|
||||||
let lhs_type = fcx.expr_ty(lhs);
|
let lhs_type = fcx.expr_ty(lhs);
|
||||||
check_expr_has_type(fcx, rhs, lhs_type);
|
check_expr_has_type(fcx, rhs, lhs_type);
|
||||||
fcx.write_ty(id, ty::mk_nil(fcx.ccx.tcx));
|
fcx.write_ty(id, ty::mk_nil());
|
||||||
// The callee checks for bot / err, we don't need to
|
// The callee checks for bot / err, we don't need to
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1321,8 +1321,8 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
// check each arg against "error", in order to set up
|
// check each arg against "error", in order to set up
|
||||||
// all the node type bindings
|
// all the node type bindings
|
||||||
FnSig {bound_lifetime_names: opt_vec::Empty,
|
FnSig {bound_lifetime_names: opt_vec::Empty,
|
||||||
inputs: err_args(fcx.tcx(), args.len()),
|
inputs: err_args(args.len()),
|
||||||
output: ty::mk_err(fcx.tcx())}
|
output: ty::mk_err()}
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -1417,7 +1417,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
None => {
|
None => {
|
||||||
check_block_no_value(fcx, thn);
|
check_block_no_value(fcx, thn);
|
||||||
ty::mk_nil(fcx.ccx.tcx)
|
ty::mk_nil()
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -1448,15 +1448,14 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
ast::NoSugar, deref_args)
|
ast::NoSugar, deref_args)
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
let tcx = fcx.tcx();
|
|
||||||
unbound_method();
|
unbound_method();
|
||||||
// Check the args anyway
|
// Check the args anyway
|
||||||
// so we get all the error messages
|
// so we get all the error messages
|
||||||
let expected_ty = ty::mk_err(tcx);
|
let expected_ty = ty::mk_err();
|
||||||
check_method_argument_types(fcx, op_ex.span,
|
check_method_argument_types(fcx, op_ex.span,
|
||||||
expected_ty, op_ex, args,
|
expected_ty, op_ex, args,
|
||||||
ast::NoSugar, deref_args);
|
ast::NoSugar, deref_args);
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1494,7 +1493,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
let result_t = match op {
|
let result_t = match op {
|
||||||
ast::eq | ast::ne | ast::lt | ast::le | ast::ge |
|
ast::eq | ast::ne | ast::lt | ast::le | ast::ge |
|
||||||
ast::gt => {
|
ast::gt => {
|
||||||
ty::mk_bool(tcx)
|
ty::mk_bool()
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
lhs_t
|
lhs_t
|
||||||
|
@ -1565,7 +1564,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn check_user_unop(fcx: @mut FnCtxt,
|
fn check_user_unop(fcx: @mut FnCtxt,
|
||||||
|
@ -1671,11 +1670,11 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
bound_lifetime_names: opt_vec::Empty,
|
bound_lifetime_names: opt_vec::Empty,
|
||||||
inputs: fn_ty.sig.inputs.map(|an_arg| {
|
inputs: fn_ty.sig.inputs.map(|an_arg| {
|
||||||
arg { mode: an_arg.mode,
|
arg { mode: an_arg.mode,
|
||||||
ty: ty::mk_err(tcx)
|
ty: ty::mk_err()
|
||||||
}}),
|
}}),
|
||||||
output: ty::mk_err(tcx)
|
output: ty::mk_err()
|
||||||
};
|
};
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
let fn_ty_copy = copy fn_ty;
|
let fn_ty_copy = copy fn_ty;
|
||||||
|
@ -1792,7 +1791,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
|
|
||||||
// Typecheck each field.
|
// Typecheck each field.
|
||||||
for ast_fields.each |field| {
|
for ast_fields.each |field| {
|
||||||
let mut expected_field_type = ty::mk_err(tcx);
|
let mut expected_field_type = ty::mk_err();
|
||||||
|
|
||||||
let pair = class_field_map.find(&field.node.ident).
|
let pair = class_field_map.find(&field.node.ident).
|
||||||
map_consume(|x| *x);
|
map_consume(|x| *x);
|
||||||
|
@ -1934,7 +1933,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
fields,
|
fields,
|
||||||
base_expr.is_none());
|
base_expr.is_none());
|
||||||
if ty::type_is_error(fcx.node_ty(id)) {
|
if ty::type_is_error(fcx.node_ty(id)) {
|
||||||
struct_type = ty::mk_err(tcx);
|
struct_type = ty::mk_err();
|
||||||
}
|
}
|
||||||
|
|
||||||
// Check the base expression if necessary.
|
// Check the base expression if necessary.
|
||||||
|
@ -1943,7 +1942,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
Some(base_expr) => {
|
Some(base_expr) => {
|
||||||
check_expr_has_type(fcx, base_expr, struct_type);
|
check_expr_has_type(fcx, base_expr, struct_type);
|
||||||
if ty::type_is_bot(fcx.node_ty(base_expr.id)) {
|
if ty::type_is_bot(fcx.node_ty(base_expr.id)) {
|
||||||
struct_type = ty::mk_bot(tcx);
|
struct_type = ty::mk_bot();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -2040,10 +2039,10 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
let inner_ty = match expected_sty {
|
let inner_ty = match expected_sty {
|
||||||
Some(ty::ty_closure(ref fty)) => {
|
Some(ty::ty_closure(ref fty)) => {
|
||||||
match fcx.mk_subty(false, expr.span,
|
match fcx.mk_subty(false, expr.span,
|
||||||
fty.sig.output, ty::mk_bool(tcx)) {
|
fty.sig.output, ty::mk_bool()) {
|
||||||
result::Ok(_) => {
|
result::Ok(_) => {
|
||||||
ty::mk_closure(tcx, ty::ClosureTy {
|
ty::mk_closure(tcx, ty::ClosureTy {
|
||||||
sig: FnSig {output: ty::mk_nil(tcx),
|
sig: FnSig {output: ty::mk_nil(),
|
||||||
..copy fty.sig},
|
..copy fty.sig},
|
||||||
..copy *fty
|
..copy *fty
|
||||||
})
|
})
|
||||||
|
@ -2070,7 +2069,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
None);
|
None);
|
||||||
err_happened = true;
|
err_happened = true;
|
||||||
fcx.write_error(expr.id);
|
fcx.write_error(expr.id);
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -2085,7 +2084,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
actual)
|
actual)
|
||||||
},
|
},
|
||||||
expected_t, None);
|
expected_t, None);
|
||||||
let err_ty = ty::mk_err(tcx);
|
let err_ty = ty::mk_err();
|
||||||
fcx.write_error(expr.id);
|
fcx.write_error(expr.id);
|
||||||
err_happened = true;
|
err_happened = true;
|
||||||
err_ty
|
err_ty
|
||||||
|
@ -2131,7 +2130,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
} else {
|
} else {
|
||||||
let loop_body_ty =
|
let loop_body_ty =
|
||||||
ty::replace_closure_return_type(
|
ty::replace_closure_return_type(
|
||||||
tcx, block_ty, ty::mk_bool(tcx));
|
tcx, block_ty, ty::mk_bool());
|
||||||
fcx.write_ty(expr.id, loop_body_ty);
|
fcx.write_ty(expr.id, loop_body_ty);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -2168,10 +2167,10 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if any_error {
|
if any_error {
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
}
|
}
|
||||||
else if any_bot {
|
else if any_bot {
|
||||||
ty::mk_bot(tcx)
|
ty::mk_bot()
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
ty::mk_evec(tcx, ty::mt {ty: t, mutbl: mutability}, tt)
|
ty::mk_evec(tcx, ty::mt {ty: t, mutbl: mutability}, tt)
|
||||||
|
@ -2179,7 +2178,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
ast::expr_repeat(element, count_expr, mutbl) => {
|
ast::expr_repeat(element, count_expr, mutbl) => {
|
||||||
let _ = ty::eval_repeat_count(tcx, count_expr);
|
let _ = ty::eval_repeat_count(tcx, count_expr);
|
||||||
check_expr_with_hint(fcx, count_expr, ty::mk_uint(tcx));
|
check_expr_with_hint(fcx, count_expr, ty::mk_uint());
|
||||||
let tt = ast_expr_vstore_to_vstore(fcx, ev, vst);
|
let tt = ast_expr_vstore_to_vstore(fcx, ev, vst);
|
||||||
let mutability = match vst {
|
let mutability = match vst {
|
||||||
ast::expr_vstore_mut_box | ast::expr_vstore_mut_slice => {
|
ast::expr_vstore_mut_box | ast::expr_vstore_mut_slice => {
|
||||||
|
@ -2191,9 +2190,9 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
check_expr_has_type(fcx, element, t);
|
check_expr_has_type(fcx, element, t);
|
||||||
let arg_t = fcx.expr_ty(element);
|
let arg_t = fcx.expr_ty(element);
|
||||||
if ty::type_is_error(arg_t) {
|
if ty::type_is_error(arg_t) {
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
} else if ty::type_is_bot(arg_t) {
|
} else if ty::type_is_bot(arg_t) {
|
||||||
ty::mk_bot(tcx)
|
ty::mk_bot()
|
||||||
} else {
|
} else {
|
||||||
ty::mk_evec(tcx, ty::mt {ty: t, mutbl: mutability}, tt)
|
ty::mk_evec(tcx, ty::mt {ty: t, mutbl: mutability}, tt)
|
||||||
}
|
}
|
||||||
|
@ -2351,9 +2350,9 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
|
|
||||||
let tm = ty::mt { ty: fcx.expr_ty(oprnd), mutbl: mutbl };
|
let tm = ty::mt { ty: fcx.expr_ty(oprnd), mutbl: mutbl };
|
||||||
let oprnd_t = if ty::type_is_error(tm.ty) {
|
let oprnd_t = if ty::type_is_error(tm.ty) {
|
||||||
ty::mk_err(tcx)
|
ty::mk_err()
|
||||||
} else if ty::type_is_bot(tm.ty) {
|
} else if ty::type_is_bot(tm.ty) {
|
||||||
ty::mk_bot(tcx)
|
ty::mk_bot()
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
ty::mk_rptr(tcx, region, tm)
|
ty::mk_rptr(tcx, region, tm)
|
||||||
|
@ -2387,7 +2386,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
};
|
};
|
||||||
match expr_opt {
|
match expr_opt {
|
||||||
None => match fcx.mk_eqty(false, expr.span,
|
None => match fcx.mk_eqty(false, expr.span,
|
||||||
ret_ty, ty::mk_nil(tcx)) {
|
ret_ty, ty::mk_nil()) {
|
||||||
result::Ok(_) => { /* fall through */ }
|
result::Ok(_) => { /* fall through */ }
|
||||||
result::Err(_) => {
|
result::Err(_) => {
|
||||||
tcx.sess.span_err(
|
tcx.sess.span_err(
|
||||||
|
@ -2403,7 +2402,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
ast::expr_log(lv, e) => {
|
ast::expr_log(lv, e) => {
|
||||||
check_expr_has_type(fcx, lv,
|
check_expr_has_type(fcx, lv,
|
||||||
ty::mk_mach_uint(tcx, ast::ty_u32));
|
ty::mk_mach_uint(ast::ty_u32));
|
||||||
|
|
||||||
// Note: this does not always execute, so do not propagate bot:
|
// Note: this does not always execute, so do not propagate bot:
|
||||||
check_expr(fcx, e);
|
check_expr(fcx, e);
|
||||||
|
@ -2451,7 +2450,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
ast::expr_if(cond, ref thn, elsopt) => {
|
ast::expr_if(cond, ref thn, elsopt) => {
|
||||||
check_expr_has_type(fcx, cond, ty::mk_bool(tcx));
|
check_expr_has_type(fcx, cond, ty::mk_bool());
|
||||||
check_then_else(fcx, thn, elsopt, id, expr.span);
|
check_then_else(fcx, thn, elsopt, id, expr.span);
|
||||||
let cond_ty = fcx.expr_ty(cond);
|
let cond_ty = fcx.expr_ty(cond);
|
||||||
let then_ty = fcx.node_ty(thn.node.id);
|
let then_ty = fcx.node_ty(thn.node.id);
|
||||||
|
@ -2471,7 +2470,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
// Other cases were handled by check_then_else
|
// Other cases were handled by check_then_else
|
||||||
}
|
}
|
||||||
ast::expr_while(cond, ref body) => {
|
ast::expr_while(cond, ref body) => {
|
||||||
check_expr_has_type(fcx, cond, ty::mk_bool(tcx));
|
check_expr_has_type(fcx, cond, ty::mk_bool());
|
||||||
check_block_no_value(fcx, body);
|
check_block_no_value(fcx, body);
|
||||||
let cond_ty = fcx.expr_ty(cond);
|
let cond_ty = fcx.expr_ty(cond);
|
||||||
let body_ty = fcx.node_ty(body.node.id);
|
let body_ty = fcx.node_ty(body.node.id);
|
||||||
|
@ -2539,7 +2538,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
has non-closure type: %s",
|
has non-closure type: %s",
|
||||||
actual)
|
actual)
|
||||||
}, expected_t, None);
|
}, expected_t, None);
|
||||||
let err_ty = ty::mk_err(tcx);
|
let err_ty = ty::mk_err();
|
||||||
fcx.write_ty(id, err_ty);
|
fcx.write_ty(id, err_ty);
|
||||||
err_ty
|
err_ty
|
||||||
}
|
}
|
||||||
|
@ -2706,7 +2705,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
}
|
}
|
||||||
ast::expr_repeat(element, count_expr, mutbl) => {
|
ast::expr_repeat(element, count_expr, mutbl) => {
|
||||||
let count = ty::eval_repeat_count(tcx, count_expr);
|
let count = ty::eval_repeat_count(tcx, count_expr);
|
||||||
check_expr_with_hint(fcx, count_expr, ty::mk_uint(tcx));
|
check_expr_with_hint(fcx, count_expr, ty::mk_uint());
|
||||||
let t: ty::t = fcx.infcx().next_ty_var();
|
let t: ty::t = fcx.infcx().next_ty_var();
|
||||||
check_expr_has_type(fcx, element, t);
|
check_expr_has_type(fcx, element, t);
|
||||||
let element_ty = fcx.expr_ty(element);
|
let element_ty = fcx.expr_ty(element);
|
||||||
|
@ -2782,7 +2781,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|
||||||
else {
|
else {
|
||||||
let (base_t, derefs) = do_autoderef(fcx, expr.span, raw_base_t);
|
let (base_t, derefs) = do_autoderef(fcx, expr.span, raw_base_t);
|
||||||
let base_sty = structure_of(fcx, expr.span, base_t);
|
let base_sty = structure_of(fcx, expr.span, base_t);
|
||||||
match ty::index_sty(tcx, &base_sty) {
|
match ty::index_sty(&base_sty) {
|
||||||
Some(mt) => {
|
Some(mt) => {
|
||||||
require_integral(fcx, idx.span, idx_t);
|
require_integral(fcx, idx.span, idx_t);
|
||||||
fcx.write_ty(id, mt.ty);
|
fcx.write_ty(id, mt.ty);
|
||||||
|
@ -2886,7 +2885,7 @@ pub fn check_stmt(fcx: @mut FnCtxt, stmt: @ast::stmt) {
|
||||||
ast::stmt_expr(expr, id) => {
|
ast::stmt_expr(expr, id) => {
|
||||||
node_id = id;
|
node_id = id;
|
||||||
// Check with expected type of ()
|
// Check with expected type of ()
|
||||||
check_expr_has_type(fcx, expr, ty::mk_nil(fcx.ccx.tcx));
|
check_expr_has_type(fcx, expr, ty::mk_nil());
|
||||||
let expr_ty = fcx.expr_ty(expr);
|
let expr_ty = fcx.expr_ty(expr);
|
||||||
saw_bot = saw_bot || ty::type_is_bot(expr_ty);
|
saw_bot = saw_bot || ty::type_is_bot(expr_ty);
|
||||||
saw_err = saw_err || ty::type_is_error(expr_ty);
|
saw_err = saw_err || ty::type_is_error(expr_ty);
|
||||||
|
@ -2912,7 +2911,7 @@ pub fn check_stmt(fcx: @mut FnCtxt, stmt: @ast::stmt) {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn check_block_no_value(fcx: @mut FnCtxt, blk: &ast::blk) {
|
pub fn check_block_no_value(fcx: @mut FnCtxt, blk: &ast::blk) {
|
||||||
check_block_with_expected(fcx, blk, Some(ty::mk_nil(fcx.ccx.tcx)));
|
check_block_with_expected(fcx, blk, Some(ty::mk_nil()));
|
||||||
let blkty = fcx.node_ty(blk.node.id);
|
let blkty = fcx.node_ty(blk.node.id);
|
||||||
if ty::type_is_error(blkty) {
|
if ty::type_is_error(blkty) {
|
||||||
fcx.write_error(blk.node.id);
|
fcx.write_error(blk.node.id);
|
||||||
|
@ -2921,7 +2920,7 @@ pub fn check_block_no_value(fcx: @mut FnCtxt, blk: &ast::blk) {
|
||||||
fcx.write_bot(blk.node.id);
|
fcx.write_bot(blk.node.id);
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
let nilty = ty::mk_nil(fcx.ccx.tcx);
|
let nilty = ty::mk_nil();
|
||||||
demand::suptype(fcx, blk.span, nilty, blkty);
|
demand::suptype(fcx, blk.span, nilty, blkty);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -3054,7 +3053,7 @@ pub fn check_enum_variants(ccx: @mut CrateCtxt,
|
||||||
let e = *e_ref;
|
let e = *e_ref;
|
||||||
debug!("disr expr, checking %s",
|
debug!("disr expr, checking %s",
|
||||||
pprust::expr_to_str(e, ccx.tcx.sess.intr()));
|
pprust::expr_to_str(e, ccx.tcx.sess.intr()));
|
||||||
let declty = ty::mk_int(ccx.tcx);
|
let declty = ty::mk_int();
|
||||||
let fcx = blank_fn_ctxt(ccx, rty, e.id);
|
let fcx = blank_fn_ctxt(ccx, rty, e.id);
|
||||||
check_const_with_ty(fcx, e.span, e, declty);
|
check_const_with_ty(fcx, e.span, e, declty);
|
||||||
// check_expr (from check_const pass) doesn't guarantee
|
// check_expr (from check_const pass) doesn't guarantee
|
||||||
|
@ -3173,7 +3172,7 @@ pub fn ty_param_bounds_and_ty_for_def(fcx: @mut FnCtxt,
|
||||||
ty: ty::mk_ptr(
|
ty: ty::mk_ptr(
|
||||||
fcx.ccx.tcx,
|
fcx.ccx.tcx,
|
||||||
ty::mt {
|
ty::mt {
|
||||||
ty: ty::mk_mach_uint(fcx.ccx.tcx, ast::ty_u8),
|
ty: ty::mk_mach_uint(ast::ty_u8),
|
||||||
mutbl: ast::m_imm
|
mutbl: ast::m_imm
|
||||||
})
|
})
|
||||||
};
|
};
|
||||||
|
@ -3296,7 +3295,7 @@ pub fn structurally_resolved_type(fcx: @mut FnCtxt, sp: span, tp: ty::t)
|
||||||
fcx.type_error_message(sp, |_actual| {
|
fcx.type_error_message(sp, |_actual| {
|
||||||
~"the type of this value must be known in this context"
|
~"the type of this value must be known in this context"
|
||||||
}, tp, None);
|
}, tp, None);
|
||||||
demand::suptype(fcx, sp, ty::mk_err(fcx.tcx()), tp);
|
demand::suptype(fcx, sp, ty::mk_err(), tp);
|
||||||
tp
|
tp
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -3413,10 +3412,10 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
|
||||||
let tcx = ccx.tcx;
|
let tcx = ccx.tcx;
|
||||||
let (n_tps, inputs, output) = match *ccx.tcx.sess.str_of(it.ident) {
|
let (n_tps, inputs, output) = match *ccx.tcx.sess.str_of(it.ident) {
|
||||||
~"size_of" |
|
~"size_of" |
|
||||||
~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint(ccx.tcx)),
|
~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint()),
|
||||||
~"init" => (1u, ~[], param(ccx, 0u)),
|
~"init" => (1u, ~[], param(ccx, 0u)),
|
||||||
~"forget" => (1u, ~[arg(ast::by_copy, param(ccx, 0u))],
|
~"forget" => (1u, ~[arg(ast::by_copy, param(ccx, 0u))],
|
||||||
ty::mk_nil(tcx)),
|
ty::mk_nil()),
|
||||||
~"reinterpret_cast" => (2u, ~[arg(ast::by_ref, param(ccx, 0u))],
|
~"reinterpret_cast" => (2u, ~[arg(ast::by_ref, param(ccx, 0u))],
|
||||||
param(ccx, 1u)),
|
param(ccx, 1u)),
|
||||||
~"addr_of" => (1u, ~[arg(ast::by_ref, param(ccx, 0u))],
|
~"addr_of" => (1u, ~[arg(ast::by_ref, param(ccx, 0u))],
|
||||||
|
@ -3426,41 +3425,41 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
|
||||||
ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)),
|
ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)),
|
||||||
param(ccx, 0u))),
|
param(ccx, 0u))),
|
||||||
arg(ast::by_copy, param(ccx, 0u))],
|
arg(ast::by_copy, param(ccx, 0u))],
|
||||||
ty::mk_nil(tcx))
|
ty::mk_nil())
|
||||||
}
|
}
|
||||||
~"needs_drop" => (1u, ~[], ty::mk_bool(tcx)),
|
~"needs_drop" => (1u, ~[], ty::mk_bool()),
|
||||||
|
|
||||||
~"atomic_cxchg" | ~"atomic_cxchg_acq"| ~"atomic_cxchg_rel" => {
|
~"atomic_cxchg" | ~"atomic_cxchg_acq"| ~"atomic_cxchg_rel" => {
|
||||||
(0u, ~[arg(ast::by_copy,
|
(0u, ~[arg(ast::by_copy,
|
||||||
ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)),
|
ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)),
|
||||||
ty::mk_int(tcx))),
|
ty::mk_int())),
|
||||||
arg(ast::by_copy, ty::mk_int(tcx)),
|
arg(ast::by_copy, ty::mk_int()),
|
||||||
arg(ast::by_copy, ty::mk_int(tcx))],
|
arg(ast::by_copy, ty::mk_int())],
|
||||||
ty::mk_int(tcx))
|
ty::mk_int())
|
||||||
}
|
}
|
||||||
~"atomic_xchg" | ~"atomic_xadd" | ~"atomic_xsub" |
|
~"atomic_xchg" | ~"atomic_xadd" | ~"atomic_xsub" |
|
||||||
~"atomic_xchg_acq" | ~"atomic_xadd_acq" | ~"atomic_xsub_acq" |
|
~"atomic_xchg_acq" | ~"atomic_xadd_acq" | ~"atomic_xsub_acq" |
|
||||||
~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => {
|
~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => {
|
||||||
(0u, ~[arg(ast::by_copy,
|
(0u, ~[arg(ast::by_copy,
|
||||||
ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)),
|
ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)),
|
||||||
ty::mk_int(tcx))),
|
ty::mk_int())),
|
||||||
arg(ast::by_copy, ty::mk_int(tcx))],
|
arg(ast::by_copy, ty::mk_int())],
|
||||||
ty::mk_int(tcx))
|
ty::mk_int())
|
||||||
}
|
}
|
||||||
|
|
||||||
~"get_tydesc" => {
|
~"get_tydesc" => {
|
||||||
// FIXME (#3730): return *intrinsic::tydesc, not *()
|
// FIXME (#3730): return *intrinsic::tydesc, not *()
|
||||||
(1u, ~[], ty::mk_nil_ptr(tcx))
|
(1u, ~[], ty::mk_nil_ptr(ccx.tcx))
|
||||||
}
|
}
|
||||||
~"visit_tydesc" => {
|
~"visit_tydesc" => {
|
||||||
let tydesc_name = special_idents::tydesc;
|
let tydesc_name = special_idents::tydesc;
|
||||||
assert!(tcx.intrinsic_defs.contains_key(&tydesc_name));
|
assert!(tcx.intrinsic_defs.contains_key(&tydesc_name));
|
||||||
let (_, tydesc_ty) = *tcx.intrinsic_defs.get(&tydesc_name);
|
let (_, tydesc_ty) = *tcx.intrinsic_defs.get(&tydesc_name);
|
||||||
let (_, visitor_object_ty) = ty::visitor_object_ty(tcx);
|
let (_, visitor_object_ty) = ty::visitor_object_ty(ccx.tcx);
|
||||||
let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {ty: tydesc_ty,
|
let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {ty: tydesc_ty,
|
||||||
mutbl: ast::m_imm});
|
mutbl: ast::m_imm});
|
||||||
(0u, ~[arg(ast::by_copy, td_ptr),
|
(0u, ~[arg(ast::by_copy, td_ptr),
|
||||||
arg(ast::by_ref, visitor_object_ty)], ty::mk_nil(tcx))
|
arg(ast::by_ref, visitor_object_ty)], ty::mk_nil())
|
||||||
}
|
}
|
||||||
~"frame_address" => {
|
~"frame_address" => {
|
||||||
let fty = ty::mk_closure(ccx.tcx, ty::ClosureTy {
|
let fty = ty::mk_closure(ccx.tcx, ty::ClosureTy {
|
||||||
|
@ -3473,224 +3472,224 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
|
||||||
inputs: ~[arg {mode: ast::expl(ast::by_copy),
|
inputs: ~[arg {mode: ast::expl(ast::by_copy),
|
||||||
ty: ty::mk_imm_ptr(
|
ty: ty::mk_imm_ptr(
|
||||||
ccx.tcx,
|
ccx.tcx,
|
||||||
ty::mk_mach_uint(ccx.tcx, ast::ty_u8))}],
|
ty::mk_mach_uint(ast::ty_u8))}],
|
||||||
output: ty::mk_nil(ccx.tcx)
|
output: ty::mk_nil()
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
(0u, ~[arg(ast::by_ref, fty)], ty::mk_nil(tcx))
|
(0u, ~[arg(ast::by_ref, fty)], ty::mk_nil())
|
||||||
}
|
}
|
||||||
~"morestack_addr" => {
|
~"morestack_addr" => {
|
||||||
(0u, ~[], ty::mk_nil_ptr(tcx))
|
(0u, ~[], ty::mk_nil_ptr(ccx.tcx))
|
||||||
}
|
}
|
||||||
~"memmove32" => {
|
~"memmove32" => {
|
||||||
(0, ~[arg(ast::by_copy,
|
(0, ~[arg(ast::by_copy,
|
||||||
ty::mk_ptr(tcx,
|
ty::mk_ptr(tcx,
|
||||||
ty::mt { ty: ty::mk_u8(tcx), mutbl: ast::m_mutbl })),
|
ty::mt { ty: ty::mk_u8(), mutbl: ast::m_mutbl })),
|
||||||
arg(ast::by_copy,
|
arg(ast::by_copy,
|
||||||
ty::mk_ptr(tcx,
|
ty::mk_ptr(tcx,
|
||||||
ty::mt { ty: ty::mk_u8(tcx), mutbl: ast::m_imm })),
|
ty::mt { ty: ty::mk_u8(), mutbl: ast::m_imm })),
|
||||||
arg(ast::by_copy,
|
arg(ast::by_copy,
|
||||||
ty::mk_u32(tcx))],
|
ty::mk_u32())],
|
||||||
ty::mk_nil(tcx))
|
ty::mk_nil())
|
||||||
}
|
}
|
||||||
~"memmove64" => {
|
~"memmove64" => {
|
||||||
(0, ~[arg(ast::by_copy,
|
(0, ~[arg(ast::by_copy,
|
||||||
ty::mk_ptr(tcx,
|
ty::mk_ptr(tcx,
|
||||||
ty::mt { ty: ty::mk_u8(tcx), mutbl: ast::m_mutbl })),
|
ty::mt { ty: ty::mk_u8(), mutbl: ast::m_mutbl })),
|
||||||
arg(ast::by_copy,
|
arg(ast::by_copy,
|
||||||
ty::mk_ptr(tcx,
|
ty::mk_ptr(tcx,
|
||||||
ty::mt { ty: ty::mk_u8(tcx), mutbl: ast::m_imm })),
|
ty::mt { ty: ty::mk_u8(), mutbl: ast::m_imm })),
|
||||||
arg(ast::by_copy,
|
arg(ast::by_copy,
|
||||||
ty::mk_u64(tcx))],
|
ty::mk_u64())],
|
||||||
ty::mk_nil(tcx))
|
ty::mk_nil())
|
||||||
}
|
}
|
||||||
~"sqrtf32" => {
|
~"sqrtf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"sqrtf64" => {
|
~"sqrtf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"powif32" => {
|
~"powif32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx)),
|
(0u, ~[arg(ast::by_copy, ty::mk_f32()),
|
||||||
arg(ast::by_copy, ty::mk_i32(tcx))],
|
arg(ast::by_copy, ty::mk_i32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"powif64" => {
|
~"powif64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx)),
|
(0u, ~[arg(ast::by_copy, ty::mk_f64()),
|
||||||
arg(ast::by_copy, ty::mk_i32(tcx))],
|
arg(ast::by_copy, ty::mk_i32())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"sinf32" => {
|
~"sinf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"sinf64" => {
|
~"sinf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"cosf32" => {
|
~"cosf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"cosf64" => {
|
~"cosf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"powf32" => {
|
~"powf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx)),
|
(0u, ~[arg(ast::by_copy, ty::mk_f32()),
|
||||||
arg(ast::by_copy, ty::mk_f32(tcx))],
|
arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"powf64" => {
|
~"powf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx)),
|
(0u, ~[arg(ast::by_copy, ty::mk_f64()),
|
||||||
arg(ast::by_copy, ty::mk_f64(tcx))],
|
arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"expf32" => {
|
~"expf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"expf64" => {
|
~"expf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"exp2f32" => {
|
~"exp2f32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"exp2f64" => {
|
~"exp2f64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"logf32" => {
|
~"logf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"logf64" => {
|
~"logf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"log10f32" => {
|
~"log10f32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"log10f64" => {
|
~"log10f64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"log2f32" => {
|
~"log2f32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"log2f64" => {
|
~"log2f64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"fmaf32" => {
|
~"fmaf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx)),
|
(0u, ~[arg(ast::by_copy, ty::mk_f32()),
|
||||||
arg(ast::by_copy, ty::mk_f32(tcx)),
|
arg(ast::by_copy, ty::mk_f32()),
|
||||||
arg(ast::by_copy, ty::mk_f32(tcx))],
|
arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"fmaf64" => {
|
~"fmaf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx)),
|
(0u, ~[arg(ast::by_copy, ty::mk_f64()),
|
||||||
arg(ast::by_copy, ty::mk_f64(tcx)),
|
arg(ast::by_copy, ty::mk_f64()),
|
||||||
arg(ast::by_copy, ty::mk_f64(tcx))],
|
arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"fabsf32" => {
|
~"fabsf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"fabsf64" => {
|
~"fabsf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"floorf32" => {
|
~"floorf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"floorf64" => {
|
~"floorf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"ceilf32" => {
|
~"ceilf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"ceilf64" => {
|
~"ceilf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"truncf32" => {
|
~"truncf32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f32())],
|
||||||
ty::mk_f32(tcx))
|
ty::mk_f32())
|
||||||
}
|
}
|
||||||
~"truncf64" => {
|
~"truncf64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_f64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_f64())],
|
||||||
ty::mk_f64(tcx))
|
ty::mk_f64())
|
||||||
}
|
}
|
||||||
~"ctpop8" => {
|
~"ctpop8" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i8(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i8())],
|
||||||
ty::mk_i8(tcx))
|
ty::mk_i8())
|
||||||
}
|
}
|
||||||
~"ctpop16" => {
|
~"ctpop16" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i16(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i16())],
|
||||||
ty::mk_i16(tcx))
|
ty::mk_i16())
|
||||||
}
|
}
|
||||||
~"ctpop32" => {
|
~"ctpop32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i32())],
|
||||||
ty::mk_i32(tcx))
|
ty::mk_i32())
|
||||||
}
|
}
|
||||||
~"ctpop64" => {
|
~"ctpop64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i64())],
|
||||||
ty::mk_i64(tcx))
|
ty::mk_i64())
|
||||||
}
|
}
|
||||||
~"ctlz8" => {
|
~"ctlz8" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i8(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i8())],
|
||||||
ty::mk_i8(tcx))
|
ty::mk_i8())
|
||||||
}
|
}
|
||||||
~"ctlz16" => {
|
~"ctlz16" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i16(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i16())],
|
||||||
ty::mk_i16(tcx))
|
ty::mk_i16())
|
||||||
}
|
}
|
||||||
~"ctlz32" => {
|
~"ctlz32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i32())],
|
||||||
ty::mk_i32(tcx))
|
ty::mk_i32())
|
||||||
}
|
}
|
||||||
~"ctlz64" => {
|
~"ctlz64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i64())],
|
||||||
ty::mk_i64(tcx))
|
ty::mk_i64())
|
||||||
}
|
}
|
||||||
~"cttz8" => {
|
~"cttz8" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i8(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i8())],
|
||||||
ty::mk_i8(tcx))
|
ty::mk_i8())
|
||||||
}
|
}
|
||||||
~"cttz16" => {
|
~"cttz16" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i16(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i16())],
|
||||||
ty::mk_i16(tcx))
|
ty::mk_i16())
|
||||||
}
|
}
|
||||||
~"cttz32" => {
|
~"cttz32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i32())],
|
||||||
ty::mk_i32(tcx))
|
ty::mk_i32())
|
||||||
}
|
}
|
||||||
~"cttz64" => {
|
~"cttz64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i64())],
|
||||||
ty::mk_i64(tcx))
|
ty::mk_i64())
|
||||||
}
|
}
|
||||||
~"bswap16" => {
|
~"bswap16" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i16(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i16())],
|
||||||
ty::mk_i16(tcx))
|
ty::mk_i16())
|
||||||
}
|
}
|
||||||
~"bswap32" => {
|
~"bswap32" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i32(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i32())],
|
||||||
ty::mk_i32(tcx))
|
ty::mk_i32())
|
||||||
}
|
}
|
||||||
~"bswap64" => {
|
~"bswap64" => {
|
||||||
(0u, ~[arg(ast::by_copy, ty::mk_i64(tcx))],
|
(0u, ~[arg(ast::by_copy, ty::mk_i64())],
|
||||||
ty::mk_i64(tcx))
|
ty::mk_i64())
|
||||||
}
|
}
|
||||||
ref other => {
|
ref other => {
|
||||||
tcx.sess.span_err(it.span, ~"unrecognized intrinsic function: `" +
|
tcx.sess.span_err(it.span, ~"unrecognized intrinsic function: `" +
|
||||||
|
|
|
@ -108,7 +108,7 @@ pub impl Rcx {
|
||||||
match resolve_type(self.fcx.infcx(), unresolved_ty,
|
match resolve_type(self.fcx.infcx(), unresolved_ty,
|
||||||
resolve_and_force_all_but_regions) {
|
resolve_and_force_all_but_regions) {
|
||||||
Ok(t) => t,
|
Ok(t) => t,
|
||||||
Err(_) => ty::mk_err(self.fcx.tcx())
|
Err(_) => ty::mk_err()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -57,7 +57,7 @@ fn resolve_type_vars_in_types(fcx: @mut FnCtxt, sp: span, tys: &[ty::t])
|
||||||
tys.map(|t| {
|
tys.map(|t| {
|
||||||
match resolve_type_vars_in_type(fcx, sp, *t) {
|
match resolve_type_vars_in_type(fcx, sp, *t) {
|
||||||
Some(t1) => t1,
|
Some(t1) => t1,
|
||||||
None => ty::mk_err(fcx.ccx.tcx)
|
None => ty::mk_err()
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
|
@ -613,14 +613,13 @@ pub fn super_tys<C:Combine>(
|
||||||
vid: ty::IntVid,
|
vid: ty::IntVid,
|
||||||
val: ty::IntVarValue) -> cres<ty::t>
|
val: ty::IntVarValue) -> cres<ty::t>
|
||||||
{
|
{
|
||||||
let tcx = self.infcx().tcx;
|
|
||||||
if val == IntType(ast::ty_char) {
|
if val == IntType(ast::ty_char) {
|
||||||
Err(ty::terr_integer_as_char)
|
Err(ty::terr_integer_as_char)
|
||||||
} else {
|
} else {
|
||||||
if_ok!(self.infcx().simple_var_t(vid_is_expected, vid, val));
|
if_ok!(self.infcx().simple_var_t(vid_is_expected, vid, val));
|
||||||
match val {
|
match val {
|
||||||
IntType(v) => Ok(ty::mk_mach_int(tcx, v)),
|
IntType(v) => Ok(ty::mk_mach_int(v)),
|
||||||
UintType(v) => Ok(ty::mk_mach_uint(tcx, v))
|
UintType(v) => Ok(ty::mk_mach_uint(v))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -631,9 +630,8 @@ pub fn super_tys<C:Combine>(
|
||||||
vid: ty::FloatVid,
|
vid: ty::FloatVid,
|
||||||
val: ast::float_ty) -> cres<ty::t>
|
val: ast::float_ty) -> cres<ty::t>
|
||||||
{
|
{
|
||||||
let tcx = self.infcx().tcx;
|
|
||||||
if_ok!(self.infcx().simple_var_t(vid_is_expected, vid, val));
|
if_ok!(self.infcx().simple_var_t(vid_is_expected, vid, val));
|
||||||
Ok(ty::mk_mach_float(tcx, val))
|
Ok(ty::mk_mach_float(val))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -327,7 +327,7 @@ impl LatticeDir for Glb {
|
||||||
|
|
||||||
impl TyLatticeDir for Glb {
|
impl TyLatticeDir for Glb {
|
||||||
fn ty_bot(&self, _t: ty::t) -> cres<ty::t> {
|
fn ty_bot(&self, _t: ty::t) -> cres<ty::t> {
|
||||||
Ok(ty::mk_bot(self.infcx.tcx))
|
Ok(ty::mk_bot())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -245,12 +245,12 @@ pub impl ResolveState {
|
||||||
|
|
||||||
let node = self.infcx.get(vid);
|
let node = self.infcx.get(vid);
|
||||||
match node.possible_types {
|
match node.possible_types {
|
||||||
Some(IntType(t)) => ty::mk_mach_int(self.infcx.tcx, t),
|
Some(IntType(t)) => ty::mk_mach_int(t),
|
||||||
Some(UintType(t)) => ty::mk_mach_uint(self.infcx.tcx, t),
|
Some(UintType(t)) => ty::mk_mach_uint(t),
|
||||||
None => {
|
None => {
|
||||||
if self.should(force_ivar) {
|
if self.should(force_ivar) {
|
||||||
// As a last resort, default to int.
|
// As a last resort, default to int.
|
||||||
let ty = ty::mk_int(self.infcx.tcx);
|
let ty = ty::mk_int();
|
||||||
self.infcx.set(vid,
|
self.infcx.set(vid,
|
||||||
Root(Some(IntType(ast::ty_i)), node.rank));
|
Root(Some(IntType(ast::ty_i)), node.rank));
|
||||||
ty
|
ty
|
||||||
|
@ -268,11 +268,11 @@ pub impl ResolveState {
|
||||||
|
|
||||||
let node = self.infcx.get(vid);
|
let node = self.infcx.get(vid);
|
||||||
match node.possible_types {
|
match node.possible_types {
|
||||||
Some(t) => ty::mk_mach_float(self.infcx.tcx, t),
|
Some(t) => ty::mk_mach_float(t),
|
||||||
None => {
|
None => {
|
||||||
if self.should(force_fvar) {
|
if self.should(force_fvar) {
|
||||||
// As a last resort, default to float.
|
// As a last resort, default to float.
|
||||||
let ty = ty::mk_float(self.infcx.tcx);
|
let ty = ty::mk_float();
|
||||||
self.infcx.set(vid, Root(Some(ast::ty_f), node.rank));
|
self.infcx.set(vid, Root(Some(ast::ty_f), node.rank));
|
||||||
ty
|
ty
|
||||||
} else {
|
} else {
|
||||||
|
|
|
@ -363,11 +363,11 @@ fn check_start_fn_ty(ccx: @mut CrateCtxt,
|
||||||
purity: ast::impure_fn,
|
purity: ast::impure_fn,
|
||||||
abis: abi::AbiSet::Rust(),
|
abis: abi::AbiSet::Rust(),
|
||||||
sig: ty::FnSig {bound_lifetime_names: opt_vec::Empty,
|
sig: ty::FnSig {bound_lifetime_names: opt_vec::Empty,
|
||||||
inputs: ~[arg(ast::by_copy, ty::mk_int(tcx)),
|
inputs: ~[arg(ast::by_copy, ty::mk_int()),
|
||||||
arg(ast::by_copy, ty::mk_imm_ptr(tcx,
|
arg(ast::by_copy, ty::mk_imm_ptr(tcx,
|
||||||
ty::mk_imm_ptr(tcx, ty::mk_u8(tcx)))),
|
ty::mk_imm_ptr(tcx, ty::mk_u8()))),
|
||||||
arg(ast::by_copy, ty::mk_imm_ptr(tcx, ty::mk_u8(tcx)))],
|
arg(ast::by_copy, ty::mk_imm_ptr(tcx, ty::mk_u8()))],
|
||||||
output: ty::mk_int(tcx)}
|
output: ty::mk_int()}
|
||||||
});
|
});
|
||||||
|
|
||||||
require_same_types(tcx, None, false, start_span, start_t, se_ty,
|
require_same_types(tcx, None, false, start_span, start_t, se_ty,
|
||||||
|
|
Loading…
Reference in a new issue