Refer to types using the local identifier

On type errors, refer to types using the locally available name when
they have been imported into scope instead of the fully qualified path.

```
error[E0308]: mismatched types
 --> file.rs:7:24
  |
7 |     let y: Option<X> = Ok(());
  |                        ^^^^^^ expected enum `std::option::Option`, found enum `std::result::Result`
  |
  = note: expected type `Option<X>`
             found type `Result<(), _>`
  = help: here are some functions which might fulfill your needs:
          - .err()
          - .unwrap_err()
```

Author: estebank

src/librustc/infer/error_reporting/mod.rs

@@ -76,6 +76,10 @@ impl<'tcx> ConstVal<'tcx> {
             _ => None
         }
     }
+
+    pub fn to_usize(&self) -> Option<usize> {
+        self.to_const_int().and_then(|i| i.to_usize())
+    }
 }
 
 #[derive(Clone, Debug)]

src/librustc/middle/const_val.rs

@@ -1179,6 +1179,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.all_crate_nums(LOCAL_CRATE)
     }
 
+    pub fn cstore(&self) -> &CrateStore {
+        self.cstore
+    }
+
     pub fn def_key(self, id: DefId) -> hir_map::DefKey {
         if id.is_local() {
             self.hir.def_key(id)

src/librustc/ty/context.rs

@@ -1469,4 +1469,10 @@ pub struct Const<'tcx> {
     pub val: ConstVal<'tcx>,
 }
 
+impl<'tcx> Const<'tcx> {
+    pub fn usize_val(&self) -> usize {
+        self.val.to_usize().unwrap_or(0)
+    }
+}
+
 impl<'tcx> serialize::UseSpecializedDecodable for &'tcx Const<'tcx> {}

src/librustc/ty/sty.rs

@@ -188,6 +188,15 @@ impl ConstInt {
         })
     }
 
+    /// Converts the value to a `usize` if it's in the range 0...std::usize::MAX
+    pub fn to_usize(&self) -> Option<usize> {
+        self.to_u128().and_then(|v| if v <= usize::max_value() as u128 {
+            Some(v as usize)
+        } else {
+            None
+        })
+    }
+
     /// Converts the value to a `u128` if it's in the range 0...std::u128::MAX
     pub fn to_u128(&self) -> Option<u128> {
         match *self {

src/librustc_const_math/int.rs

@@ -10,7 +10,7 @@
 
 static i: String = 10;
 //~^ ERROR mismatched types
-//~| expected type `std::string::String`
+//~| expected type `String`
 //~| found type `{integer}`
 //~| expected struct `std::string::String`, found integral variable
 fn main() { println!("{}", i); }

src/test/compile-fail/bad-const-type.rs

@@ -19,5 +19,5 @@ pub fn main() {
     let x: Box<Trait> = Box::new(Foo);
     let _y: &Trait = x; //~ ERROR E0308
                         //~| expected type `&Trait`
-                        //~| found type `std::boxed::Box<Trait>`
+                        //~| found type `Box<Trait>`
 }

src/test/compile-fail/cross-borrow-trait.rs

@@ -51,5 +51,5 @@ fn main() {
     let box box x = box 1isize as Box<T>;
     //~^ ERROR mismatched types
     //~| expected type `T`
-    //~| found type `std::boxed::Box<_>`
+    //~| found type `Box<_>`
 }

src/test/compile-fail/destructure-trait-ref.rs

@@ -16,15 +16,15 @@ fn main() {
     let _: () = (box |_: isize| {}) as Box<FnOnce(isize)>;
     //~^ ERROR mismatched types
     //~| expected type `()`
-    //~| found type `std::boxed::Box<std::ops::FnOnce(isize)>`
+    //~| found type `Box<std::ops::FnOnce(isize)>`
     let _: () = (box |_: isize, isize| {}) as Box<Fn(isize, isize)>;
     //~^ ERROR mismatched types
     //~| expected type `()`
-    //~| found type `std::boxed::Box<std::ops::Fn(isize, isize)>`
+    //~| found type `Box<std::ops::Fn(isize, isize)>`
     let _: () = (box || -> isize { unimplemented!() }) as Box<FnMut() -> isize>;
     //~^ ERROR mismatched types
     //~| expected type `()`
-    //~| found type `std::boxed::Box<std::ops::FnMut() -> isize>`
+    //~| found type `Box<std::ops::FnMut() -> isize>`
 
     needs_fn(1);
     //~^ ERROR : std::ops::Fn<(isize,)>`

src/test/compile-fail/fn-trait-formatting.rs

@@ -14,7 +14,7 @@ fn main() {
     let x: Option<usize>;
     x = 5;
     //~^ ERROR mismatched types
-    //~| expected type `std::option::Option<usize>`
+    //~| expected type `Option<usize>`
     //~| found type `{integer}`
     //~| expected enum `std::option::Option`, found integral variable
 }