Skip to content

Commit 2aa6858

Browse files
borsbors
committed
Auto merge of #23601 - nikomatsakis:by-value-index, r=japaric
This is a [breaking-change]. When indexing a generic map (hashmap, etc) using the `[]` operator, it is now necessary to borrow explicitly, so change `map[key]` to `map[&key]` (consistent with the `get` routine). However, indexing of string-valued maps with constant strings can now be written `map["abc"]`. r? @japaric cc @aturon @gankro
2 parents b0aad7d + b760c56 commit 2aa6858

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

74 files changed

+983
-180
lines changed

‎src/libcollections/bit.rs

+12
Original file line numberDiff line numberDiff line change
@@ -169,6 +169,8 @@ pub struct BitVec {
169169
impl Index<usize> for BitVec {
170170
type Output = bool;
171171

172+
173+
#[cfg(stage0)]
172174
#[inline]
173175
fn index(&self, i: &usize) -> &bool {
174176
if self.get(*i).expect("index out of bounds") {
@@ -177,6 +179,16 @@ impl Index<usize> for BitVec {
177179
&FALSE
178180
}
179181
}
182+
183+
#[cfg(not(stage0))]
184+
#[inline]
185+
fn index(&self, i: usize) -> &bool {
186+
if self.get(i).expect("index out of bounds") {
187+
&TRUE
188+
} else {
189+
&FALSE
190+
}
191+
}
180192
}
181193

182194
/// Computes how many blocks are needed to store that many bits

‎src/libcollections/btree/map.rs

+30-2
Original file line numberDiff line numberDiff line change
@@ -264,7 +264,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
264264
/// Some(x) => *x = "b",
265265
/// None => (),
266266
/// }
267-
/// assert_eq!(map[1], "b");
267+
/// assert_eq!(map[&1], "b");
268268
/// ```
269269
// See `get` for implementation notes, this is basically a copy-paste with mut's added
270270
#[stable(feature = "rust1", since = "1.0.0")]
@@ -326,7 +326,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
326326
///
327327
/// map.insert(37, "b");
328328
/// assert_eq!(map.insert(37, "c"), Some("b"));
329-
/// assert_eq!(map[37], "c");
329+
/// assert_eq!(map[&37], "c");
330330
/// ```
331331
#[stable(feature = "rust1", since = "1.0.0")]
332332
pub fn insert(&mut self, mut key: K, mut value: V) -> Option<V> {
@@ -914,21 +914,49 @@ impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {
914914
}
915915
}
916916

917+
#[cfg(stage0)]
917918
#[stable(feature = "rust1", since = "1.0.0")]
918919
impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
919920
where K: Borrow<Q>, Q: Ord
920921
{
921922
type Output = V;
922923

924+
#[inline]
925+
fn index(&self, key: &Q) -> &V {
926+
self.get(key).expect("no entry found for key")
927+
}
928+
}
929+
930+
#[cfg(not(stage0))]
931+
#[stable(feature = "rust1", since = "1.0.0")]
932+
impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>
933+
where K: Borrow<Q>, Q: Ord
934+
{
935+
type Output = V;
936+
937+
#[inline]
923938
fn index(&self, key: &Q) -> &V {
924939
self.get(key).expect("no entry found for key")
925940
}
926941
}
927942

943+
#[cfg(stage0)]
928944
#[stable(feature = "rust1", since = "1.0.0")]
929945
impl<K: Ord, Q: ?Sized, V> IndexMut<Q> for BTreeMap<K, V>
930946
where K: Borrow<Q>, Q: Ord
931947
{
948+
#[inline]
949+
fn index_mut(&mut self, key: &Q) -> &mut V {
950+
self.get_mut(key).expect("no entry found for key")
951+
}
952+
}
953+
954+
#[cfg(not(stage0))]
955+
#[stable(feature = "rust1", since = "1.0.0")]
956+
impl<'a, K: Ord, Q: ?Sized, V> IndexMut<&'a Q> for BTreeMap<K, V>
957+
where K: Borrow<Q>, Q: Ord
958+
{
959+
#[inline]
932960
fn index_mut(&mut self, key: &Q) -> &mut V {
933961
self.get_mut(key).expect("no entry found for key")
934962
}

‎src/libcollections/btree/node.rs

+61
Original file line numberDiff line numberDiff line change
@@ -1522,6 +1522,7 @@ macro_rules! node_slice_impl {
15221522
}
15231523

15241524
/// Returns a sub-slice with elements starting with `min_key`.
1525+
#[cfg(stage0)]
15251526
pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
15261527
// _______________
15271528
// |_1_|_3_|_5_|_7_|
@@ -1549,7 +1550,37 @@ macro_rules! node_slice_impl {
15491550
}
15501551
}
15511552

1553+
/// Returns a sub-slice with elements starting with `min_key`.
1554+
#[cfg(not(stage0))]
1555+
pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
1556+
// _______________
1557+
// |_1_|_3_|_5_|_7_|
1558+
// | | | | |
1559+
// 0 0 1 1 2 2 3 3 4 index
1560+
// | | | | |
1561+
// \___|___|___|___/ slice_from(&0); pos = 0
1562+
// \___|___|___/ slice_from(&2); pos = 1
1563+
// |___|___|___/ slice_from(&3); pos = 1; result.head_is_edge = false
1564+
// \___|___/ slice_from(&4); pos = 2
1565+
// \___/ slice_from(&6); pos = 3
1566+
// \|/ slice_from(&999); pos = 4
1567+
let (pos, pos_is_kv) = self.search_linear(min_key);
1568+
$NodeSlice {
1569+
has_edges: self.has_edges,
1570+
edges: if !self.has_edges {
1571+
self.edges
1572+
} else {
1573+
self.edges.$index(pos ..)
1574+
},
1575+
keys: &self.keys[pos ..],
1576+
vals: self.vals.$index(pos ..),
1577+
head_is_edge: !pos_is_kv,
1578+
tail_is_edge: self.tail_is_edge,
1579+
}
1580+
}
1581+
15521582
/// Returns a sub-slice with elements up to and including `max_key`.
1583+
#[cfg(stage0)]
15531584
pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
15541585
// _______________
15551586
// |_1_|_3_|_5_|_7_|
@@ -1577,6 +1608,36 @@ macro_rules! node_slice_impl {
15771608
tail_is_edge: !pos_is_kv,
15781609
}
15791610
}
1611+
1612+
/// Returns a sub-slice with elements up to and including `max_key`.
1613+
#[cfg(not(stage0))]
1614+
pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
1615+
// _______________
1616+
// |_1_|_3_|_5_|_7_|
1617+
// | | | | |
1618+
// 0 0 1 1 2 2 3 3 4 index
1619+
// | | | | |
1620+
//\|/ | | | | slice_to(&0); pos = 0
1621+
// \___/ | | | slice_to(&2); pos = 1
1622+
// \___|___| | | slice_to(&3); pos = 1; result.tail_is_edge = false
1623+
// \___|___/ | | slice_to(&4); pos = 2
1624+
// \___|___|___/ | slice_to(&6); pos = 3
1625+
// \___|___|___|___/ slice_to(&999); pos = 4
1626+
let (pos, pos_is_kv) = self.search_linear(max_key);
1627+
let pos = pos + if pos_is_kv { 1 } else { 0 };
1628+
$NodeSlice {
1629+
has_edges: self.has_edges,
1630+
edges: if !self.has_edges {
1631+
self.edges
1632+
} else {
1633+
self.edges.$index(.. (pos + 1))
1634+
},
1635+
keys: &self.keys[..pos],
1636+
vals: self.vals.$index(.. pos),
1637+
head_is_edge: self.head_is_edge,
1638+
tail_is_edge: !pos_is_kv,
1639+
}
1640+
}
15801641
}
15811642

15821643
impl<'a, K: 'a, V: 'a> $NodeSlice<'a, K, V> {

‎src/libcollections/string.rs

+32
Original file line numberDiff line numberDiff line change
@@ -870,34 +870,66 @@ impl<'a> Add<&'a str> for String {
870870
#[stable(feature = "rust1", since = "1.0.0")]
871871
impl ops::Index<ops::Range<usize>> for String {
872872
type Output = str;
873+
874+
#[cfg(stage0)]
873875
#[inline]
874876
fn index(&self, index: &ops::Range<usize>) -> &str {
875877
&self[..][*index]
876878
}
879+
880+
#[cfg(not(stage0))]
881+
#[inline]
882+
fn index(&self, index: ops::Range<usize>) -> &str {
883+
&self[..][index]
884+
}
877885
}
878886
#[stable(feature = "rust1", since = "1.0.0")]
879887
impl ops::Index<ops::RangeTo<usize>> for String {
880888
type Output = str;
889+
890+
#[cfg(stage0)]
881891
#[inline]
882892
fn index(&self, index: &ops::RangeTo<usize>) -> &str {
883893
&self[..][*index]
884894
}
895+
896+
#[cfg(not(stage0))]
897+
#[inline]
898+
fn index(&self, index: ops::RangeTo<usize>) -> &str {
899+
&self[..][index]
900+
}
885901
}
886902
#[stable(feature = "rust1", since = "1.0.0")]
887903
impl ops::Index<ops::RangeFrom<usize>> for String {
888904
type Output = str;
905+
906+
#[cfg(stage0)]
889907
#[inline]
890908
fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
891909
&self[..][*index]
892910
}
911+
912+
#[cfg(not(stage0))]
913+
#[inline]
914+
fn index(&self, index: ops::RangeFrom<usize>) -> &str {
915+
&self[..][index]
916+
}
893917
}
894918
#[stable(feature = "rust1", since = "1.0.0")]
895919
impl ops::Index<ops::RangeFull> for String {
896920
type Output = str;
921+
922+
#[cfg(stage0)]
897923
#[inline]
898924
fn index(&self, _index: &ops::RangeFull) -> &str {
899925
unsafe { mem::transmute(&*self.vec) }
900926
}
927+
928+
#[cfg(not(stage0))]
929+
#[inline]
930+
fn index(&self, _index: ops::RangeFull) -> &str {
931+
unsafe { mem::transmute(&*self.vec) }
932+
}
901933
}
902934

903935
#[stable(feature = "rust1", since = "1.0.0")]

0 commit comments

Comments
 (0)