From: Josh Stone <jistone@redhat.com>
Date: Thu, 20 Apr 2017 18:25:05 +0000 (-0700)
Subject: Remove EnumSet
X-Git-Url: https://git.lizzy.rs/?a=commitdiff_plain;h=a76274e533969c8458c4471fbfc1b84ba44137e0;p=rust.git

Remove EnumSet

[unstable, deprecated since 1.16.0]
---

diff --git a/src/doc/unstable-book/src/SUMMARY.md b/src/doc/unstable-book/src/SUMMARY.md
index 3e041543977..b803b6556cf 100644
--- a/src/doc/unstable-book/src/SUMMARY.md
+++ b/src/doc/unstable-book/src/SUMMARY.md
@@ -130,7 +130,6 @@
     - [derive_clone_copy](library-features/derive-clone-copy.md)
     - [derive_eq](library-features/derive-eq.md)
     - [discriminant_value](library-features/discriminant-value.md)
-    - [enumset](library-features/enumset.md)
     - [error_type_id](library-features/error-type-id.md)
     - [exact_size_is_empty](library-features/exact-size-is-empty.md)
     - [fd](library-features/fd.md)
diff --git a/src/doc/unstable-book/src/library-features/enumset.md b/src/doc/unstable-book/src/library-features/enumset.md
deleted file mode 100644
index 24c8d8fa7db..00000000000
--- a/src/doc/unstable-book/src/library-features/enumset.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# `enumset`
-
-The tracking issue for this feature is: [#37966]
-
-[#37966]: https://github.com/rust-lang/rust/issues/37966
-
-------------------------
diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
deleted file mode 100644
index aaee567bf1d..00000000000
--- a/src/libcollections/enum_set.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A structure for holding a set of enum variants.
-//!
-//! This module defines a container which uses an efficient bit mask
-//! representation to hold C-like enum variants.
-
-#![unstable(feature = "enumset",
-            reason = "matches collection reform specification, \
-                      waiting for dust to settle",
-            issue = "37966")]
-#![rustc_deprecated(since = "1.16.0", reason = "long since replaced")]
-#![allow(deprecated)]
-
-use core::marker;
-use core::fmt;
-use core::iter::{FromIterator, FusedIterator};
-use core::ops::{Sub, BitOr, BitAnd, BitXor};
-
-// FIXME(contentions): implement union family of methods? (general design may be
-// wrong here)
-
-/// A specialized set implementation to use enum types.
-///
-/// It is a logic error for an item to be modified in such a way that the
-/// transformation of the item to or from a `usize`, as determined by the
-/// `CLike` trait, changes while the item is in the set. This is normally only
-/// possible through `Cell`, `RefCell`, global state, I/O, or unsafe code.
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct EnumSet<E> {
-    // We must maintain the invariant that no bits are set
-    // for which no variant exists
-    bits: usize,
-    marker: marker::PhantomData<E>,
-}
-
-impl<E> Copy for EnumSet<E> {}
-
-impl<E> Clone for EnumSet<E> {
-    fn clone(&self) -> EnumSet<E> {
-        *self
-    }
-}
-
-impl<E: CLike + fmt::Debug> fmt::Debug for EnumSet<E> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_set().entries(self).finish()
-    }
-}
-
-/// An interface for casting C-like enum to usize and back.
-/// A typically implementation is as below.
-///
-/// ```{rust,ignore}
-/// #[repr(usize)]
-/// enum Foo {
-///     A, B, C
-/// }
-///
-/// impl CLike for Foo {
-///     fn to_usize(&self) -> usize {
-///         *self as usize
-///     }
-///
-///     fn from_usize(v: usize) -> Foo {
-///         unsafe { mem::transmute(v) }
-///     }
-/// }
-/// ```
-pub trait CLike {
-    /// Converts a C-like enum to a `usize`.
-    fn to_usize(&self) -> usize;
-    /// Converts a `usize` to a C-like enum.
-    fn from_usize(usize) -> Self;
-}
-
-fn bit<E: CLike>(e: &E) -> usize {
-    use core::mem;
-    let value = e.to_usize();
-    let bits = mem::size_of::<usize>() * 8;
-    assert!(value < bits,
-            "EnumSet only supports up to {} variants.",
-            bits - 1);
-    1 << value
-}
-
-impl<E: CLike> EnumSet<E> {
-    /// Returns an empty `EnumSet`.
-    pub fn new() -> EnumSet<E> {
-        EnumSet {
-            bits: 0,
-            marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns the number of elements in the given `EnumSet`.
-    pub fn len(&self) -> usize {
-        self.bits.count_ones() as usize
-    }
-
-    /// Returns `true` if the `EnumSet` is empty.
-    pub fn is_empty(&self) -> bool {
-        self.bits == 0
-    }
-
-    pub fn clear(&mut self) {
-        self.bits = 0;
-    }
-
-    /// Returns `false` if the `EnumSet` contains any enum of the given `EnumSet`.
-    pub fn is_disjoint(&self, other: &EnumSet<E>) -> bool {
-        (self.bits & other.bits) == 0
-    }
-
-    /// Returns `true` if a given `EnumSet` is included in this `EnumSet`.
-    pub fn is_superset(&self, other: &EnumSet<E>) -> bool {
-        (self.bits & other.bits) == other.bits
-    }
-
-    /// Returns `true` if this `EnumSet` is included in the given `EnumSet`.
-    pub fn is_subset(&self, other: &EnumSet<E>) -> bool {
-        other.is_superset(self)
-    }
-
-    /// Returns the union of both `EnumSets`.
-    pub fn union(&self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {
-            bits: self.bits | e.bits,
-            marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns the intersection of both `EnumSets`.
-    pub fn intersection(&self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {
-            bits: self.bits & e.bits,
-            marker: marker::PhantomData,
-        }
-    }
-
-    /// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before
-    pub fn insert(&mut self, e: E) -> bool {
-        let result = !self.contains(&e);
-        self.bits |= bit(&e);
-        result
-    }
-
-    /// Removes an enum from the EnumSet
-    pub fn remove(&mut self, e: &E) -> bool {
-        let result = self.contains(e);
-        self.bits &= !bit(e);
-        result
-    }
-
-    /// Returns `true` if an `EnumSet` contains a given enum.
-    pub fn contains(&self, e: &E) -> bool {
-        (self.bits & bit(e)) != 0
-    }
-
-    /// Returns an iterator over an `EnumSet`.
-    pub fn iter(&self) -> Iter<E> {
-        Iter::new(self.bits)
-    }
-}
-
-impl<E: CLike> Sub for EnumSet<E> {
-    type Output = EnumSet<E>;
-
-    fn sub(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {
-            bits: self.bits & !e.bits,
-            marker: marker::PhantomData,
-        }
-    }
-}
-
-impl<E: CLike> BitOr for EnumSet<E> {
-    type Output = EnumSet<E>;
-
-    fn bitor(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {
-            bits: self.bits | e.bits,
-            marker: marker::PhantomData,
-        }
-    }
-}
-
-impl<E: CLike> BitAnd for EnumSet<E> {
-    type Output = EnumSet<E>;
-
-    fn bitand(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {
-            bits: self.bits & e.bits,
-            marker: marker::PhantomData,
-        }
-    }
-}
-
-impl<E: CLike> BitXor for EnumSet<E> {
-    type Output = EnumSet<E>;
-
-    fn bitxor(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {
-            bits: self.bits ^ e.bits,
-            marker: marker::PhantomData,
-        }
-    }
-}
-
-/// An iterator over an `EnumSet`
-pub struct Iter<E> {
-    index: usize,
-    bits: usize,
-    marker: marker::PhantomData<E>,
-}
-
-impl<E: fmt::Debug> fmt::Debug for Iter<E> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Iter")
-         .field(&self.index)
-         .field(&self.bits)
-         .finish()
-    }
-}
-
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-impl<E> Clone for Iter<E> {
-    fn clone(&self) -> Iter<E> {
-        Iter {
-            index: self.index,
-            bits: self.bits,
-            marker: marker::PhantomData,
-        }
-    }
-}
-
-impl<E: CLike> Iter<E> {
-    fn new(bits: usize) -> Iter<E> {
-        Iter {
-            index: 0,
-            bits: bits,
-            marker: marker::PhantomData,
-        }
-    }
-}
-
-impl<E: CLike> Iterator for Iter<E> {
-    type Item = E;
-
-    fn next(&mut self) -> Option<E> {
-        if self.bits == 0 {
-            return None;
-        }
-
-        while (self.bits & 1) == 0 {
-            self.index += 1;
-            self.bits >>= 1;
-        }
-        let elem = CLike::from_usize(self.index);
-        self.index += 1;
-        self.bits >>= 1;
-        Some(elem)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let exact = self.bits.count_ones() as usize;
-        (exact, Some(exact))
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<E: CLike> FusedIterator for Iter<E> {}
-
-impl<E: CLike> FromIterator<E> for EnumSet<E> {
-    fn from_iter<I: IntoIterator<Item = E>>(iter: I) -> EnumSet<E> {
-        let mut ret = EnumSet::new();
-        ret.extend(iter);
-        ret
-    }
-}
-
-impl<'a, E> IntoIterator for &'a EnumSet<E>
-    where E: CLike
-{
-    type Item = E;
-    type IntoIter = Iter<E>;
-
-    fn into_iter(self) -> Iter<E> {
-        self.iter()
-    }
-}
-
-impl<E: CLike> Extend<E> for EnumSet<E> {
-    fn extend<I: IntoIterator<Item = E>>(&mut self, iter: I) {
-        for element in iter {
-            self.insert(element);
-        }
-    }
-}
-
-impl<'a, E: 'a + CLike + Copy> Extend<&'a E> for EnumSet<E> {
-    fn extend<I: IntoIterator<Item = &'a E>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index 3bea61f6220..8d056afdb57 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -89,9 +89,6 @@
 #[doc(no_inline)]
 pub use linked_list::LinkedList;
 #[doc(no_inline)]
-#[allow(deprecated)]
-pub use enum_set::EnumSet;
-#[doc(no_inline)]
 pub use vec_deque::VecDeque;
 #[doc(no_inline)]
 pub use string::String;
@@ -107,7 +104,6 @@
 pub mod binary_heap;
 mod btree;
 pub mod borrow;
-pub mod enum_set;
 pub mod fmt;
 pub mod linked_list;
 pub mod range;
diff --git a/src/test/run-pass/sync-send-iterators-in-libcollections.rs b/src/test/run-pass/sync-send-iterators-in-libcollections.rs
index d046705c94b..ea154590dee 100644
--- a/src/test/run-pass/sync-send-iterators-in-libcollections.rs
+++ b/src/test/run-pass/sync-send-iterators-in-libcollections.rs
@@ -10,13 +10,12 @@
 
 #![allow(warnings)]
 #![feature(collections)]
-#![feature(drain, enumset, collections_bound, btree_range, vecmap)]
+#![feature(drain, collections_bound, btree_range, vecmap)]
 
 extern crate collections;
 
 use collections::BinaryHeap;
 use collections::{BTreeMap, BTreeSet};
-use collections::EnumSet;
 use collections::LinkedList;
 use collections::String;
 use collections::Vec;
@@ -25,7 +24,6 @@
 use std::collections::HashSet;
 
 use collections::Bound::Included;
-use collections::enum_set::CLike;
 use std::mem;
 
 fn is_sync<T>(_: T) where T: Sync {}
@@ -76,21 +74,6 @@ fn main() {
 
     all_sync_send!(LinkedList::<usize>::new(), iter, iter_mut, into_iter);
 
-    #[derive(Copy, Clone)]
-    #[repr(usize)]
-    #[allow(dead_code)]
-    enum Foo { A, B, C }
-    impl CLike for Foo {
-        fn to_usize(&self) -> usize {
-            *self as usize
-        }
-
-        fn from_usize(v: usize) -> Foo {
-            unsafe { mem::transmute(v) }
-        }
-    }
-    all_sync_send!(EnumSet::<Foo>::new(), iter);
-
     all_sync_send!(VecDeque::<usize>::new(), iter, iter_mut, into_iter);
     is_sync_send!(VecDeque::<usize>::new(), drain(..));