Support dereference operator overloading

This adds in support for deref lang-item operator overloads. Deref operator
overloading is an interesting case of the libcore interaction with the
compiler. The deref operator lang item is:

```rust
pub trait Deref {
    type Target;

    fn deref(&self) -> &Self::Target;
}
```

It has two default impl's one for '&T' and '&mut T' to apply genericly.
The reason it is interesting is from the prototype the deref lang item
always returns &Self::Target in all cases regardless of mutability, the
lang item here is designed to wrap up any dereference such that when
applied it guarentees the type system you will get back an immutable
reference to something. The reason for doing this is more clear when
thinking about autoderef and method-resolution and how you apply
dereference operations to custom types and a test case is included for
that.

The autoderef mechanism will now need to be updated to support drefs fully.

Fixes #809

1 files changed, 8 insertions, 0 deletions

diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index 4f8c389..77a4caf 100644
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -51,6 +51,8 @@ public:
     DIV_ASSIGN,
     REM_ASSIGN,
 
+    DEREF,
+
     UNKNOWN,
   };
 
@@ -104,6 +106,10 @@ public:
       {
 	return ItemType::REM_ASSIGN;
       }
+    else if (item.compare ("deref") == 0)
+      {
+	return ItemType::DEREF;
+      }
 
     return ItemType::UNKNOWN;
   }
@@ -136,6 +142,8 @@ public:
 	return "div_assign";
       case REM_ASSIGN:
 	return "rem_assign";
+      case DEREF:
+	return "deref";
 
       case UNKNOWN:
 	break;