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

Allow truncating constants to 16-bit u/isize

Browse Source
This commit is contained in:
Jake Goulding 2016-06-09 17:01:05 -04:00
parent e51958ba72
commit 1858cfb80d
3 changed files with 25 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/librustc_const_eval/eval.rs
View File

@ -956,10 +956,7 @@ fn infer<'a, 'tcx>(i: ConstInt,
(&ty::TyInt(IntTy::I32), Infer(i)) => Ok(I32(i as i64 as i32)),
(&ty::TyInt(IntTy::I64), Infer(i)) => Ok(I64(i as i64)),
(&ty::TyInt(IntTy::Is), Infer(i)) => {
match ConstIsize::new(i as i64, tcx.sess.target.int_type) {
Ok(val) => Ok(Isize(val)),
Err(_) => Ok(Isize(ConstIsize::Is32(i as i64 as i32))),
}
Ok(Isize(ConstIsize::new_truncating(i as i64, tcx.sess.target.int_type)))
},
(&ty::TyInt(IntTy::I8), InferSigned(i)) => Ok(I8(i as i8)),
@ -967,10 +964,7 @@ fn infer<'a, 'tcx>(i: ConstInt,
(&ty::TyInt(IntTy::I32), InferSigned(i)) => Ok(I32(i as i32)),
(&ty::TyInt(IntTy::I64), InferSigned(i)) => Ok(I64(i)),
(&ty::TyInt(IntTy::Is), InferSigned(i)) => {
match ConstIsize::new(i, tcx.sess.target.int_type) {
Ok(val) => Ok(Isize(val)),
Err(_) => Ok(Isize(ConstIsize::Is32(i as i32))),
}
Ok(Isize(ConstIsize::new_truncating(i, tcx.sess.target.int_type)))
},
(&ty::TyUint(UintTy::U8), Infer(i)) => Ok(U8(i as u8)),
@ -978,10 +972,7 @@ fn infer<'a, 'tcx>(i: ConstInt,
(&ty::TyUint(UintTy::U32), Infer(i)) => Ok(U32(i as u32)),
(&ty::TyUint(UintTy::U64), Infer(i)) => Ok(U64(i)),
(&ty::TyUint(UintTy::Us), Infer(i)) => {
match ConstUsize::new(i, tcx.sess.target.uint_type) {
Ok(val) => Ok(Usize(val)),
Err(_) => Ok(Usize(ConstUsize::Us32(i as u32))),
}
Ok(Usize(ConstUsize::new_truncating(i, tcx.sess.target.uint_type)))
},
(&ty::TyUint(_), InferSigned(_)) => Err(IntermediateUnsignedNegative),
@ -1063,20 +1054,14 @@ fn cast_const_int<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, val: ConstInt, ty: ty::
ty::TyInt(ast::IntTy::I32) => Ok(Integral(I32(v as i64 as i32))),
ty::TyInt(ast::IntTy::I64) => Ok(Integral(I64(v as i64))),
ty::TyInt(ast::IntTy::Is) => {
match ConstIsize::new(v as i64, tcx.sess.target.int_type) {
Ok(val) => Ok(Integral(Isize(val))),
Err(_) => Ok(Integral(Isize(ConstIsize::Is32(v as i64 as i32)))),
}
Ok(Integral(Isize(ConstIsize::new_truncating(v as i64, tcx.sess.target.int_type))))
},
ty::TyUint(ast::UintTy::U8) => Ok(Integral(U8(v as u8))),
ty::TyUint(ast::UintTy::U16) => Ok(Integral(U16(v as u16))),
ty::TyUint(ast::UintTy::U32) => Ok(Integral(U32(v as u32))),
ty::TyUint(ast::UintTy::U64) => Ok(Integral(U64(v))),
ty::TyUint(ast::UintTy::Us) => {
match ConstUsize::new(v, tcx.sess.target.uint_type) {
Ok(val) => Ok(Integral(Usize(val))),
Err(_) => Ok(Integral(Usize(ConstUsize::Us32(v as u32)))),
}
Ok(Integral(Usize(ConstUsize::new_truncating(v, tcx.sess.target.uint_type))))
},
ty::TyFloat(ast::FloatTy::F64) => match val.erase_type() {
Infer(u) => Ok(Float(F64(u as f64))),

11
src/librustc_const_math/is.rs
View File

@ -27,7 +27,8 @@ impl ConstIsize {
(Is16(i), ast::IntTy::I16) => i as i64,
(Is32(i), ast::IntTy::I32) => i as i64,
(Is64(i), ast::IntTy::I64) => i,
_ => panic!("got invalid isize size for target"),
_ => panic!("unable to convert self ({:?}) to target isize ({:?})",
self, target_int_ty),
}
}
pub fn new(i: i64, target_int_ty: ast::IntTy) -> Result<Self, ConstMathErr> {
@ -40,4 +41,12 @@ impl ConstIsize {
_ => unreachable!(),
}
}
pub fn new_truncating(i: i64, target_int_ty: ast::IntTy) -> Self {
match target_int_ty {
ast::IntTy::I16 => Is16(i as i16),
ast::IntTy::I32 => Is32(i as i32),
ast::IntTy::I64 => Is64(i),
_ => unreachable!(),
}
}
}

11
src/librustc_const_math/us.rs
View File

@ -27,7 +27,8 @@ impl ConstUsize {
(Us16(i), ast::UintTy::U16) => i as u64,
(Us32(i), ast::UintTy::U32) => i as u64,
(Us64(i), ast::UintTy::U64) => i,
_ => panic!("got invalid usize size for target"),
_ => panic!("unable to convert self ({:?}) to target usize ({:?})",
self, target_uint_ty),
}
}
pub fn new(i: u64, target_uint_ty: ast::UintTy) -> Result<Self, ConstMathErr> {
@ -40,4 +41,12 @@ impl ConstUsize {
_ => unreachable!(),
}
}
pub fn new_truncating(i: u64, target_uint_ty: ast::UintTy) -> Self {
match target_uint_ty {
ast::UintTy::U16 => Us16(i as u16),
ast::UintTy::U32 => Us32(i as u32),
ast::UintTy::U64 => Us64(i),
_ => unreachable!(),
}
}
}