Replace syntax's SmallVector with AccumulateVec

mk/crates.mk

@@ -100,7 +100,7 @@ DEPS_serialize := std log
 DEPS_term := std
 DEPS_test := std getopts term native:rust_test_helpers
 
-DEPS_syntax := std term serialize log arena libc rustc_bitflags rustc_unicode rustc_errors syntax_pos
+DEPS_syntax := std term serialize log arena libc rustc_bitflags rustc_unicode rustc_errors syntax_pos rustc_data_structures
 DEPS_syntax_ext := syntax syntax_pos rustc_errors fmt_macros proc_macro
 DEPS_syntax_pos := serialize
 DEPS_proc_macro_tokens := syntax syntax_pos log

src/librustc/infer/combine.rs

@@ -184,7 +184,7 @@ impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {
  {
  // We use SmallVector here instead of Vec because this code is hot and
  // it's rare that the stack length exceeds 1.
- let mut stack = SmallVector::zero();
+ let mut stack = SmallVector::new();
  stack.push((a_ty, dir, b_vid));
  loop {
  // For each turn of the loop, we extract a tuple

src/librustc_data_structures/accumulate_vec.rs

@@ -11,22 +11,68 @@
 //! A vector type intended to be used for collecting from iterators onto the stack.
 //!
 //! Space for up to N elements is provided on the stack. If more elements are collected, Vec is
-//! used to store the values on the heap. This type does not support re-allocating onto the heap,
-//! and there is no way to push more elements onto the existing storage.
+//! used to store the values on the heap.
 //!
 //! The N above is determined by Array's implementor, by way of an associatated constant.
 
-use std::ops::Deref;
-use std::iter::{IntoIterator, FromIterator};
+use std::ops::{Deref, DerefMut};
+use std::iter::{self, IntoIterator, FromIterator};
+use std::slice;
+use std::vec;
 
-use array_vec::{Array, ArrayVec};
+use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
 
-#[derive(Debug)]
+use array_vec::{self, Array, ArrayVec};
+
+#[derive(PartialEq, Eq, Hash, Debug)]
 pub enum AccumulateVec<A: Array> {
  Array(ArrayVec<A>),
  Heap(Vec<A::Element>)
 }
 
+impl<A> Clone for AccumulateVec<A>
+ where A: Array,
+ A::Element: Clone {
+ fn clone(&self) -> Self {
+ match *self {
+ AccumulateVec::Array(ref arr) => AccumulateVec::Array(arr.clone()),
+ AccumulateVec::Heap(ref vec) => AccumulateVec::Heap(vec.clone()),
+ }
+ }
+}
+
+impl<A: Array> AccumulateVec<A> {
+ pub fn new() -> AccumulateVec<A> {
+ AccumulateVec::Array(ArrayVec::new())
+ }
+
+ pub fn one(el: A::Element) -> Self {
+ iter::once(el).collect()
+ }
+
+ pub fn many<I: IntoIterator<Item=A::Element>>(iter: I) -> Self {
+ iter.into_iter().collect()
+ }
+
+ pub fn len(&self) -> usize {
+ match *self {
+ AccumulateVec::Array(ref arr) => arr.len(),
+ AccumulateVec::Heap(ref vec) => vec.len(),
+ }
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ pub fn pop(&mut self) -> Option<A::Element> {
+ match *self {
+ AccumulateVec::Array(ref mut arr) => arr.pop(),
+ AccumulateVec::Heap(ref mut vec) => vec.pop(),
+ }
+ }
+}
+
 impl<A: Array> Deref for AccumulateVec<A> {
  type Target = [A::Element];
  fn deref(&self) -> &Self::Target {
@@ -37,6 +83,15 @@ impl<A: Array> Deref for AccumulateVec<A> {
  }
 }
 
+impl<A: Array> DerefMut for AccumulateVec<A> {
+ fn deref_mut(&mut self) -> &mut [A::Element] {
+ match *self {
+ AccumulateVec::Array(ref mut v) => &mut v[..],
+ AccumulateVec::Heap(ref mut v) => &mut v[..],
+ }
+ }
+}
+
 impl<A: Array> FromIterator<A::Element> for AccumulateVec<A> {
  fn from_iter<I>(iter: I) -> AccumulateVec<A> where I: IntoIterator<Item=A::Element> {
  let iter = iter.into_iter();
@@ -50,3 +105,94 @@ impl<A: Array> FromIterator<A::Element> for AccumulateVec<A> {
  }
 }
 
+pub struct IntoIter<A: Array> {
+ repr: IntoIterRepr<A>,
+}
+
+enum IntoIterRepr<A: Array> {
+ Array(array_vec::Iter<A>),
+ Heap(vec::IntoIter<A::Element>),
+}
+
+impl<A: Array> Iterator for IntoIter<A> {
+ type Item = A::Element;
+
+ fn next(&mut self) -> Option<A::Element> {
+ match self.repr {
+ IntoIterRepr::Array(ref mut arr) => arr.next(),
+ IntoIterRepr::Heap(ref mut iter) => iter.next(),
+ }
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ match self.repr {
+ IntoIterRepr::Array(ref iter) => iter.size_hint(),
+ IntoIterRepr::Heap(ref iter) => iter.size_hint(),
+ }
+ }
+}
+
+impl<A: Array> IntoIterator for AccumulateVec<A> {
+ type Item = A::Element;
+ type IntoIter = IntoIter<A>;
+ fn into_iter(self) -> Self::IntoIter {
+ IntoIter {
+ repr: match self {
+ AccumulateVec::Array(arr) => IntoIterRepr::Array(arr.into_iter()),
+ AccumulateVec::Heap(vec) => IntoIterRepr::Heap(vec.into_iter()),
+ }
+ }
+ }
+}
+
+impl<'a, A: Array> IntoIterator for &'a AccumulateVec<A> {
+ type Item = &'a A::Element;
+ type IntoIter = slice::Iter<'a, A::Element>;
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
+impl<'a, A: Array> IntoIterator for &'a mut AccumulateVec<A> {
+ type Item = &'a mut A::Element;
+ type IntoIter = slice::IterMut<'a, A::Element>;
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter_mut()
+ }
+}
+
+impl<A: Array> From<Vec<A::Element>> for AccumulateVec<A> {
+ fn from(v: Vec<A::Element>) -> AccumulateVec<A> {
+ AccumulateVec::many(v)
+ }
+}
+
+impl<A: Array> Default for AccumulateVec<A> {
+ fn default() -> AccumulateVec<A> {
+ AccumulateVec::new()
+ }
+}
+
+impl<A> Encodable for AccumulateVec<A>
+ where A: Array,
+ A::Element: Encodable {
+ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+ s.emit_seq(self.len(), |s| {
+ for (i, e) in self.iter().enumerate() {
+ try!(s.emit_seq_elt(i, |s| e.encode(s)));
+ }
+ Ok(())
+ })
+ }
+}
+
+impl<A> Decodable for AccumulateVec<A>
+ where A: Array,
+ A::Element: Decodable {
+ fn decode<D: Decoder>(d: &mut D) -> Result<AccumulateVec<A>, D::Error> {
+ d.read_seq(|d, len| {
+ Ok(try!((0..len).map(|i| d.read_seq_elt(i, |d| Decodable::decode(d))).collect()))
+ })
+ }
+}
+