use middle::ty::fold::TypeFoldable;
use std::fmt;
-use syntax::abi;
-use syntax::ast;
+use syntax::{abi, ast_util};
use syntax::parse::token;
use syntax::ast::CRATE_NODE_ID;
use rustc_front::hir;
}
}
-pub fn int_ty_to_string(t: ast::IntTy, val: Option<i64>) -> String {
- let s = match t {
- ast::TyIs => "isize",
- ast::TyI8 => "i8",
- ast::TyI16 => "i16",
- ast::TyI32 => "i32",
- ast::TyI64 => "i64"
- };
-
- match val {
- // cast to a u64 so we can correctly print INT64_MIN. All integral types
- // are parsed as u64, so we wouldn't want to print an extra negative
- // sign.
- Some(n) => format!("{}{}", n as u64, s),
- None => s.to_string()
- }
-}
-
-pub fn uint_ty_to_string(t: ast::UintTy, val: Option<u64>) -> String {
- let s = match t {
- ast::TyUs => "usize",
- ast::TyU8 => "u8",
- ast::TyU16 => "u16",
- ast::TyU32 => "u32",
- ast::TyU64 => "u64"
- };
-
- match val {
- Some(n) => format!("{}{}", n, s),
- None => s.to_string()
- }
-}
-
-
-pub fn float_ty_to_string(t: ast::FloatTy) -> String {
- match t {
- ast::TyF32 => "f32".to_string(),
- ast::TyF64 => "f64".to_string(),
- }
-}
-
impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TyBool => write!(f, "bool"),
TyChar => write!(f, "char"),
- TyInt(t) => write!(f, "{}", int_ty_to_string(t, None)),
- TyUint(t) => write!(f, "{}", uint_ty_to_string(t, None)),
- TyFloat(t) => write!(f, "{}", float_ty_to_string(t)),
+ TyInt(t) => write!(f, "{}", ast_util::int_ty_to_string(t)),
+ TyUint(t) => write!(f, "{}", ast_util::uint_ty_to_string(t)),
+ TyFloat(t) => write!(f, "{}", ast_util::float_ty_to_string(t)),
TyBox(typ) => write!(f, "Box<{}>", typ),
TyRawPtr(ref tm) => {
write!(f, "*{} {}", match tm.mutbl {
use syntax;
use syntax::util::interner::Interner;
use syntax::codemap::Span;
-use syntax::{ast, codemap};
+use syntax::{ast, ast_util, codemap};
use syntax::parse::token;
let (name, encoding) = match t.sty {
ty::TyTuple(ref elements) if elements.is_empty() =>
- ("()".to_string(), DW_ATE_unsigned),
- ty::TyBool => ("bool".to_string(), DW_ATE_boolean),
- ty::TyChar => ("char".to_string(), DW_ATE_unsigned_char),
- ty::TyInt(int_ty) => match int_ty {
- ast::TyIs => ("isize".to_string(), DW_ATE_signed),
- ast::TyI8 => ("i8".to_string(), DW_ATE_signed),
- ast::TyI16 => ("i16".to_string(), DW_ATE_signed),
- ast::TyI32 => ("i32".to_string(), DW_ATE_signed),
- ast::TyI64 => ("i64".to_string(), DW_ATE_signed)
+ ("()", DW_ATE_unsigned),
+ ty::TyBool => ("bool", DW_ATE_boolean),
+ ty::TyChar => ("char", DW_ATE_unsigned_char),
+ ty::TyInt(int_ty) => {
+ (ast_util::int_ty_to_string(int_ty), DW_ATE_signed)
},
- ty::TyUint(uint_ty) => match uint_ty {
- ast::TyUs => ("usize".to_string(), DW_ATE_unsigned),
- ast::TyU8 => ("u8".to_string(), DW_ATE_unsigned),
- ast::TyU16 => ("u16".to_string(), DW_ATE_unsigned),
- ast::TyU32 => ("u32".to_string(), DW_ATE_unsigned),
- ast::TyU64 => ("u64".to_string(), DW_ATE_unsigned)
+ ty::TyUint(uint_ty) => {
+ (ast_util::uint_ty_to_string(uint_ty), DW_ATE_unsigned)
},
- ty::TyFloat(float_ty) => match float_ty {
- ast::TyF32 => ("f32".to_string(), DW_ATE_float),
- ast::TyF64 => ("f64".to_string(), DW_ATE_float),
+ ty::TyFloat(float_ty) => {
+ (ast_util::float_ty_to_string(float_ty), DW_ATE_float)
},
_ => cx.sess().bug("debuginfo::basic_type_metadata - t is invalid type")
};
use middle::ty::{self, Ty};
use rustc_front::hir;
-use syntax::ast;
+use syntax::ast_util;
// Compute the name of the type as it should be stored in debuginfo. Does not do
// any caching, i.e. calling the function twice with the same type will also do
qualified: bool,
output: &mut String) {
match t.sty {
- ty::TyBool => output.push_str("bool"),
- ty::TyChar => output.push_str("char"),
- ty::TyStr => output.push_str("str"),
- ty::TyInt(ast::TyIs) => output.push_str("isize"),
- ty::TyInt(ast::TyI8) => output.push_str("i8"),
- ty::TyInt(ast::TyI16) => output.push_str("i16"),
- ty::TyInt(ast::TyI32) => output.push_str("i32"),
- ty::TyInt(ast::TyI64) => output.push_str("i64"),
- ty::TyUint(ast::TyUs) => output.push_str("usize"),
- ty::TyUint(ast::TyU8) => output.push_str("u8"),
- ty::TyUint(ast::TyU16) => output.push_str("u16"),
- ty::TyUint(ast::TyU32) => output.push_str("u32"),
- ty::TyUint(ast::TyU64) => output.push_str("u64"),
- ty::TyFloat(ast::TyF32) => output.push_str("f32"),
- ty::TyFloat(ast::TyF64) => output.push_str("f64"),
+ ty::TyBool => output.push_str("bool"),
+ ty::TyChar => output.push_str("char"),
+ ty::TyStr => output.push_str("str"),
+ ty::TyInt(int_ty) => output.push_str(ast_util::int_ty_to_string(int_ty)),
+ ty::TyUint(uint_ty) => output.push_str(ast_util::uint_ty_to_string(uint_ty)),
+ ty::TyFloat(float_ty) => output.push_str(ast_util::float_ty_to_string(float_ty)),
ty::TyStruct(def, substs) |
ty::TyEnum(def, substs) => {
push_item_name(cx, def.did, qualified, output);
impl fmt::Display for IntTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", ast_util::int_ty_to_string(*self, None))
+ write!(f, "{}", ast_util::int_ty_to_string(*self))
}
}
impl fmt::Display for UintTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", ast_util::uint_ty_to_string(*self, None))
+ write!(f, "{}", ast_util::uint_ty_to_string(*self))
}
}
match e.node { ExprPath(..) => true, _ => false }
}
-/// Get a string representation of a signed int type, with its value.
-/// We want to avoid "45int" and "-3int" in favor of "45" and "-3"
-pub fn int_ty_to_string(t: IntTy, val: Option<i64>) -> String {
- let s = match t {
+pub fn int_ty_to_string(t: IntTy) -> &'static str {
+ match t {
TyIs => "isize",
TyI8 => "i8",
TyI16 => "i16",
TyI32 => "i32",
TyI64 => "i64"
- };
-
- match val {
- // cast to a u64 so we can correctly print INT64_MIN. All integral types
- // are parsed as u64, so we wouldn't want to print an extra negative
- // sign.
- Some(n) => format!("{}{}", n as u64, s),
- None => s.to_string()
}
}
+pub fn int_val_to_string(t: IntTy, val: i64) -> String {
+ // cast to a u64 so we can correctly print INT64_MIN. All integral types
+ // are parsed as u64, so we wouldn't want to print an extra negative
+ // sign.
+ format!("{}{}", val as u64, int_ty_to_string(t))
+}
+
pub fn int_ty_max(t: IntTy) -> u64 {
match t {
TyI8 => 0x80,
}
}
-/// Get a string representation of an unsigned int type, with its value.
-/// We want to avoid "42u" in favor of "42us". "42uint" is right out.
-pub fn uint_ty_to_string(t: UintTy, val: Option<u64>) -> String {
- let s = match t {
+pub fn uint_ty_to_string(t: UintTy) -> &'static str {
+ match t {
TyUs => "usize",
TyU8 => "u8",
TyU16 => "u16",
TyU32 => "u32",
TyU64 => "u64"
- };
-
- match val {
- Some(n) => format!("{}{}", n, s),
- None => s.to_string()
}
}
+pub fn uint_val_to_string(t: UintTy, val: u64) -> String {
+ format!("{}{}", val, uint_ty_to_string(t))
+}
+
pub fn uint_ty_max(t: UintTy) -> u64 {
match t {
TyU8 => 0xff,
}
}
-pub fn float_ty_to_string(t: FloatTy) -> String {
+pub fn float_ty_to_string(t: FloatTy) -> &'static str {
match t {
- TyF32 => "f32".to_string(),
- TyF64 => "f64".to_string(),
+ TyF32 => "f32",
+ TyF64 => "f64",
}
}
match t {
ast::SignedIntLit(st, ast::Plus) => {
word(self.writer(),
- &ast_util::int_ty_to_string(st, Some(i as i64)))
+ &ast_util::int_val_to_string(st, i as i64))
}
ast::SignedIntLit(st, ast::Minus) => {
- let istr = ast_util::int_ty_to_string(st, Some(-(i as i64)));
+ let istr = ast_util::int_val_to_string(st, -(i as i64));
word(self.writer(),
&format!("-{}", istr))
}
ast::UnsignedIntLit(ut) => {
- word(self.writer(), &ast_util::uint_ty_to_string(ut, Some(i)))
+ word(self.writer(), &ast_util::uint_val_to_string(ut, i))
}
ast::UnsuffixedIntLit(ast::Plus) => {
word(self.writer(), &format!("{}", i))
projects / rust.git / commitdiff