Indexing Autoref + Borrow = :(

[Gankra]

use std::collections::HashMap;
fn main(){
    let mut map = HashMap::new();
    map.insert("foo".to_string(), "bar".to_string());

    // Oh hey I can use borrow to do lookup with a string literal!
    println!("{}", map["foo"]);
}

// <anon>:5:20: 5:30 error: the trait `collections::borrow::Borrow<&str>` 
// is not implemented for the type `collections::string::String` [E0277]
// <anon>:5     println!("{}", map["foo"]);
//                             ^~~~~~~~~~

:(

use std::collections::HashMap;
fn main(){
    let mut map = HashMap::new();
    map.insert("foo".to_string(), "bar".to_string());

    // Ok, maybe I can deref to cancel out the autoref?
    println!("{}", map[*"foo"]);
}

// error: internal compiler error: trying to take the 
// sizing type of str, an unsized type

:((((((

These two conveniences are basically cancelling each-other out for the super-natural case of doing lookup with a string literal. Is there something that can be done about this?

[Gankra]

CC @aturon

[eddyb]

The ICE is definitely a bug, which I may have introduced: *"foo" is treated as a constant expression, but constant expressions have no notion of lvalues, so &*expr works for constant expressions iff *expr is sized (and can be treated as an rvalue).
The following works, btw:

use std::collections::HashMap;
fn main(){
    let mut map = HashMap::new();
    map.insert("foo".to_string(), "bar".to_string());

    // Ok, maybe I can deref to cancel out the autoref?
    let key = "foo";
    println!("{}", map[*key]);
}

[Gankra]

Yeah, that was my work-around, but I think we can all agree that that's pretty awful.

[aturon]

triage: I-nominated

[aturon]

(Hm, triage bot seems to be busted.)

[aturon]

Nominating: we need to at least get the * version working before beta. It would be nice if the more natural version worked as well, but that may require more substantial changes to indexing.

[pnkfelix]

1.0 beta for addressing the ICE.

its not clear whether we have time for a breaking-change to try to fix the trait.

(and its also not clear whether a breaking-change is the only option for fixing the trait; e.g. there may be some method via deref-coercion or other magic.)

[aturon]

Update: @nikomatsakis is looking into changing the traits to work by-value, as the RFC originally intended.

[alexcrichton]

Now that index operators take arguments by value I believe this bug is actually fixed. Yay!

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a".to_string(), 2);
    println!("{}", m["a"]);
}