"rustc_typeck 0.0.0",
"scoped-tls 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"serialize 0.0.0",
+ "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"syntax 0.0.0",
"syntax_ext 0.0.0",
"syntax_pos 0.0.0",
use middle::cstore::CrateStore;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::indexed_vec::IndexVec;
-use rustc_data_structures::small_vec::OneVector;
use rustc_data_structures::thin_vec::ThinVec;
use session::Session;
use util::common::FN_OUTPUT_NAME;
use std::fmt::Debug;
use std::iter;
use std::mem;
+use smallvec::SmallVec;
use syntax::attr;
use syntax::ast;
use syntax::ast::*;
PassThrough,
}
-struct ImplTraitTypeIdVisitor<'a> { ids: &'a mut OneVector<hir::ItemId> }
+struct ImplTraitTypeIdVisitor<'a> { ids: &'a mut SmallVec<[hir::ItemId; 1]> }
impl<'a, 'b> Visitor<'a> for ImplTraitTypeIdVisitor<'b> {
fn visit_ty(&mut self, ty: &'a Ty) {
)
}
- fn lower_local(&mut self, l: &Local) -> (P<hir::Local>, OneVector<hir::ItemId>) {
+ fn lower_local(&mut self, l: &Local) -> (P<hir::Local>, SmallVec<[hir::ItemId; 1]>) {
let LoweredNodeId { node_id, hir_id } = self.lower_node_id(l.id);
- let mut ids = OneVector::<hir::ItemId>::new();
+ let mut ids = SmallVec::<[hir::ItemId; 1]>::new();
if self.sess.features_untracked().impl_trait_in_bindings {
if let Some(ref ty) = l.ty {
let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
&mut self,
decl: &FnDecl,
header: &FnHeader,
- ids: &mut OneVector<hir::ItemId>,
+ ids: &mut SmallVec<[hir::ItemId; 1]>,
) {
if let Some(id) = header.asyncness.opt_return_id() {
ids.push(hir::ItemId { id });
}
}
- fn lower_item_id(&mut self, i: &Item) -> OneVector<hir::ItemId> {
+ fn lower_item_id(&mut self, i: &Item) -> SmallVec<[hir::ItemId; 1]> {
match i.node {
ItemKind::Use(ref use_tree) => {
let mut vec = smallvec![hir::ItemId { id: i.id }];
self.lower_item_id_use_tree(use_tree, i.id, &mut vec);
vec
}
- ItemKind::MacroDef(..) => OneVector::new(),
+ ItemKind::MacroDef(..) => SmallVec::new(),
ItemKind::Fn(ref decl, ref header, ..) => {
let mut ids = smallvec![hir::ItemId { id: i.id }];
self.lower_fn_impl_trait_ids(decl, header, &mut ids);
fn lower_item_id_use_tree(&mut self,
tree: &UseTree,
base_id: NodeId,
- vec: &mut OneVector<hir::ItemId>)
+ vec: &mut SmallVec<[hir::ItemId; 1]>)
{
match tree.kind {
UseTreeKind::Nested(ref nested_vec) => for &(ref nested, id) in nested_vec {
}
}
- fn lower_stmt(&mut self, s: &Stmt) -> OneVector<hir::Stmt> {
+ fn lower_stmt(&mut self, s: &Stmt) -> SmallVec<[hir::Stmt; 1]> {
smallvec![match s.node {
StmtKind::Local(ref l) => {
let (l, item_ids) = self.lower_local(l);
- let mut ids: OneVector<hir::Stmt> = item_ids
+ let mut ids: SmallVec<[hir::Stmt; 1]> = item_ids
.into_iter()
.map(|item_id| Spanned {
node: hir::StmtKind::Decl(
// except according to those terms.
use rustc::middle::allocator::AllocatorKind;
-use rustc_data_structures::small_vec::OneVector;
use rustc_errors;
+use smallvec::SmallVec;
use syntax::{
ast::{
self, Arg, Attribute, Crate, Expr, FnHeader, Generics, Ident, Item, ItemKind,
}
impl<'a> Folder for ExpandAllocatorDirectives<'a> {
- fn fold_item(&mut self, item: P<Item>) -> OneVector<P<Item>> {
+ fn fold_item(&mut self, item: P<Item>) -> SmallVec<[P<Item>; 1]> {
debug!("in submodule {}", self.in_submod);
let name = if attr::contains_name(&item.attrs, "global_allocator") {
let module = f.cx.monotonic_expander().fold_item(module).pop().unwrap();
// Return the item and new submodule
- let mut ret = OneVector::with_capacity(2);
- ret.push(item);
- ret.push(module);
-
- return ret;
+ smallvec![item, module]
}
// If we enter a submodule, take note.
extern crate rustc_rayon_core as rayon_core;
extern crate rustc_hash;
extern crate serialize;
-#[cfg_attr(test, macro_use)]
extern crate smallvec;
// See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
pub mod ptr_key;
pub mod sip128;
pub mod small_c_str;
-pub mod small_vec;
pub mod snapshot_map;
pub use ena::snapshot_vec;
pub mod sorted_map;
+++ /dev/null
-// Copyright 2016 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 vector type intended to be used for small vectors.
-//!
-//! 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.
-//!
-//! The N above is determined by Array's implementor, by way of an associated constant.
-
-use smallvec::{Array, SmallVec};
-
-pub type OneVector<T> = SmallVec<[T; 1]>;
-
-pub trait ExpectOne<A: Array> {
- fn expect_one(self, err: &'static str) -> A::Item;
-}
-
-impl<A: Array> ExpectOne<A> for SmallVec<A> {
- fn expect_one(self, err: &'static str) -> A::Item {
- assert!(self.len() == 1, err);
- self.into_iter().next().unwrap()
- }
-}
-
-#[cfg(test)]
-mod tests {
- extern crate test;
- use super::*;
-
- #[test]
- #[should_panic]
- fn test_expect_one_zero() {
- let _: isize = OneVector::new().expect_one("");
- }
-
- #[test]
- #[should_panic]
- fn test_expect_one_many() {
- OneVector::from_vec(vec![1, 2]).expect_one("");
- }
-
- #[test]
- fn test_expect_one_one() {
- assert_eq!(1, (smallvec![1] as OneVector<_>).expect_one(""));
- assert_eq!(1, OneVector::from_vec(vec![1]).expect_one(""));
- }
-}
rustc_typeck = { path = "../librustc_typeck" }
serialize = { path = "../libserialize" }
syntax = { path = "../libsyntax" }
+smallvec = { version = "0.6.5", features = ["union"] }
syntax_ext = { path = "../libsyntax_ext" }
syntax_pos = { path = "../libsyntax_pos" }
extern crate rustc_typeck;
extern crate scoped_tls;
extern crate serialize;
+extern crate smallvec;
#[macro_use]
extern crate log;
extern crate syntax;
use rustc::session::config::{Input, OutputFilenames};
use rustc_borrowck as borrowck;
use rustc_borrowck::graphviz as borrowck_dot;
-use rustc_data_structures::small_vec::OneVector;
use rustc_data_structures::thin_vec::ThinVec;
use rustc_metadata::cstore::CStore;
use syntax_pos::{self, FileName};
use graphviz as dot;
+use smallvec::SmallVec;
use std::cell::Cell;
use std::fs::File;
self.run(is_const, |s| fold::noop_fold_item_kind(i, s))
}
- fn fold_trait_item(&mut self, i: ast::TraitItem) -> OneVector<ast::TraitItem> {
+ fn fold_trait_item(&mut self, i: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
let is_const = match i.node {
ast::TraitItemKind::Const(..) => true,
ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
self.run(is_const, |s| fold::noop_fold_trait_item(i, s))
}
- fn fold_impl_item(&mut self, i: ast::ImplItem) -> OneVector<ast::ImplItem> {
+ fn fold_impl_item(&mut self, i: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
let is_const = match i.node {
ast::ImplItemKind::Const(..) => true,
ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
use std::cell::Cell;
use std::mem;
use rustc_data_structures::sync::Lrc;
-use rustc_data_structures::small_vec::ExpectOne;
#[derive(Clone, Copy)]
crate struct FromPrelude(bool);
}
}
- EliminateCrateVar(self, item.span).fold_item(item).expect_one("")
+ let ret = EliminateCrateVar(self, item.span).fold_item(item);
+ assert!(ret.len() == 1);
+ ret.into_iter().next().unwrap()
}
fn is_whitelisted_legacy_custom_derive(&self, name: Name) -> bool {
use source_map::Spanned;
use edition::Edition;
use parse::{token, ParseSess};
-use OneVector;
+use smallvec::SmallVec;
use errors::Applicability;
use ptr::P;
Some(P(fold::noop_fold_expr(expr, self)))
}
- fn fold_stmt(&mut self, stmt: ast::Stmt) -> OneVector<ast::Stmt> {
+ fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
match self.configure_stmt(stmt) {
Some(stmt) => fold::noop_fold_stmt(stmt, self),
- None => return OneVector::new(),
+ None => return SmallVec::new(),
}
}
- fn fold_item(&mut self, item: P<ast::Item>) -> OneVector<P<ast::Item>> {
+ fn fold_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
fold::noop_fold_item(configure!(self, item), self)
}
- fn fold_impl_item(&mut self, item: ast::ImplItem) -> OneVector<ast::ImplItem> {
+ fn fold_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]>
+ {
fold::noop_fold_impl_item(configure!(self, item), self)
}
- fn fold_trait_item(&mut self, item: ast::TraitItem) -> OneVector<ast::TraitItem> {
+ fn fold_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
fold::noop_fold_trait_item(configure!(self, item), self)
}
use ext::build::AstBuilder;
use parse::token;
use ptr::P;
-use OneVector;
use symbol::{keywords, Symbol};
use tokenstream::{TokenTree};
let sym = Ident::with_empty_ctxt(Symbol::gensym(&format!(
"__register_diagnostic_{}", code
)));
- MacEager::items(OneVector::from_vec(vec![
+ MacEager::items(smallvec![
ecx.item_mod(
span,
span,
Vec::new(),
Vec::new()
)
- ]))
+ ])
}
pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
),
);
- MacEager::items(OneVector::from_vec(vec![
+ MacEager::items(smallvec![
P(ast::Item {
ident: *name,
attrs: Vec::new(),
span,
tokens: None,
})
- ]))
+ ])
}
use parse::{self, parser, DirectoryOwnership};
use parse::token;
use ptr::P;
-use OneVector;
+use smallvec::SmallVec;
use symbol::{keywords, Ident, Symbol};
use ThinVec;
None
}
/// Create zero or more items.
- fn make_items(self: Box<Self>) -> Option<OneVector<P<ast::Item>>> {
+ fn make_items(self: Box<Self>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
None
}
/// Create zero or more impl items.
- fn make_impl_items(self: Box<Self>) -> Option<OneVector<ast::ImplItem>> {
+ fn make_impl_items(self: Box<Self>) -> Option<SmallVec<[ast::ImplItem; 1]>> {
None
}
/// Create zero or more trait items.
- fn make_trait_items(self: Box<Self>) -> Option<OneVector<ast::TraitItem>> {
+ fn make_trait_items(self: Box<Self>) -> Option<SmallVec<[ast::TraitItem; 1]>> {
None
}
/// Create zero or more items in an `extern {}` block
- fn make_foreign_items(self: Box<Self>) -> Option<OneVector<ast::ForeignItem>> { None }
+ fn make_foreign_items(self: Box<Self>) -> Option<SmallVec<[ast::ForeignItem; 1]>> { None }
/// Create a pattern.
fn make_pat(self: Box<Self>) -> Option<P<ast::Pat>> {
///
/// By default this attempts to create an expression statement,
/// returning None if that fails.
- fn make_stmts(self: Box<Self>) -> Option<OneVector<ast::Stmt>> {
+ fn make_stmts(self: Box<Self>) -> Option<SmallVec<[ast::Stmt; 1]>> {
make_stmts_default!(self)
}
make_MacEager! {
expr: P<ast::Expr>,
pat: P<ast::Pat>,
- items: OneVector<P<ast::Item>>,
- impl_items: OneVector<ast::ImplItem>,
- trait_items: OneVector<ast::TraitItem>,
- foreign_items: OneVector<ast::ForeignItem>,
- stmts: OneVector<ast::Stmt>,
+ items: SmallVec<[P<ast::Item>; 1]>,
+ impl_items: SmallVec<[ast::ImplItem; 1]>,
+ trait_items: SmallVec<[ast::TraitItem; 1]>,
+ foreign_items: SmallVec<[ast::ForeignItem; 1]>,
+ stmts: SmallVec<[ast::Stmt; 1]>,
ty: P<ast::Ty>,
}
self.expr
}
- fn make_items(self: Box<Self>) -> Option<OneVector<P<ast::Item>>> {
+ fn make_items(self: Box<Self>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
self.items
}
- fn make_impl_items(self: Box<Self>) -> Option<OneVector<ast::ImplItem>> {
+ fn make_impl_items(self: Box<Self>) -> Option<SmallVec<[ast::ImplItem; 1]>> {
self.impl_items
}
- fn make_trait_items(self: Box<Self>) -> Option<OneVector<ast::TraitItem>> {
+ fn make_trait_items(self: Box<Self>) -> Option<SmallVec<[ast::TraitItem; 1]>> {
self.trait_items
}
- fn make_foreign_items(self: Box<Self>) -> Option<OneVector<ast::ForeignItem>> {
+ fn make_foreign_items(self: Box<Self>) -> Option<SmallVec<[ast::ForeignItem; 1]>> {
self.foreign_items
}
- fn make_stmts(self: Box<Self>) -> Option<OneVector<ast::Stmt>> {
+ fn make_stmts(self: Box<Self>) -> Option<SmallVec<[ast::Stmt; 1]>> {
match self.stmts.as_ref().map_or(0, |s| s.len()) {
0 => make_stmts_default!(self),
_ => self.stmts,
Some(P(DummyResult::raw_pat(self.span)))
}
- fn make_items(self: Box<DummyResult>) -> Option<OneVector<P<ast::Item>>> {
+ fn make_items(self: Box<DummyResult>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
// this code needs a comment... why not always just return the Some() ?
if self.expr_only {
None
} else {
- Some(OneVector::new())
+ Some(SmallVec::new())
}
}
- fn make_impl_items(self: Box<DummyResult>) -> Option<OneVector<ast::ImplItem>> {
+ fn make_impl_items(self: Box<DummyResult>) -> Option<SmallVec<[ast::ImplItem; 1]>> {
if self.expr_only {
None
} else {
- Some(OneVector::new())
+ Some(SmallVec::new())
}
}
- fn make_trait_items(self: Box<DummyResult>) -> Option<OneVector<ast::TraitItem>> {
+ fn make_trait_items(self: Box<DummyResult>) -> Option<SmallVec<[ast::TraitItem; 1]>> {
if self.expr_only {
None
} else {
- Some(OneVector::new())
+ Some(SmallVec::new())
}
}
- fn make_foreign_items(self: Box<Self>) -> Option<OneVector<ast::ForeignItem>> {
+ fn make_foreign_items(self: Box<Self>) -> Option<SmallVec<[ast::ForeignItem; 1]>> {
if self.expr_only {
None
} else {
- Some(OneVector::new())
+ Some(SmallVec::new())
}
}
- fn make_stmts(self: Box<DummyResult>) -> Option<OneVector<ast::Stmt>> {
+ fn make_stmts(self: Box<DummyResult>) -> Option<SmallVec<[ast::Stmt; 1]>> {
Some(smallvec![ast::Stmt {
id: ast::DUMMY_NODE_ID,
node: ast::StmtKind::Expr(DummyResult::raw_expr(self.span)),
use parse::token::{self, Token};
use parse::parser::Parser;
use ptr::P;
-use OneVector;
+use smallvec::SmallVec;
use symbol::Symbol;
use symbol::keywords;
use syntax_pos::{Span, DUMMY_SP, FileName};
Expr(P<ast::Expr>) { "expression"; one fn fold_expr; fn visit_expr; fn make_expr; }
Pat(P<ast::Pat>) { "pattern"; one fn fold_pat; fn visit_pat; fn make_pat; }
Ty(P<ast::Ty>) { "type"; one fn fold_ty; fn visit_ty; fn make_ty; }
- Stmts(OneVector<ast::Stmt>) { "statement"; many fn fold_stmt; fn visit_stmt; fn make_stmts; }
- Items(OneVector<P<ast::Item>>) { "item"; many fn fold_item; fn visit_item; fn make_items; }
- TraitItems(OneVector<ast::TraitItem>) {
+ Stmts(SmallVec<[ast::Stmt; 1]>) {
+ "statement"; many fn fold_stmt; fn visit_stmt; fn make_stmts;
+ }
+ Items(SmallVec<[P<ast::Item>; 1]>) {
+ "item"; many fn fold_item; fn visit_item; fn make_items;
+ }
+ TraitItems(SmallVec<[ast::TraitItem; 1]>) {
"trait item"; many fn fold_trait_item; fn visit_trait_item; fn make_trait_items;
}
- ImplItems(OneVector<ast::ImplItem>) {
+ ImplItems(SmallVec<[ast::ImplItem; 1]>) {
"impl item"; many fn fold_impl_item; fn visit_impl_item; fn make_impl_items;
}
- ForeignItems(OneVector<ast::ForeignItem>) {
+ ForeignItems(SmallVec<[ast::ForeignItem; 1]>) {
"foreign item"; many fn fold_foreign_item; fn visit_foreign_item; fn make_foreign_items;
}
}
-> PResult<'a, AstFragment> {
Ok(match kind {
AstFragmentKind::Items => {
- let mut items = OneVector::new();
+ let mut items = SmallVec::new();
while let Some(item) = self.parse_item()? {
items.push(item);
}
AstFragment::Items(items)
}
AstFragmentKind::TraitItems => {
- let mut items = OneVector::new();
+ let mut items = SmallVec::new();
while self.token != token::Eof {
items.push(self.parse_trait_item(&mut false)?);
}
AstFragment::TraitItems(items)
}
AstFragmentKind::ImplItems => {
- let mut items = OneVector::new();
+ let mut items = SmallVec::new();
while self.token != token::Eof {
items.push(self.parse_impl_item(&mut false)?);
}
AstFragment::ImplItems(items)
}
AstFragmentKind::ForeignItems => {
- let mut items = OneVector::new();
+ let mut items = SmallVec::new();
while self.token != token::Eof {
if let Some(item) = self.parse_foreign_item()? {
items.push(item);
AstFragment::ForeignItems(items)
}
AstFragmentKind::Stmts => {
- let mut stmts = OneVector::new();
+ let mut stmts = SmallVec::new();
while self.token != token::Eof &&
// won't make progress on a `}`
self.token != token::CloseDelim(token::Brace) {
})
}
- fn fold_stmt(&mut self, stmt: ast::Stmt) -> OneVector<ast::Stmt> {
+ fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
let mut stmt = match self.cfg.configure_stmt(stmt) {
Some(stmt) => stmt,
- None => return OneVector::new(),
+ None => return SmallVec::new(),
};
// we'll expand attributes on expressions separately
result
}
- fn fold_item(&mut self, item: P<ast::Item>) -> OneVector<P<ast::Item>> {
+ fn fold_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
let item = configure!(self, item);
let (attr, traits, item, together_with) = self.classify_item(item);
}
}
- fn fold_trait_item(&mut self, item: ast::TraitItem) -> OneVector<ast::TraitItem> {
+ fn fold_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
let item = configure!(self, item);
let (attr, traits, item, together_with) = self.classify_item(item);
}
}
- fn fold_impl_item(&mut self, item: ast::ImplItem) -> OneVector<ast::ImplItem> {
+ fn fold_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
let item = configure!(self, item);
let (attr, traits, item, together_with) = self.classify_item(item);
noop_fold_foreign_mod(self.cfg.configure_foreign_mod(foreign_mod), self)
}
- fn fold_foreign_item(&mut self,
- foreign_item: ast::ForeignItem) -> OneVector<ast::ForeignItem> {
+ fn fold_foreign_item(&mut self, foreign_item: ast::ForeignItem)
+ -> SmallVec<[ast::ForeignItem; 1]>
+ {
let (attr, traits, foreign_item, together_with) = self.classify_item(foreign_item);
if attr.is_some() || !traits.is_empty() {
use tokenstream::TokenStream;
use fold::*;
use ptr::P;
-use OneVector;
+use smallvec::SmallVec;
use symbol::keywords;
use ThinVec;
use util::move_map::MoveMap;
}
impl<'a, 'b> Folder for PlaceholderExpander<'a, 'b> {
- fn fold_item(&mut self, item: P<ast::Item>) -> OneVector<P<ast::Item>> {
+ fn fold_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
match item.node {
ast::ItemKind::Mac(_) => return self.remove(item.id).make_items(),
ast::ItemKind::MacroDef(_) => return smallvec![item],
noop_fold_item(item, self)
}
- fn fold_trait_item(&mut self, item: ast::TraitItem) -> OneVector<ast::TraitItem> {
+ fn fold_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
match item.node {
ast::TraitItemKind::Macro(_) => self.remove(item.id).make_trait_items(),
_ => noop_fold_trait_item(item, self),
}
}
- fn fold_impl_item(&mut self, item: ast::ImplItem) -> OneVector<ast::ImplItem> {
+ fn fold_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
match item.node {
ast::ImplItemKind::Macro(_) => self.remove(item.id).make_impl_items(),
_ => noop_fold_impl_item(item, self),
}
}
- fn fold_foreign_item(&mut self, item: ast::ForeignItem) -> OneVector<ast::ForeignItem> {
+ fn fold_foreign_item(&mut self, item: ast::ForeignItem) -> SmallVec<[ast::ForeignItem; 1]> {
match item.node {
ast::ForeignItemKind::Macro(_) => self.remove(item.id).make_foreign_items(),
_ => noop_fold_foreign_item(item, self),
}
}
- fn fold_stmt(&mut self, stmt: ast::Stmt) -> OneVector<ast::Stmt> {
+ fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
let (style, mut stmts) = match stmt.node {
ast::StmtKind::Mac(mac) => (mac.1, self.remove(stmt.id).make_stmts()),
_ => return noop_fold_stmt(stmt, self),
use parse;
use print::pprust;
use ptr::P;
-use OneVector;
+use smallvec::SmallVec;
use symbol::Symbol;
use tokenstream;
fn make_expr(mut self: Box<ExpandResult<'a>>) -> Option<P<ast::Expr>> {
Some(panictry!(self.p.parse_expr()))
}
- fn make_items(mut self: Box<ExpandResult<'a>>)
- -> Option<OneVector<P<ast::Item>>> {
- let mut ret = OneVector::new();
+
+ fn make_items(mut self: Box<ExpandResult<'a>>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
+ let mut ret = SmallVec::new();
while self.p.token != token::Eof {
match panictry!(self.p.parse_item()) {
Some(item) => ret.push(item),
use parse::parser::{Parser, PathStyle};
use parse::token::{self, DocComment, Nonterminal, Token};
use print::pprust;
-use OneVector;
+use smallvec::SmallVec;
use symbol::keywords;
use tokenstream::{DelimSpan, TokenStream};
/// A `ParseResult`. Note that matches are kept track of through the items generated.
fn inner_parse_loop<'a>(
sess: &ParseSess,
- cur_items: &mut OneVector<MatcherPosHandle<'a>>,
+ cur_items: &mut SmallVec<[MatcherPosHandle<'a>; 1]>,
next_items: &mut Vec<MatcherPosHandle<'a>>,
- eof_items: &mut OneVector<MatcherPosHandle<'a>>,
- bb_items: &mut OneVector<MatcherPosHandle<'a>>,
+ eof_items: &mut SmallVec<[MatcherPosHandle<'a>; 1]>,
+ bb_items: &mut SmallVec<[MatcherPosHandle<'a>; 1]>,
token: &Token,
span: syntax_pos::Span,
) -> ParseResult<()> {
loop {
// Matcher positions black-box parsed by parser.rs (`parser`)
- let mut bb_items = OneVector::new();
+ let mut bb_items = SmallVec::new();
// Matcher positions that would be valid if the macro invocation was over now
- let mut eof_items = OneVector::new();
+ let mut eof_items = SmallVec::new();
assert!(next_items.is_empty());
// Process `cur_items` until either we have finished the input or we need to get some
use ext::tt::quoted;
use fold::noop_fold_tt;
use parse::token::{self, Token, NtTT};
-use OneVector;
+use smallvec::SmallVec;
use syntax_pos::DUMMY_SP;
use tokenstream::{TokenStream, TokenTree, Delimited, DelimSpan};
interp: Option<FxHashMap<Ident, Rc<NamedMatch>>>,
src: Vec<quoted::TokenTree>)
-> TokenStream {
- let mut stack: OneVector<Frame> = smallvec![Frame::new(src)];
+ let mut stack: SmallVec<[Frame; 1]> = smallvec![Frame::new(src)];
let interpolations = interp.unwrap_or_else(FxHashMap::default); /* just a convenience */
let mut repeats = Vec::new();
let mut result: Vec<TokenStream> = Vec::new();
use source_map::{Spanned, respan};
use parse::token::{self, Token};
use ptr::P;
-use OneVector;
+use smallvec::{Array, SmallVec};
use symbol::keywords;
use ThinVec;
use tokenstream::*;
use util::move_map::MoveMap;
use rustc_data_structures::sync::Lrc;
-use rustc_data_structures::small_vec::ExpectOne;
+
+pub trait ExpectOne<A: Array> {
+ fn expect_one(self, err: &'static str) -> A::Item;
+}
+
+impl<A: Array> ExpectOne<A> for SmallVec<A> {
+ fn expect_one(self, err: &'static str) -> A::Item {
+ assert!(self.len() == 1, err);
+ self.into_iter().next().unwrap()
+ }
+}
pub trait Folder : Sized {
// Any additions to this trait should happen in form
noop_fold_use_tree(use_tree, self)
}
- fn fold_foreign_item(&mut self, ni: ForeignItem) -> OneVector<ForeignItem> {
+ fn fold_foreign_item(&mut self, ni: ForeignItem) -> SmallVec<[ForeignItem; 1]> {
noop_fold_foreign_item(ni, self)
}
noop_fold_foreign_item_simple(ni, self)
}
- fn fold_item(&mut self, i: P<Item>) -> OneVector<P<Item>> {
+ fn fold_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {
noop_fold_item(i, self)
}
noop_fold_item_kind(i, self)
}
- fn fold_trait_item(&mut self, i: TraitItem) -> OneVector<TraitItem> {
+ fn fold_trait_item(&mut self, i: TraitItem) -> SmallVec<[TraitItem; 1]> {
noop_fold_trait_item(i, self)
}
- fn fold_impl_item(&mut self, i: ImplItem) -> OneVector<ImplItem> {
+ fn fold_impl_item(&mut self, i: ImplItem) -> SmallVec<[ImplItem; 1]> {
noop_fold_impl_item(i, self)
}
noop_fold_block(b, self)
}
- fn fold_stmt(&mut self, s: Stmt) -> OneVector<Stmt> {
+ fn fold_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> {
noop_fold_stmt(s, self)
}
}
}
-pub fn noop_fold_trait_item<T: Folder>(i: TraitItem, folder: &mut T)
- -> OneVector<TraitItem> {
+pub fn noop_fold_trait_item<T: Folder>(i: TraitItem, folder: &mut T) -> SmallVec<[TraitItem; 1]> {
smallvec![TraitItem {
id: folder.new_id(i.id),
ident: folder.fold_ident(i.ident),
}]
}
-pub fn noop_fold_impl_item<T: Folder>(i: ImplItem, folder: &mut T)
- -> OneVector<ImplItem> {
+pub fn noop_fold_impl_item<T: Folder>(i: ImplItem, folder: &mut T)-> SmallVec<[ImplItem; 1]> {
smallvec![ImplItem {
id: folder.new_id(i.id),
vis: folder.fold_vis(i.vis),
}
// fold one item into possibly many items
-pub fn noop_fold_item<T: Folder>(i: P<Item>, folder: &mut T) -> OneVector<P<Item>> {
+pub fn noop_fold_item<T: Folder>(i: P<Item>, folder: &mut T) -> SmallVec<[P<Item>; 1]> {
smallvec![i.map(|i| folder.fold_item_simple(i))]
}
}
pub fn noop_fold_foreign_item<T: Folder>(ni: ForeignItem, folder: &mut T)
--> OneVector<ForeignItem> {
+ -> SmallVec<[ForeignItem; 1]>
+{
smallvec![folder.fold_foreign_item_simple(ni)]
}
es.move_flat_map(|e| folder.fold_opt_expr(e))
}
-pub fn noop_fold_stmt<T: Folder>(Stmt {node, span, id}: Stmt, folder: &mut T) -> OneVector<Stmt> {
+pub fn noop_fold_stmt<T: Folder>(Stmt {node, span, id}: Stmt, folder: &mut T) -> SmallVec<[Stmt; 1]>
+{
let id = folder.new_id(id);
let span = folder.new_span(span);
noop_fold_stmt_kind(node, folder).into_iter().map(|node| {
}).collect()
}
-pub fn noop_fold_stmt_kind<T: Folder>(node: StmtKind, folder: &mut T) -> OneVector<StmtKind> {
+pub fn noop_fold_stmt_kind<T: Folder>(node: StmtKind, folder: &mut T) -> SmallVec<[StmtKind; 1]> {
match node {
StmtKind::Local(local) => smallvec![StmtKind::Local(folder.fold_local(local))],
StmtKind::Item(item) => folder.fold_item(item).into_iter().map(StmtKind::Item).collect(),
use rustc_data_structures::sync::Lock;
use rustc_data_structures::bit_set::GrowableBitSet;
-pub use rustc_data_structures::small_vec::OneVector;
pub use rustc_data_structures::thin_vec::ThinVec;
use ast::AttrId;
use fold::Folder;
use feature_gate::Features;
use util::move_map::MoveMap;
-use fold;
+use fold::{self, ExpectOne};
use parse::{token, ParseSess};
use print::pprust;
use ast::{self, Ident};
use ptr::P;
-use OneVector;
+use smallvec::SmallVec;
use symbol::{self, Symbol, keywords};
use ThinVec;
-use rustc_data_structures::small_vec::ExpectOne;
struct Test {
span: Span,
folded
}
- fn fold_item(&mut self, i: P<ast::Item>) -> OneVector<P<ast::Item>> {
+ fn fold_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
let ident = i.ident;
if ident.name != keywords::Invalid.name() {
self.cx.path.push(ident);
}
impl fold::Folder for EntryPointCleaner {
- fn fold_item(&mut self, i: P<ast::Item>) -> OneVector<P<ast::Item>> {
+ fn fold_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
self.depth += 1;
let folded = fold::noop_fold_item(i, self).expect_one("noop did something");
self.depth -= 1;
// except according to those terms.
use std::ptr;
-use OneVector;
+use smallvec::{Array, SmallVec};
pub trait MoveMap<T>: Sized {
fn move_map<F>(self, mut f: F) -> Self where F: FnMut(T) -> T {
}
}
-impl<T> MoveMap<T> for OneVector<T> {
+impl<T, A: Array<Item = T>> MoveMap<T> for SmallVec<A> {
fn move_flat_map<F, I>(mut self, mut f: F) -> Self
where F: FnMut(T) -> I,
I: IntoIterator<Item=T>
extern crate rustc;
extern crate rustc_data_structures;
extern crate rustc_plugin;
+#[macro_use] extern crate smallvec;
extern crate syntax_pos;
-use rustc_data_structures::small_vec::OneVector;
+use smallvec::SmallVec;
use syntax::ext::base::{ExtCtxt, MacResult, MacEager};
use syntax::tokenstream;
use rustc_plugin::Registry;
fn expand(cx: &mut ExtCtxt, _: syntax_pos::Span, _: &[tokenstream::TokenTree])
-> Box<MacResult+'static> {
- MacEager::items(OneVector::from_vec(vec![
+ MacEager::items(smallvec![
quote_item!(cx, struct Struct1;).unwrap(),
quote_item!(cx, struct Struct2;).unwrap()
- ]))
+ ])
}
projects / rust.git / commitdiff