nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use ThinVec in various AST types.

Browse Source 
This commit changes the sequence parsers to produce `ThinVec`, which
triggers numerous conversions.
This commit is contained in:
Nicholas Nethercote 2022-11-23 11:55:16 +11:00
parent 6a56c3a930
commit 4143b101f9
52 changed files with 355 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock
View File

@ -3689,6 +3689,7 @@ dependencies = [
"rustc_session", "rustc_session",
"rustc_span", "rustc_span",
"rustc_target", "rustc_target",
"thin-vec",
"tracing", "tracing",
] ]
@ -4072,6 +4073,7 @@ dependencies = [
"rustc_trait_selection", "rustc_trait_selection",
"rustc_type_ir", "rustc_type_ir",
"smallvec", "smallvec",
"thin-vec",
"tracing", "tracing",
] ]
@ -4128,6 +4130,7 @@ dependencies = [
"rustc_serialize", "rustc_serialize",
"rustc_session", "rustc_session",
"rustc_span", "rustc_span",
"thin-vec",
"tracing", "tracing",
] ]
@ -4826,7 +4829,6 @@ dependencies = [
"serde_json", "serde_json",
"smallvec", "smallvec",
"tempfile", "tempfile",
"thin-vec",
"tracing", "tracing",
"tracing-subscriber", "tracing-subscriber",
"tracing-tree", "tracing-tree",

38
compiler/rustc_ast/src/ast.rs
View File

@ -253,7 +253,7 @@ pub struct ParenthesizedArgs {
pub span: Span, pub span: Span,
/// `(A, B)` /// `(A, B)`
pub inputs: Vec<P<Ty>>, pub inputs: ThinVec<P<Ty>>,
/// ```text /// ```text
/// Foo(A, B) -> C /// Foo(A, B) -> C
@ -503,7 +503,7 @@ pub enum MetaItemKind {
/// List meta item. /// List meta item.
/// ///
/// E.g., `#[derive(..)]`, where the field represents the `..`. /// E.g., `#[derive(..)]`, where the field represents the `..`.
List(Vec<NestedMetaItem>), List(ThinVec<NestedMetaItem>),
/// Name value meta item. /// Name value meta item.
/// ///
@ -581,7 +581,7 @@ impl Pat {
// A tuple pattern `(P0, .., Pn)` can be reparsed as `(T0, .., Tn)` // A tuple pattern `(P0, .., Pn)` can be reparsed as `(T0, .., Tn)`
// assuming `T0` to `Tn` are all syntactically valid as types. // assuming `T0` to `Tn` are all syntactically valid as types.
PatKind::Tuple(pats) => { PatKind::Tuple(pats) => {
let mut tys = Vec::with_capacity(pats.len()); let mut tys = ThinVec::with_capacity(pats.len());
// FIXME(#48994) - could just be collected into an Option<Vec> // FIXME(#48994) - could just be collected into an Option<Vec>
for pat in pats { for pat in pats {
tys.push(pat.to_ty()?); tys.push(pat.to_ty()?);
@ -725,11 +725,11 @@ pub enum PatKind {
Struct(Option<P<QSelf>>, Path, Vec<PatField>, /* recovered */ bool), Struct(Option<P<QSelf>>, Path, Vec<PatField>, /* recovered */ bool),
/// A tuple struct/variant pattern (`Variant(x, y, .., z)`). /// A tuple struct/variant pattern (`Variant(x, y, .., z)`).
TupleStruct(Option<P<QSelf>>, Path, Vec<P<Pat>>), TupleStruct(Option<P<QSelf>>, Path, ThinVec<P<Pat>>),
/// An or-pattern `A | B | C`. /// An or-pattern `A | B | C`.
/// Invariant: `pats.len() >= 2`. /// Invariant: `pats.len() >= 2`.
Or(Vec<P<Pat>>), Or(ThinVec<P<Pat>>),
/// A possibly qualified path pattern. /// A possibly qualified path pattern.
/// Unqualified path patterns `A::B::C` can legally refer to variants, structs, constants /// Unqualified path patterns `A::B::C` can legally refer to variants, structs, constants
@ -738,7 +738,7 @@ pub enum PatKind {
Path(Option<P<QSelf>>, Path), Path(Option<P<QSelf>>, Path),
/// A tuple pattern (`(a, b)`). /// A tuple pattern (`(a, b)`).
Tuple(Vec<P<Pat>>), Tuple(ThinVec<P<Pat>>),
/// A `box` pattern. /// A `box` pattern.
Box(P<Pat>), Box(P<Pat>),
@ -753,7 +753,7 @@ pub enum PatKind {
Range(Option<P<Expr>>, Option<P<Expr>>, Spanned<RangeEnd>), Range(Option<P<Expr>>, Option<P<Expr>>, Spanned<RangeEnd>),
/// A slice pattern `[a, b, c]`. /// A slice pattern `[a, b, c]`.
Slice(Vec<P<Pat>>), Slice(ThinVec<P<Pat>>),
/// A rest pattern `..`. /// A rest pattern `..`.
/// ///
@ -1204,7 +1204,7 @@ impl Expr {
ExprKind::Array(exprs) if exprs.len() == 1 => exprs[0].to_ty().map(TyKind::Slice)?, ExprKind::Array(exprs) if exprs.len() == 1 => exprs[0].to_ty().map(TyKind::Slice)?,
ExprKind::Tup(exprs) => { ExprKind::Tup(exprs) => {
let tys = exprs.iter().map(|expr| expr.to_ty()).collect::<Option<Vec<_>>>()?; let tys = exprs.iter().map(|expr| expr.to_ty()).collect::<Option<ThinVec<_>>>()?;
TyKind::Tup(tys) TyKind::Tup(tys)
} }
@ -1337,7 +1337,7 @@ pub struct MethodCall {
/// The receiver, e.g. `x`. /// The receiver, e.g. `x`.
pub receiver: P<Expr>, pub receiver: P<Expr>,
/// The arguments, e.g. `a, b, c`. /// The arguments, e.g. `a, b, c`.
pub args: Vec<P<Expr>>, pub args: ThinVec<P<Expr>>,
/// The span of the function, without the dot and receiver e.g. `foo::<Bar, /// The span of the function, without the dot and receiver e.g. `foo::<Bar,
/// Baz>(a, b, c)`. /// Baz>(a, b, c)`.
pub span: Span, pub span: Span,
@ -1366,7 +1366,7 @@ pub enum ExprKind {
/// A `box x` expression. /// A `box x` expression.
Box(P<Expr>), Box(P<Expr>),
/// An array (`[a, b, c, d]`) /// An array (`[a, b, c, d]`)
Array(Vec<P<Expr>>), Array(ThinVec<P<Expr>>),
/// Allow anonymous constants from an inline `const` block /// Allow anonymous constants from an inline `const` block
ConstBlock(AnonConst), ConstBlock(AnonConst),
/// A function call /// A function call
@ -1375,11 +1375,11 @@ pub enum ExprKind {
/// and the second field is the list of arguments. /// and the second field is the list of arguments.
/// This also represents calling the constructor of /// This also represents calling the constructor of
/// tuple-like ADTs such as tuple structs and enum variants. /// tuple-like ADTs such as tuple structs and enum variants.
Call(P<Expr>, Vec<P<Expr>>), Call(P<Expr>, ThinVec<P<Expr>>),
/// A method call (e.g. `x.foo::<Bar, Baz>(a, b, c)`). /// A method call (e.g. `x.foo::<Bar, Baz>(a, b, c)`).
MethodCall(Box<MethodCall>), MethodCall(Box<MethodCall>),
/// A tuple (e.g., `(a, b, c, d)`). /// A tuple (e.g., `(a, b, c, d)`).
Tup(Vec<P<Expr>>), Tup(ThinVec<P<Expr>>),
/// A binary operation (e.g., `a + b`, `a * b`). /// A binary operation (e.g., `a + b`, `a * b`).
Binary(BinOp, P<Expr>, P<Expr>), Binary(BinOp, P<Expr>, P<Expr>),
/// A unary operation (e.g., `!x`, `*x`). /// A unary operation (e.g., `!x`, `*x`).
@ -2078,7 +2078,7 @@ pub enum TyKind {
/// The never type (`!`). /// The never type (`!`).
Never, Never,
/// A tuple (`(A, B, C, D,...)`). /// A tuple (`(A, B, C, D,...)`).
Tup(Vec<P<Ty>>), Tup(ThinVec<P<Ty>>),
/// A path (`module::module::...::Type`), optionally /// A path (`module::module::...::Type`), optionally
/// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`. /// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
/// ///
@ -2363,7 +2363,7 @@ impl Param {
/// which contains metadata about function safety, asyncness, constness and ABI. /// which contains metadata about function safety, asyncness, constness and ABI.
#[derive(Clone, Encodable, Decodable, Debug)] #[derive(Clone, Encodable, Decodable, Debug)]
pub struct FnDecl { pub struct FnDecl {
pub inputs: Vec<Param>, pub inputs: ThinVec<Param>,
pub output: FnRetTy, pub output: FnRetTy,
} }
@ -2532,7 +2532,7 @@ pub enum UseTreeKind {
/// `use prefix` or `use prefix as rename` /// `use prefix` or `use prefix as rename`
Simple(Option<Ident>), Simple(Option<Ident>),
/// `use prefix::{...}` /// `use prefix::{...}`
Nested(Vec<(UseTree, NodeId)>), Nested(ThinVec<(UseTree, NodeId)>),
/// `use prefix::*` /// `use prefix::*`
Glob, Glob,
} }
@ -2695,11 +2695,11 @@ pub enum VariantData {
/// Struct variant. /// Struct variant.
/// ///
/// E.g., `Bar { .. }` as in `enum Foo { Bar { .. } }`. /// E.g., `Bar { .. }` as in `enum Foo { Bar { .. } }`.
Struct(Vec<FieldDef>, bool), Struct(ThinVec<FieldDef>, bool),
/// Tuple variant. /// Tuple variant.
/// ///
/// E.g., `Bar(..)` as in `enum Foo { Bar(..) }`. /// E.g., `Bar(..)` as in `enum Foo { Bar(..) }`.
Tuple(Vec<FieldDef>, NodeId), Tuple(ThinVec<FieldDef>, NodeId),
/// Unit variant. /// Unit variant.
/// ///
/// E.g., `Bar = ..` as in `enum Foo { Bar = .. }`. /// E.g., `Bar = ..` as in `enum Foo { Bar = .. }`.
@ -3122,8 +3122,8 @@ mod size_asserts {
static_assert_size!(GenericBound, 56); static_assert_size!(GenericBound, 56);
static_assert_size!(Generics, 40); static_assert_size!(Generics, 40);
static_assert_size!(Impl, 136); static_assert_size!(Impl, 136);
static_assert_size!(Item, 152); static_assert_size!(Item, 144);
static_assert_size!(ItemKind, 80); static_assert_size!(ItemKind, 72);
static_assert_size!(LitKind, 24); static_assert_size!(LitKind, 24);
static_assert_size!(Local, 72); static_assert_size!(Local, 72);
static_assert_size!(MetaItemLit, 40); static_assert_size!(MetaItemLit, 40);

10
compiler/rustc_ast/src/attr/mod.rs
View File

@ -20,7 +20,7 @@ use std::iter;
use std::ops::BitXor; use std::ops::BitXor;
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
use std::sync::atomic::{AtomicU32, Ordering}; use std::sync::atomic::{AtomicU32, Ordering};
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
pub struct MarkedAttrs(GrowableBitSet<AttrId>); pub struct MarkedAttrs(GrowableBitSet<AttrId>);
@ -135,7 +135,7 @@ impl Attribute {
} }
} }
pub fn meta_item_list(&self) -> Option<Vec<NestedMetaItem>> { pub fn meta_item_list(&self) -> Option<ThinVec<NestedMetaItem>> {
match &self.kind { match &self.kind {
AttrKind::Normal(normal) => normal.item.meta_item_list(), AttrKind::Normal(normal) => normal.item.meta_item_list(),
AttrKind::DocComment(..) => None, AttrKind::DocComment(..) => None,
@ -216,7 +216,7 @@ impl AttrItem {
self.args.span().map_or(self.path.span, |args_span| self.path.span.to(args_span)) self.args.span().map_or(self.path.span, |args_span| self.path.span.to(args_span))
} }
fn meta_item_list(&self) -> Option<Vec<NestedMetaItem>> { fn meta_item_list(&self) -> Option<ThinVec<NestedMetaItem>> {
match &self.args { match &self.args {
AttrArgs::Delimited(args) if args.delim == MacDelimiter::Parenthesis => { AttrArgs::Delimited(args) if args.delim == MacDelimiter::Parenthesis => {
MetaItemKind::list_from_tokens(args.tokens.clone()) MetaItemKind::list_from_tokens(args.tokens.clone())
@ -375,9 +375,9 @@ impl MetaItemKind {
} }
} }
fn list_from_tokens(tokens: TokenStream) -> Option<Vec<NestedMetaItem>> { fn list_from_tokens(tokens: TokenStream) -> Option<ThinVec<NestedMetaItem>> {
let mut tokens = tokens.into_trees().peekable(); let mut tokens = tokens.into_trees().peekable();
let mut result = Vec::new(); let mut result = ThinVec::new();
while tokens.peek().is_some() { while tokens.peek().is_some() {
let item = NestedMetaItem::from_tokens(&mut tokens)?; let item = NestedMetaItem::from_tokens(&mut tokens)?;
result.push(item); result.push(item);

23
compiler/rustc_ast/src/mut_visit.rs
View File

@ -369,6 +369,11 @@ pub fn visit_exprs<T: MutVisitor>(exprs: &mut Vec<P<Expr>>, vis: &mut T) {
exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr)) exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr))
} }
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
pub fn visit_thin_exprs<T: MutVisitor>(exprs: &mut ThinVec<P<Expr>>, vis: &mut T) {
exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr))
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
pub fn visit_bounds<T: MutVisitor>(bounds: &mut GenericBounds, vis: &mut T) { pub fn visit_bounds<T: MutVisitor>(bounds: &mut GenericBounds, vis: &mut T) {
visit_vec(bounds, |bound| vis.visit_param_bound(bound)); visit_vec(bounds, |bound| vis.visit_param_bound(bound));
@ -485,7 +490,7 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
vis.visit_fn_decl(decl); vis.visit_fn_decl(decl);
vis.visit_span(decl_span); vis.visit_span(decl_span);
} }
TyKind::Tup(tys) => visit_vec(tys, |ty| vis.visit_ty(ty)), TyKind::Tup(tys) => visit_thin_vec(tys, |ty| vis.visit_ty(ty)),
TyKind::Paren(ty) => vis.visit_ty(ty), TyKind::Paren(ty) => vis.visit_ty(ty),
TyKind::Path(qself, path) => { TyKind::Path(qself, path) => {
vis.visit_qself(qself); vis.visit_qself(qself);
@ -584,7 +589,7 @@ pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(
vis: &mut T, vis: &mut T,
) { ) {
let ParenthesizedArgs { inputs, output, span, .. } = args; let ParenthesizedArgs { inputs, output, span, .. } = args;
visit_vec(inputs, |input| vis.visit_ty(input)); visit_thin_vec(inputs, |input| vis.visit_ty(input));
noop_visit_fn_ret_ty(output, vis); noop_visit_fn_ret_ty(output, vis);
vis.visit_span(span); vis.visit_span(span);
} }
@ -647,7 +652,7 @@ pub fn noop_visit_meta_item<T: MutVisitor>(mi: &mut MetaItem, vis: &mut T) {
let MetaItem { path: _, kind, span } = mi; let MetaItem { path: _, kind, span } = mi;
match kind { match kind {
MetaItemKind::Word => {} MetaItemKind::Word => {}
MetaItemKind::List(mis) => visit_vec(mis, |mi| vis.visit_meta_list_item(mi)), MetaItemKind::List(mis) => visit_thin_vec(mis, |mi| vis.visit_meta_list_item(mi)),
MetaItemKind::NameValue(_s) => {} MetaItemKind::NameValue(_s) => {}
} }
vis.visit_span(span); vis.visit_span(span);
@ -1236,7 +1241,7 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
PatKind::TupleStruct(qself, path, elems) => { PatKind::TupleStruct(qself, path, elems) => {
vis.visit_qself(qself); vis.visit_qself(qself);
vis.visit_path(path); vis.visit_path(path);
visit_vec(elems, |elem| vis.visit_pat(elem)); visit_thin_vec(elems, |elem| vis.visit_pat(elem));
} }
PatKind::Path(qself, path) => { PatKind::Path(qself, path) => {
vis.visit_qself(qself); vis.visit_qself(qself);
@ -1255,7 +1260,7 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
vis.visit_span(span); vis.visit_span(span);
} }
PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => { PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => {
visit_vec(elems, |elem| vis.visit_pat(elem)) visit_thin_vec(elems, |elem| vis.visit_pat(elem))
} }
PatKind::Paren(inner) => vis.visit_pat(inner), PatKind::Paren(inner) => vis.visit_pat(inner),
PatKind::MacCall(mac) => vis.visit_mac_call(mac), PatKind::MacCall(mac) => vis.visit_mac_call(mac),
@ -1312,7 +1317,7 @@ pub fn noop_visit_expr<T: MutVisitor>(
) { ) {
match kind { match kind {
ExprKind::Box(expr) => vis.visit_expr(expr), ExprKind::Box(expr) => vis.visit_expr(expr),
ExprKind::Array(exprs) => visit_exprs(exprs, vis), ExprKind::Array(exprs) => visit_thin_exprs(exprs, vis),
ExprKind::ConstBlock(anon_const) => { ExprKind::ConstBlock(anon_const) => {
vis.visit_anon_const(anon_const); vis.visit_anon_const(anon_const);
} }
@ -1320,10 +1325,10 @@ pub fn noop_visit_expr<T: MutVisitor>(
vis.visit_expr(expr); vis.visit_expr(expr);
vis.visit_anon_const(count); vis.visit_anon_const(count);
} }
ExprKind::Tup(exprs) => visit_exprs(exprs, vis), ExprKind::Tup(exprs) => visit_thin_exprs(exprs, vis),
ExprKind::Call(f, args) => { ExprKind::Call(f, args) => {
vis.visit_expr(f); vis.visit_expr(f);
visit_exprs(args, vis); visit_thin_exprs(args, vis);
} }
ExprKind::MethodCall(box MethodCall { ExprKind::MethodCall(box MethodCall {
seg: PathSegment { ident, id, args: seg_args }, seg: PathSegment { ident, id, args: seg_args },
@ -1335,7 +1340,7 @@ pub fn noop_visit_expr<T: MutVisitor>(
vis.visit_id(id); vis.visit_id(id);
visit_opt(seg_args, |args| vis.visit_generic_args(args)); visit_opt(seg_args, |args| vis.visit_generic_args(args));
vis.visit_method_receiver_expr(receiver); vis.visit_method_receiver_expr(receiver);
visit_exprs(call_args, vis); visit_thin_exprs(call_args, vis);
vis.visit_span(span); vis.visit_span(span);
} }
ExprKind::Binary(_binop, lhs, rhs) => { ExprKind::Binary(_binop, lhs, rhs) => {

4
compiler/rustc_ast_lowering/src/expr.rs
View File

@ -18,7 +18,7 @@ use rustc_session::errors::report_lit_error;
use rustc_span::source_map::{respan, DesugaringKind, Span, Spanned}; use rustc_span::source_map::{respan, DesugaringKind, Span, Spanned};
use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::DUMMY_SP; use rustc_span::DUMMY_SP;
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
impl<'hir> LoweringContext<'_, 'hir> { impl<'hir> LoweringContext<'_, 'hir> {
fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [hir::Expr<'hir>] { fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [hir::Expr<'hir>] {
@ -367,7 +367,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
fn lower_legacy_const_generics( fn lower_legacy_const_generics(
&mut self, &mut self,
mut f: Expr, mut f: Expr,
args: Vec<AstP<Expr>>, args: ThinVec<AstP<Expr>>,
legacy_args_idx: &[usize], legacy_args_idx: &[usize],
) -> hir::ExprKind<'hir> { ) -> hir::ExprKind<'hir> {
let ExprKind::Path(None, path) = &mut f.kind else { let ExprKind::Path(None, path) = &mut f.kind else {

5
compiler/rustc_ast_passes/Cargo.toml
View File

@ -5,7 +5,7 @@ edition = "2021"
[dependencies] [dependencies]
itertools = "0.10.1" itertools = "0.10.1"
tracing = "0.1" rustc_ast = { path = "../rustc_ast" }
rustc_ast_pretty = { path = "../rustc_ast_pretty" } rustc_ast_pretty = { path = "../rustc_ast_pretty" }
rustc_attr = { path = "../rustc_attr" } rustc_attr = { path = "../rustc_attr" }
rustc_data_structures = { path = "../rustc_data_structures" } rustc_data_structures = { path = "../rustc_data_structures" }
@ -16,4 +16,5 @@ rustc_parse = { path = "../rustc_parse" }
rustc_session = { path = "../rustc_session" } rustc_session = { path = "../rustc_session" }
rustc_span = { path = "../rustc_span" } rustc_span = { path = "../rustc_span" }
rustc_target = { path = "../rustc_target" } rustc_target = { path = "../rustc_target" }
rustc_ast = { path = "../rustc_ast" } thin-vec = "0.2.12"
tracing = "0.1"

4
compiler/rustc_ast_passes/src/feature_gate.rs
View File

@ -10,6 +10,8 @@ use rustc_span::source_map::Spanned;
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
use rustc_span::Span; use rustc_span::Span;
use rustc_target::spec::abi; use rustc_target::spec::abi;
use thin_vec::ThinVec;
use tracing::debug;
use crate::errors::ForbiddenLifetimeBound; use crate::errors::ForbiddenLifetimeBound;
@ -250,7 +252,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
ast::ItemKind::Struct(..) => { ast::ItemKind::Struct(..) => {
for attr in self.sess.filter_by_name(&i.attrs, sym::repr) { for attr in self.sess.filter_by_name(&i.attrs, sym::repr) {
for item in attr.meta_item_list().unwrap_or_else(Vec::new) { for item in attr.meta_item_list().unwrap_or_else(ThinVec::new) {
if item.has_name(sym::simd) { if item.has_name(sym::simd) {
gate_feature_post!( gate_feature_post!(
&self, &self,

3
compiler/rustc_ast_passes/src/lib.rs
View File

@ -11,9 +11,6 @@
#![feature(let_chains)] #![feature(let_chains)]
#![recursion_limit = "256"] #![recursion_limit = "256"]
#[macro_use]
extern crate tracing;
pub mod ast_validation; pub mod ast_validation;
mod errors; mod errors;
pub mod feature_gate; pub mod feature_gate;

7
compiler/rustc_ast_pretty/src/pprust/tests.rs
View File

@ -3,6 +3,7 @@ use super::*;
use rustc_ast as ast; use rustc_ast as ast;
use rustc_span::create_default_session_globals_then; use rustc_span::create_default_session_globals_then;
use rustc_span::symbol::Ident; use rustc_span::symbol::Ident;
use thin_vec::ThinVec;
fn fun_to_string( fn fun_to_string(
decl: &ast::FnDecl, decl: &ast::FnDecl,
@ -27,8 +28,10 @@ fn test_fun_to_string() {
create_default_session_globals_then(|| { create_default_session_globals_then(|| {
let abba_ident = Ident::from_str("abba"); let abba_ident = Ident::from_str("abba");
let decl = let decl = ast::FnDecl {
ast::FnDecl { inputs: Vec::new(), output: ast::FnRetTy::Default(rustc_span::DUMMY_SP) }; inputs: ThinVec::new(),
output: ast::FnRetTy::Default(rustc_span::DUMMY_SP),
};
let generics = ast::Generics::default(); let generics = ast::Generics::default();
assert_eq!( assert_eq!(
fun_to_string(&decl, ast::FnHeader::default(), abba_ident, &generics), fun_to_string(&decl, ast::FnHeader::default(), abba_ident, &generics),

15
compiler/rustc_builtin_macros/src/alloc_error_handler.rs
View File

@ -6,7 +6,7 @@ use rustc_ast::{Fn, ItemKind, Stmt, TyKind, Unsafe};
use rustc_expand::base::{Annotatable, ExtCtxt}; use rustc_expand::base::{Annotatable, ExtCtxt};
use rustc_span::symbol::{kw, sym, Ident}; use rustc_span::symbol::{kw, sym, Ident};
use rustc_span::Span; use rustc_span::Span;
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
pub fn expand( pub fn expand(
ecx: &mut ExtCtxt<'_>, ecx: &mut ExtCtxt<'_>,
@ -42,7 +42,7 @@ pub fn expand(
let stmts = vec![generate_handler(ecx, item.ident, span, sig_span)]; let stmts = vec![generate_handler(ecx, item.ident, span, sig_span)];
// Generate anonymous constant serving as container for the allocator methods. // Generate anonymous constant serving as container for the allocator methods.
let const_ty = ecx.ty(sig_span, TyKind::Tup(Vec::new())); let const_ty = ecx.ty(sig_span, TyKind::Tup(ThinVec::new()));
let const_body = ecx.expr_block(ecx.block(span, stmts)); let const_body = ecx.expr_block(ecx.block(span, stmts));
let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body); let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
let const_item = if is_stmt { let const_item = if is_stmt {
@ -67,13 +67,16 @@ fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig_span: Span
let layout_new = cx.std_path(&[sym::alloc, sym::Layout, sym::from_size_align_unchecked]); let layout_new = cx.std_path(&[sym::alloc, sym::Layout, sym::from_size_align_unchecked]);
let layout_new = cx.expr_path(cx.path(span, layout_new)); let layout_new = cx.expr_path(cx.path(span, layout_new));
let layout = let layout = cx.expr_call(
cx.expr_call(span, layout_new, vec![cx.expr_ident(span, size), cx.expr_ident(span, align)]); span,
layout_new,
thin_vec![cx.expr_ident(span, size), cx.expr_ident(span, align)],
);
let call = cx.expr_call_ident(sig_span, handler, vec![layout]); let call = cx.expr_call_ident(sig_span, handler, thin_vec![layout]);
let never = ast::FnRetTy::Ty(cx.ty(span, TyKind::Never)); let never = ast::FnRetTy::Ty(cx.ty(span, TyKind::Never));
let params = vec![cx.param(span, size, ty_usize.clone()), cx.param(span, align, ty_usize)]; let params = thin_vec![cx.param(span, size, ty_usize.clone()), cx.param(span, align, ty_usize)];
let decl = cx.fn_decl(params, never); let decl = cx.fn_decl(params, never);
let header = FnHeader { unsafety: Unsafe::Yes(span), ..FnHeader::default() }; let header = FnHeader { unsafety: Unsafe::Yes(span), ..FnHeader::default() };
let sig = FnSig { decl, header, span: span }; let sig = FnSig { decl, header, span: span };

3
compiler/rustc_builtin_macros/src/assert.rs
View File

@ -11,6 +11,7 @@ use rustc_expand::base::{DummyResult, ExtCtxt, MacEager, MacResult};
use rustc_parse::parser::Parser; use rustc_parse::parser::Parser;
use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP}; use rustc_span::{Span, DUMMY_SP};
use thin_vec::thin_vec;
pub fn expand_assert<'cx>( pub fn expand_assert<'cx>(
cx: &'cx mut ExtCtxt<'_>, cx: &'cx mut ExtCtxt<'_>,
@ -79,7 +80,7 @@ pub fn expand_assert<'cx>(
let then = cx.expr_call_global( let then = cx.expr_call_global(
call_site_span, call_site_span,
cx.std_path(&[sym::panicking, sym::panic]), cx.std_path(&[sym::panicking, sym::panic]),
vec![cx.expr_str( thin_vec![cx.expr_str(
DUMMY_SP, DUMMY_SP,
Symbol::intern(&format!( Symbol::intern(&format!(
"assertion failed: {}", "assertion failed: {}",

14
compiler/rustc_builtin_macros/src/assert/context.rs
View File

@ -12,7 +12,7 @@ use rustc_span::{
symbol::{sym, Ident, Symbol}, symbol::{sym, Ident, Symbol},
Span, Span,
}; };
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
pub(super) struct Context<'cx, 'a> { pub(super) struct Context<'cx, 'a> {
// An optimization. // An optimization.
@ -120,7 +120,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
thin_vec![self.cx.attr_nested_word(sym::allow, sym::unused_imports, self.span)], thin_vec![self.cx.attr_nested_word(sym::allow, sym::unused_imports, self.span)],
ItemKind::Use(UseTree { ItemKind::Use(UseTree {
prefix: self.cx.path(self.span, self.cx.std_path(&[sym::asserting])), prefix: self.cx.path(self.span, self.cx.std_path(&[sym::asserting])),
kind: UseTreeKind::Nested(vec![ kind: UseTreeKind::Nested(thin_vec![
nested_tree(self, sym::TryCaptureGeneric), nested_tree(self, sym::TryCaptureGeneric),
nested_tree(self, sym::TryCapturePrintable), nested_tree(self, sym::TryCapturePrintable),
]), ]),
@ -136,7 +136,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
self.cx.expr_call( self.cx.expr_call(
self.span, self.span,
self.cx.expr_path(self.cx.path(self.span, unlikely_path)), self.cx.expr_path(self.cx.path(self.span, unlikely_path)),
vec![self.cx.expr(self.span, ExprKind::Unary(UnOp::Not, cond_expr))], thin_vec![self.cx.expr(self.span, ExprKind::Unary(UnOp::Not, cond_expr))],
) )
} }
@ -339,7 +339,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
let init = self.cx.expr_call( let init = self.cx.expr_call(
self.span, self.span,
self.cx.expr_path(self.cx.path(self.span, init_std_path)), self.cx.expr_path(self.cx.path(self.span, init_std_path)),
vec![], ThinVec::new(),
); );
let capture = Capture { decl: self.cx.stmt_let(self.span, true, ident, init), ident }; let capture = Capture { decl: self.cx.stmt_let(self.span, true, ident, init), ident };
self.capture_decls.push(capture); self.capture_decls.push(capture);
@ -366,7 +366,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
self.cx.expr_path( self.cx.expr_path(
self.cx.path(self.span, self.cx.std_path(&[sym::asserting, sym::Wrapper])), self.cx.path(self.span, self.cx.std_path(&[sym::asserting, sym::Wrapper])),
), ),
vec![self.cx.expr_path(Path::from_ident(local_bind))], thin_vec![self.cx.expr_path(Path::from_ident(local_bind))],
); );
let try_capture_call = self let try_capture_call = self
.cx .cx
@ -378,7 +378,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
ident: Ident::new(sym::try_capture, self.span), ident: Ident::new(sym::try_capture, self.span),
}, },
expr_paren(self.cx, self.span, self.cx.expr_addr_of(self.span, wrapper)), expr_paren(self.cx, self.span, self.cx.expr_addr_of(self.span, wrapper)),
vec![expr_addr_of_mut( thin_vec![expr_addr_of_mut(
self.cx, self.cx,
self.span, self.span,
self.cx.expr_path(Path::from_ident(capture)), self.cx.expr_path(Path::from_ident(capture)),
@ -441,7 +441,7 @@ fn expr_method_call(
cx: &ExtCtxt<'_>, cx: &ExtCtxt<'_>,
seg: PathSegment, seg: PathSegment,
receiver: P<Expr>, receiver: P<Expr>,
args: Vec<P<Expr>>, args: ThinVec<P<Expr>>,
span: Span, span: Span,
) -> P<Expr> { ) -> P<Expr> {
cx.expr(span, ExprKind::MethodCall(Box::new(MethodCall { seg, receiver, args, span }))) cx.expr(span, ExprKind::MethodCall(Box::new(MethodCall { seg, receiver, args, span })))

2
compiler/rustc_builtin_macros/src/deriving/clone.rs
View File

@ -162,7 +162,7 @@ fn cs_clone(
let all_fields; let all_fields;
let fn_path = cx.std_path(&[sym::clone, sym::Clone, sym::clone]); let fn_path = cx.std_path(&[sym::clone, sym::Clone, sym::clone]);
let subcall = |cx: &mut ExtCtxt<'_>, field: &FieldInfo| { let subcall = |cx: &mut ExtCtxt<'_>, field: &FieldInfo| {
let args = vec![field.self_expr.clone()]; let args = thin_vec![field.self_expr.clone()];
cx.expr_call_global(field.span, fn_path.clone(), args) cx.expr_call_global(field.span, fn_path.clone(), args)
}; };

2
compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs
View File

@ -64,7 +64,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> Bl
let [other_expr] = &field.other_selflike_exprs[..] else { let [other_expr] = &field.other_selflike_exprs[..] else {
cx.span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`"); cx.span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`");
}; };
let args = vec![field.self_expr.clone(), other_expr.clone()]; let args = thin_vec![field.self_expr.clone(), other_expr.clone()];
cx.expr_call_global(field.span, cmp_path.clone(), args) cx.expr_call_global(field.span, cmp_path.clone(), args)
} }
CsFold::Combine(span, expr1, expr2) => { CsFold::Combine(span, expr1, expr2) => {

2
compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
View File

@ -98,7 +98,7 @@ fn cs_partial_cmp(
let [other_expr] = &field.other_selflike_exprs[..] else { let [other_expr] = &field.other_selflike_exprs[..] else {
cx.span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`"); cx.span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`");
}; };
let args = vec![field.self_expr.clone(), other_expr.clone()]; let args = thin_vec![field.self_expr.clone(), other_expr.clone()];
cx.expr_call_global(field.span, partial_cmp_path.clone(), args) cx.expr_call_global(field.span, partial_cmp_path.clone(), args)
} }
CsFold::Combine(span, mut expr1, expr2) => { CsFold::Combine(span, mut expr1, expr2) => {

15
compiler/rustc_builtin_macros/src/deriving/debug.rs
View File

@ -7,6 +7,7 @@ use rustc_ast::{self as ast, MetaItem};
use rustc_expand::base::{Annotatable, ExtCtxt}; use rustc_expand::base::{Annotatable, ExtCtxt};
use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::Span; use rustc_span::Span;
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_debug( pub fn expand_deriving_debug(
cx: &mut ExtCtxt<'_>, cx: &mut ExtCtxt<'_>,
@ -94,7 +95,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
if fields.is_empty() { if fields.is_empty() {
// Special case for no fields. // Special case for no fields.
let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]); let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]);
let expr = cx.expr_call_global(span, fn_path_write_str, vec![fmt, name]); let expr = cx.expr_call_global(span, fn_path_write_str, thin_vec![fmt, name]);
BlockOrExpr::new_expr(expr) BlockOrExpr::new_expr(expr)
} else if fields.len() <= CUTOFF { } else if fields.len() <= CUTOFF {
// Few enough fields that we can use a specific-length method. // Few enough fields that we can use a specific-length method.
@ -105,7 +106,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
}; };
let fn_path_debug = cx.std_path(&[sym::fmt, sym::Formatter, Symbol::intern(&debug)]); let fn_path_debug = cx.std_path(&[sym::fmt, sym::Formatter, Symbol::intern(&debug)]);
let mut args = Vec::with_capacity(2 + fields.len() * args_per_field); let mut args = ThinVec::with_capacity(2 + fields.len() * args_per_field);
args.extend([fmt, name]); args.extend([fmt, name]);
for i in 0..fields.len() { for i in 0..fields.len() {
let field = &fields[i]; let field = &fields[i];
@ -121,8 +122,8 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
BlockOrExpr::new_expr(expr) BlockOrExpr::new_expr(expr)
} else { } else {
// Enough fields that we must use the any-length method. // Enough fields that we must use the any-length method.
let mut name_exprs = Vec::with_capacity(fields.len()); let mut name_exprs = ThinVec::with_capacity(fields.len());
let mut value_exprs = Vec::with_capacity(fields.len()); let mut value_exprs = ThinVec::with_capacity(fields.len());
for i in 0..fields.len() { for i in 0..fields.len() {
let field = &fields[i]; let field = &fields[i];
@ -177,7 +178,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
}; };
let fn_path_debug_internal = cx.std_path(&[sym::fmt, sym::Formatter, sym_debug]); let fn_path_debug_internal = cx.std_path(&[sym::fmt, sym::Formatter, sym_debug]);
let mut args = Vec::with_capacity(4); let mut args = ThinVec::with_capacity(4);
args.push(fmt); args.push(fmt);
args.push(name); args.push(name);
if is_struct { if is_struct {
@ -223,7 +224,7 @@ fn show_fieldless_enum(
let pat = match &v.data { let pat = match &v.data {
ast::VariantData::Tuple(fields, _) => { ast::VariantData::Tuple(fields, _) => {
debug_assert!(fields.is_empty()); debug_assert!(fields.is_empty());
cx.pat_tuple_struct(span, variant_path, vec![]) cx.pat_tuple_struct(span, variant_path, thin_vec![])
} }
ast::VariantData::Struct(fields, _) => { ast::VariantData::Struct(fields, _) => {
debug_assert!(fields.is_empty()); debug_assert!(fields.is_empty());
@ -236,5 +237,5 @@ fn show_fieldless_enum(
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let name = cx.expr_match(span, cx.expr_self(span), arms); let name = cx.expr_match(span, cx.expr_self(span), arms);
let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]); let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]);
BlockOrExpr::new_expr(cx.expr_call_global(span, fn_path_write_str, vec![fmt, name])) BlockOrExpr::new_expr(cx.expr_call_global(span, fn_path_write_str, thin_vec![fmt, name]))
} }

14
compiler/rustc_builtin_macros/src/deriving/decodable.rs
View File

@ -3,12 +3,12 @@
use crate::deriving::generic::ty::*; use crate::deriving::generic::ty::*;
use crate::deriving::generic::*; use crate::deriving::generic::*;
use crate::deriving::pathvec_std; use crate::deriving::pathvec_std;
use rustc_ast::ptr::P; use rustc_ast::ptr::P;
use rustc_ast::{self as ast, Expr, MetaItem, Mutability}; use rustc_ast::{self as ast, Expr, MetaItem, Mutability};
use rustc_expand::base::{Annotatable, ExtCtxt}; use rustc_expand::base::{Annotatable, ExtCtxt};
use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::Span; use rustc_span::Span;
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_rustc_decodable( pub fn expand_deriving_rustc_decodable(
cx: &mut ExtCtxt<'_>, cx: &mut ExtCtxt<'_>,
@ -96,7 +96,7 @@ fn decodable_substructure(
cx.expr_call_global( cx.expr_call_global(
span, span,
fn_read_struct_field_path.clone(), fn_read_struct_field_path.clone(),
vec![ thin_vec![
blkdecoder.clone(), blkdecoder.clone(),
cx.expr_str(span, name), cx.expr_str(span, name),
cx.expr_usize(span, field), cx.expr_usize(span, field),
@ -112,7 +112,7 @@ fn decodable_substructure(
cx.expr_call_global( cx.expr_call_global(
trait_span, trait_span,
fn_read_struct_path, fn_read_struct_path,
vec![ thin_vec![
decoder, decoder,
cx.expr_str(trait_span, substr.type_ident.name), cx.expr_str(trait_span, substr.type_ident.name),
cx.expr_usize(trait_span, nfields), cx.expr_usize(trait_span, nfields),
@ -124,7 +124,7 @@ fn decodable_substructure(
let variant = Ident::new(sym::i, trait_span); let variant = Ident::new(sym::i, trait_span);
let mut arms = Vec::with_capacity(fields.len() + 1); let mut arms = Vec::with_capacity(fields.len() + 1);
let mut variants = Vec::with_capacity(fields.len()); let mut variants = ThinVec::with_capacity(fields.len());
let fn_read_enum_variant_arg_path: Vec<_> = let fn_read_enum_variant_arg_path: Vec<_> =
cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_enum_variant_arg]); cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_enum_variant_arg]);
@ -141,7 +141,7 @@ fn decodable_substructure(
cx.expr_call_global( cx.expr_call_global(
span, span,
fn_read_enum_variant_arg_path.clone(), fn_read_enum_variant_arg_path.clone(),
vec![blkdecoder.clone(), idx, exprdecode.clone()], thin_vec![blkdecoder.clone(), idx, exprdecode.clone()],
), ),
) )
}); });
@ -162,7 +162,7 @@ fn decodable_substructure(
let result = cx.expr_call_global( let result = cx.expr_call_global(
trait_span, trait_span,
fn_read_enum_variant_path, fn_read_enum_variant_path,
vec![blkdecoder, variant_array_ref, lambda], thin_vec![blkdecoder, variant_array_ref, lambda],
); );
let fn_read_enum_path: Vec<_> = let fn_read_enum_path: Vec<_> =
cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_enum]); cx.def_site_path(&[sym::rustc_serialize, sym::Decoder, sym::read_enum]);
@ -170,7 +170,7 @@ fn decodable_substructure(
cx.expr_call_global( cx.expr_call_global(
trait_span, trait_span,
fn_read_enum_path, fn_read_enum_path,
vec![ thin_vec![
decoder, decoder,
cx.expr_str(trait_span, substr.type_ident.name), cx.expr_str(trait_span, substr.type_ident.name),
cx.lambda1(trait_span, result, blkarg), cx.lambda1(trait_span, result, blkarg),

4
compiler/rustc_builtin_macros/src/deriving/default.rs
View File

@ -8,7 +8,7 @@ use rustc_span::symbol::Ident;
use rustc_span::symbol::{kw, sym}; use rustc_span::symbol::{kw, sym};
use rustc_span::Span; use rustc_span::Span;
use smallvec::SmallVec; use smallvec::SmallVec;
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_default( pub fn expand_deriving_default(
cx: &mut ExtCtxt<'_>, cx: &mut ExtCtxt<'_>,
@ -60,7 +60,7 @@ fn default_struct_substructure(
) -> BlockOrExpr { ) -> BlockOrExpr {
// Note that `kw::Default` is "default" and `sym::Default` is "Default"! // Note that `kw::Default` is "default" and `sym::Default` is "Default"!
let default_ident = cx.std_path(&[kw::Default, sym::Default, kw::Default]); let default_ident = cx.std_path(&[kw::Default, sym::Default, kw::Default]);
let default_call = |span| cx.expr_call_global(span, default_ident.clone(), Vec::new()); let default_call = |span| cx.expr_call_global(span, default_ident.clone(), ThinVec::new());
let expr = match summary { let expr = match summary {
Unnamed(_, false) => cx.expr_ident(trait_span, substr.type_ident), Unnamed(_, false) => cx.expr_ident(trait_span, substr.type_ident),

26
compiler/rustc_builtin_macros/src/deriving/encodable.rs
View File

@ -88,11 +88,11 @@
use crate::deriving::generic::ty::*; use crate::deriving::generic::ty::*;
use crate::deriving::generic::*; use crate::deriving::generic::*;
use crate::deriving::pathvec_std; use crate::deriving::pathvec_std;
use rustc_ast::{AttrVec, ExprKind, MetaItem, Mutability}; use rustc_ast::{AttrVec, ExprKind, MetaItem, Mutability};
use rustc_expand::base::{Annotatable, ExtCtxt}; use rustc_expand::base::{Annotatable, ExtCtxt};
use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::Span; use rustc_span::Span;
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_rustc_encodable( pub fn expand_deriving_rustc_encodable(
cx: &mut ExtCtxt<'_>, cx: &mut ExtCtxt<'_>,
@ -176,12 +176,13 @@ fn encodable_substructure(
None => Symbol::intern(&format!("_field{}", i)), None => Symbol::intern(&format!("_field{}", i)),
}; };
let self_ref = cx.expr_addr_of(span, self_expr.clone()); let self_ref = cx.expr_addr_of(span, self_expr.clone());
let enc = cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]); let enc =
cx.expr_call(span, fn_path.clone(), thin_vec![self_ref, blkencoder.clone()]);
let lambda = cx.lambda1(span, enc, blkarg); let lambda = cx.lambda1(span, enc, blkarg);
let call = cx.expr_call_global( let call = cx.expr_call_global(
span, span,
fn_emit_struct_field_path.clone(), fn_emit_struct_field_path.clone(),
vec![ thin_vec![
blkencoder.clone(), blkencoder.clone(),
cx.expr_str(span, name), cx.expr_str(span, name),
cx.expr_usize(span, i), cx.expr_usize(span, i),
@ -203,7 +204,7 @@ fn encodable_substructure(
// unit structs have no fields and need to return Ok() // unit structs have no fields and need to return Ok()
let blk = if stmts.is_empty() { let blk = if stmts.is_empty() {
let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![])); let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, ThinVec::new()));
cx.lambda1(trait_span, ok, blkarg) cx.lambda1(trait_span, ok, blkarg)
} else { } else {
cx.lambda_stmts_1(trait_span, stmts, blkarg) cx.lambda_stmts_1(trait_span, stmts, blkarg)
@ -215,7 +216,7 @@ fn encodable_substructure(
let expr = cx.expr_call_global( let expr = cx.expr_call_global(
trait_span, trait_span,
fn_emit_struct_path, fn_emit_struct_path,
vec![ thin_vec![
encoder, encoder,
cx.expr_str(trait_span, substr.type_ident.name), cx.expr_str(trait_span, substr.type_ident.name),
cx.expr_usize(trait_span, fields.len()), cx.expr_usize(trait_span, fields.len()),
@ -241,14 +242,17 @@ fn encodable_substructure(
let last = fields.len() - 1; let last = fields.len() - 1;
for (i, &FieldInfo { ref self_expr, span, .. }) in fields.iter().enumerate() { for (i, &FieldInfo { ref self_expr, span, .. }) in fields.iter().enumerate() {
let self_ref = cx.expr_addr_of(span, self_expr.clone()); let self_ref = cx.expr_addr_of(span, self_expr.clone());
let enc = let enc = cx.expr_call(
cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]); span,
fn_path.clone(),
thin_vec![self_ref, blkencoder.clone()],
);
let lambda = cx.lambda1(span, enc, blkarg); let lambda = cx.lambda1(span, enc, blkarg);
let call = cx.expr_call_global( let call = cx.expr_call_global(
span, span,
fn_emit_enum_variant_arg_path.clone(), fn_emit_enum_variant_arg_path.clone(),
vec![blkencoder.clone(), cx.expr_usize(span, i), lambda], thin_vec![blkencoder.clone(), cx.expr_usize(span, i), lambda],
); );
let call = if i != last { let call = if i != last {
cx.expr_try(span, call) cx.expr_try(span, call)
@ -258,7 +262,7 @@ fn encodable_substructure(
stmts.push(cx.stmt_expr(call)); stmts.push(cx.stmt_expr(call));
} }
} else { } else {
let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![])); let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, ThinVec::new()));
let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok))); let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
stmts.push(cx.stmt_expr(ret_ok)); stmts.push(cx.stmt_expr(ret_ok));
} }
@ -272,7 +276,7 @@ fn encodable_substructure(
let call = cx.expr_call_global( let call = cx.expr_call_global(
trait_span, trait_span,
fn_emit_enum_variant_path, fn_emit_enum_variant_path,
vec![ thin_vec![
blkencoder, blkencoder,
name, name,
cx.expr_usize(trait_span, *idx), cx.expr_usize(trait_span, *idx),
@ -287,7 +291,7 @@ fn encodable_substructure(
let expr = cx.expr_call_global( let expr = cx.expr_call_global(
trait_span, trait_span,
fn_emit_enum_path, fn_emit_enum_path,
vec![encoder, cx.expr_str(trait_span, substr.type_ident.name), blk], thin_vec![encoder, cx.expr_str(trait_span, substr.type_ident.name), blk],
); );
BlockOrExpr::new_mixed(vec![me], Some(expr)) BlockOrExpr::new_mixed(vec![me], Some(expr))
} }

14
compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
View File

@ -935,8 +935,8 @@ impl<'a> MethodDef<'a> {
trait_: &TraitDef<'_>, trait_: &TraitDef<'_>,
type_ident: Ident, type_ident: Ident,
generics: &Generics, generics: &Generics,
) -> (Option<ast::ExplicitSelf>, Vec<P<Expr>>, Vec<P<Expr>>, Vec<(Ident, P<ast::Ty>)>) { ) -> (Option<ast::ExplicitSelf>, ThinVec<P<Expr>>, Vec<P<Expr>>, Vec<(Ident, P<ast::Ty>)>) {
let mut selflike_args = Vec::new(); let mut selflike_args = ThinVec::new();
let mut nonselflike_args = Vec::new(); let mut nonselflike_args = Vec::new();
let mut nonself_arg_tys = Vec::new(); let mut nonself_arg_tys = Vec::new();
let span = trait_.span; let span = trait_.span;
@ -1133,7 +1133,7 @@ impl<'a> MethodDef<'a> {
trait_: &TraitDef<'b>, trait_: &TraitDef<'b>,
enum_def: &'b EnumDef, enum_def: &'b EnumDef,
type_ident: Ident, type_ident: Ident,
selflike_args: Vec<P<Expr>>, selflike_args: ThinVec<P<Expr>>,
nonselflike_args: &[P<Expr>], nonselflike_args: &[P<Expr>],
) -> BlockOrExpr { ) -> BlockOrExpr {
let span = trait_.span; let span = trait_.span;
@ -1188,7 +1188,7 @@ impl<'a> MethodDef<'a> {
cx, cx,
span, span,
sym::discriminant_value, sym::discriminant_value,
vec![selflike_arg.clone()], thin_vec![selflike_arg.clone()],
); );
cx.stmt_let(span, false, ident, variant_value) cx.stmt_let(span, false, ident, variant_value)
}) })
@ -1260,7 +1260,7 @@ impl<'a> MethodDef<'a> {
let sp = variant.span.with_ctxt(trait_.span.ctxt()); let sp = variant.span.with_ctxt(trait_.span.ctxt());
let variant_path = cx.path(sp, vec![type_ident, variant.ident]); let variant_path = cx.path(sp, vec![type_ident, variant.ident]);
let by_ref = ByRef::No; // because enums can't be repr(packed) let by_ref = ByRef::No; // because enums can't be repr(packed)
let mut subpats: Vec<_> = trait_.create_struct_patterns( let mut subpats = trait_.create_struct_patterns(
cx, cx,
variant_path, variant_path,
&variant.data, &variant.data,
@ -1336,7 +1336,7 @@ impl<'a> MethodDef<'a> {
// ... // ...
// _ => ::core::intrinsics::unreachable() // _ => ::core::intrinsics::unreachable()
// } // }
let get_match_expr = |mut selflike_args: Vec<P<Expr>>| { let get_match_expr = |mut selflike_args: ThinVec<P<Expr>>| {
let match_arg = if selflike_args.len() == 1 { let match_arg = if selflike_args.len() == 1 {
selflike_args.pop().unwrap() selflike_args.pop().unwrap()
} else { } else {
@ -1427,7 +1427,7 @@ impl<'a> TraitDef<'a> {
struct_def: &'a VariantData, struct_def: &'a VariantData,
prefixes: &[String], prefixes: &[String],
by_ref: ByRef, by_ref: ByRef,
) -> Vec<P<ast::Pat>> { ) -> ThinVec<P<ast::Pat>> {
prefixes prefixes
.iter() .iter()
.map(|prefix| { .map(|prefix| {

2
compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
View File

@ -103,7 +103,7 @@ impl Ty {
Path(p) => p.to_ty(cx, span, self_ty, self_generics), Path(p) => p.to_ty(cx, span, self_ty, self_generics),
Self_ => cx.ty_path(self.to_path(cx, span, self_ty, self_generics)), Self_ => cx.ty_path(self.to_path(cx, span, self_ty, self_generics)),
Unit => { Unit => {
let ty = ast::TyKind::Tup(vec![]); let ty = ast::TyKind::Tup(ThinVec::new());
cx.ty(span, ty) cx.ty(span, ty)
} }
} }

4
compiler/rustc_builtin_macros/src/deriving/hash.rs
View File

@ -1,11 +1,11 @@
use crate::deriving::generic::ty::*; use crate::deriving::generic::ty::*;
use crate::deriving::generic::*; use crate::deriving::generic::*;
use crate::deriving::{path_std, pathvec_std}; use crate::deriving::{path_std, pathvec_std};
use rustc_ast::{AttrVec, MetaItem, Mutability}; use rustc_ast::{AttrVec, MetaItem, Mutability};
use rustc_expand::base::{Annotatable, ExtCtxt}; use rustc_expand::base::{Annotatable, ExtCtxt};
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
use rustc_span::Span; use rustc_span::Span;
use thin_vec::thin_vec;
pub fn expand_deriving_hash( pub fn expand_deriving_hash(
cx: &mut ExtCtxt<'_>, cx: &mut ExtCtxt<'_>,
@ -60,7 +60,7 @@ fn hash_substructure(
cx.expr_path(cx.path_global(span, strs)) cx.expr_path(cx.path_global(span, strs))
}; };
let expr = cx.expr_call(span, hash_path, vec![expr, state_expr.clone()]); let expr = cx.expr_call(span, hash_path, thin_vec![expr, state_expr.clone()]);
cx.stmt_expr(expr) cx.stmt_expr(expr)
}; };

4
compiler/rustc_builtin_macros/src/deriving/mod.rs
View File

@ -93,7 +93,7 @@ fn call_intrinsic(
cx: &ExtCtxt<'_>, cx: &ExtCtxt<'_>,
span: Span, span: Span,
intrinsic: Symbol, intrinsic: Symbol,
args: Vec<P<ast::Expr>>, args: ThinVec<P<ast::Expr>>,
) -> P<ast::Expr> { ) -> P<ast::Expr> {
let span = cx.with_def_site_ctxt(span); let span = cx.with_def_site_ctxt(span);
let path = cx.std_path(&[sym::intrinsics, intrinsic]); let path = cx.std_path(&[sym::intrinsics, intrinsic]);
@ -104,7 +104,7 @@ fn call_intrinsic(
fn call_unreachable(cx: &ExtCtxt<'_>, span: Span) -> P<ast::Expr> { fn call_unreachable(cx: &ExtCtxt<'_>, span: Span) -> P<ast::Expr> {
let span = cx.with_def_site_ctxt(span); let span = cx.with_def_site_ctxt(span);
let path = cx.std_path(&[sym::intrinsics, sym::unreachable]); let path = cx.std_path(&[sym::intrinsics, sym::unreachable]);
let call = cx.expr_call_global(span, path, vec![]); let call = cx.expr_call_global(span, path, ThinVec::new());
cx.expr_block(P(ast::Block { cx.expr_block(P(ast::Block {
stmts: vec![cx.stmt_expr(call)], stmts: vec![cx.stmt_expr(call)],

4
compiler/rustc_builtin_macros/src/env.rs
View File

@ -8,8 +8,8 @@ use rustc_ast::{self as ast, GenericArg};
use rustc_expand::base::{self, *}; use rustc_expand::base::{self, *};
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::Span; use rustc_span::Span;
use std::env; use std::env;
use thin_vec::thin_vec;
pub fn expand_option_env<'cx>( pub fn expand_option_env<'cx>(
cx: &'cx mut ExtCtxt<'_>, cx: &'cx mut ExtCtxt<'_>,
@ -41,7 +41,7 @@ pub fn expand_option_env<'cx>(
Some(value) => cx.expr_call_global( Some(value) => cx.expr_call_global(
sp, sp,
cx.std_path(&[sym::option, sym::Option, sym::Some]), cx.std_path(&[sym::option, sym::Option, sym::Some]),
vec![cx.expr_str(sp, value)], thin_vec![cx.expr_str(sp, value)],
), ),
}; };
MacEager::expr(e) MacEager::expr(e)

14
compiler/rustc_builtin_macros/src/global_allocator.rs
View File

@ -9,7 +9,7 @@ use rustc_ast::{Fn, ItemKind, Mutability, Stmt, Ty, TyKind, Unsafe};
use rustc_expand::base::{Annotatable, ExtCtxt}; use rustc_expand::base::{Annotatable, ExtCtxt};
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::Span; use rustc_span::Span;
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
pub fn expand( pub fn expand(
ecx: &mut ExtCtxt<'_>, ecx: &mut ExtCtxt<'_>,
@ -47,7 +47,7 @@ pub fn expand(
let stmts = ALLOCATOR_METHODS.iter().map(|method| f.allocator_fn(method)).collect(); let stmts = ALLOCATOR_METHODS.iter().map(|method| f.allocator_fn(method)).collect();
// Generate anonymous constant serving as container for the allocator methods. // Generate anonymous constant serving as container for the allocator methods.
let const_ty = ecx.ty(ty_span, TyKind::Tup(Vec::new())); let const_ty = ecx.ty(ty_span, TyKind::Tup(ThinVec::new()));
let const_body = ecx.expr_block(ecx.block(span, stmts)); let const_body = ecx.expr_block(ecx.block(span, stmts));
let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body); let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
let const_item = if is_stmt { let const_item = if is_stmt {
@ -70,7 +70,7 @@ struct AllocFnFactory<'a, 'b> {
impl AllocFnFactory<'_, '_> { impl AllocFnFactory<'_, '_> {
fn allocator_fn(&self, method: &AllocatorMethod) -> Stmt { fn allocator_fn(&self, method: &AllocatorMethod) -> Stmt {
let mut abi_args = Vec::new(); let mut abi_args = ThinVec::new();
let mut i = 0; let mut i = 0;
let mut mk = || { let mut mk = || {
let name = Ident::from_str_and_span(&format!("arg{}", i), self.span); let name = Ident::from_str_and_span(&format!("arg{}", i), self.span);
@ -99,7 +99,7 @@ impl AllocFnFactory<'_, '_> {
self.cx.stmt_item(self.ty_span, item) self.cx.stmt_item(self.ty_span, item)
} }
fn call_allocator(&self, method: Symbol, mut args: Vec<P<Expr>>) -> P<Expr> { fn call_allocator(&self, method: Symbol, mut args: ThinVec<P<Expr>>) -> P<Expr> {
let method = self.cx.std_path(&[sym::alloc, sym::GlobalAlloc, method]); let method = self.cx.std_path(&[sym::alloc, sym::GlobalAlloc, method]);
let method = self.cx.expr_path(self.cx.path(self.ty_span, method)); let method = self.cx.expr_path(self.cx.path(self.ty_span, method));
let allocator = self.cx.path_ident(self.ty_span, self.global); let allocator = self.cx.path_ident(self.ty_span, self.global);
@ -117,7 +117,7 @@ impl AllocFnFactory<'_, '_> {
fn arg_ty( fn arg_ty(
&self, &self,
ty: &AllocatorTy, ty: &AllocatorTy,
args: &mut Vec<Param>, args: &mut ThinVec<Param>,
ident: &mut dyn FnMut() -> Ident, ident: &mut dyn FnMut() -> Ident,
) -> P<Expr> { ) -> P<Expr> {
match *ty { match *ty {
@ -134,7 +134,7 @@ impl AllocFnFactory<'_, '_> {
let layout_new = self.cx.expr_path(self.cx.path(self.span, layout_new)); let layout_new = self.cx.expr_path(self.cx.path(self.span, layout_new));
let size = self.cx.expr_ident(self.span, size); let size = self.cx.expr_ident(self.span, size);
let align = self.cx.expr_ident(self.span, align); let align = self.cx.expr_ident(self.span, align);
let layout = self.cx.expr_call(self.span, layout_new, vec![size, align]); let layout = self.cx.expr_call(self.span, layout_new, thin_vec![size, align]);
layout layout
} }
@ -168,7 +168,7 @@ impl AllocFnFactory<'_, '_> {
(self.ptr_u8(), expr) (self.ptr_u8(), expr)
} }
AllocatorTy::Unit => (self.cx.ty(self.span, TyKind::Tup(Vec::new())), expr), AllocatorTy::Unit => (self.cx.ty(self.span, TyKind::Tup(ThinVec::new())), expr),
AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => { AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
panic!("can't convert `AllocatorTy` to an output") panic!("can't convert `AllocatorTy` to an output")

12
compiler/rustc_builtin_macros/src/proc_macro_harness.rs
View File

@ -11,6 +11,7 @@ use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP}; use rustc_span::{Span, DUMMY_SP};
use smallvec::smallvec; use smallvec::smallvec;
use std::mem; use std::mem;
use thin_vec::{thin_vec, ThinVec};
struct ProcMacroDerive { struct ProcMacroDerive {
id: NodeId, id: NodeId,
@ -314,11 +315,14 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> P<ast::Item> {
cx.expr_call( cx.expr_call(
span, span,
proc_macro_ty_method_path(cx, custom_derive), proc_macro_ty_method_path(cx, custom_derive),
vec![ thin_vec![
cx.expr_str(span, cd.trait_name), cx.expr_str(span, cd.trait_name),
cx.expr_array_ref( cx.expr_array_ref(
span, span,
cd.attrs.iter().map(|&s| cx.expr_str(span, s)).collect::<Vec<_>>(), cd.attrs
.iter()
.map(|&s| cx.expr_str(span, s))
.collect::<ThinVec<_>>(),
), ),
local_path(cx, cd.function_name), local_path(cx, cd.function_name),
], ],
@ -335,7 +339,7 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> P<ast::Item> {
cx.expr_call( cx.expr_call(
span, span,
proc_macro_ty_method_path(cx, ident), proc_macro_ty_method_path(cx, ident),
vec![ thin_vec![
cx.expr_str(span, ca.function_name.name), cx.expr_str(span, ca.function_name.name),
local_path(cx, ca.function_name), local_path(cx, ca.function_name),
], ],
@ -377,7 +381,7 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> P<ast::Item> {
let anon_constant = cx.item_const( let anon_constant = cx.item_const(
span, span,
Ident::new(kw::Underscore, span), Ident::new(kw::Underscore, span),
cx.ty(span, ast::TyKind::Tup(Vec::new())), cx.ty(span, ast::TyKind::Tup(ThinVec::new())),
block, block,
); );

18
compiler/rustc_builtin_macros/src/test.rs
View File

@ -10,7 +10,7 @@ use rustc_session::Session;
use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::Span; use rustc_span::Span;
use std::iter; use std::iter;
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
/// #[test_case] is used by custom test authors to mark tests /// #[test_case] is used by custom test authors to mark tests
/// When building for test, it needs to make the item public and gensym the name /// When building for test, it needs to make the item public and gensym the name
@ -179,19 +179,19 @@ pub fn expand_test_or_bench(
cx.expr_call( cx.expr_call(
sp, sp,
cx.expr_path(test_path("StaticBenchFn")), cx.expr_path(test_path("StaticBenchFn")),
vec![ thin_vec![
// |b| self::test::assert_test_result( // |b| self::test::assert_test_result(
cx.lambda1( cx.lambda1(
sp, sp,
cx.expr_call( cx.expr_call(
sp, sp,
cx.expr_path(test_path("assert_test_result")), cx.expr_path(test_path("assert_test_result")),
vec![ thin_vec![
// super::$test_fn(b) // super::$test_fn(b)
cx.expr_call( cx.expr_call(
ret_ty_sp, ret_ty_sp,
cx.expr_path(cx.path(sp, vec![item.ident])), cx.expr_path(cx.path(sp, vec![item.ident])),
vec![cx.expr_ident(sp, b)], thin_vec![cx.expr_ident(sp, b)],
), ),
], ],
), ),
@ -203,7 +203,7 @@ pub fn expand_test_or_bench(
cx.expr_call( cx.expr_call(
sp, sp,
cx.expr_path(test_path("StaticTestFn")), cx.expr_path(test_path("StaticTestFn")),
vec![ thin_vec![
// || { // || {
cx.lambda0( cx.lambda0(
sp, sp,
@ -211,12 +211,12 @@ pub fn expand_test_or_bench(
cx.expr_call( cx.expr_call(
sp, sp,
cx.expr_path(test_path("assert_test_result")), cx.expr_path(test_path("assert_test_result")),
vec![ thin_vec![
// $test_fn() // $test_fn()
cx.expr_call( cx.expr_call(
ret_ty_sp, ret_ty_sp,
cx.expr_path(cx.path(sp, vec![item.ident])), cx.expr_path(cx.path(sp, vec![item.ident])),
vec![], ThinVec::new(),
), // ) ), // )
], ],
), // } ), // }
@ -263,7 +263,7 @@ pub fn expand_test_or_bench(
cx.expr_call( cx.expr_call(
sp, sp,
cx.expr_path(test_path("StaticTestName")), cx.expr_path(test_path("StaticTestName")),
vec![cx.expr_str(sp, test_path_symbol)], thin_vec![cx.expr_str(sp, test_path_symbol)],
), ),
), ),
// ignore: true | false // ignore: true | false
@ -300,7 +300,7 @@ pub fn expand_test_or_bench(
ShouldPanic::Yes(Some(sym)) => cx.expr_call( ShouldPanic::Yes(Some(sym)) => cx.expr_call(
sp, sp,
cx.expr_path(should_panic_path("YesWithMessage")), cx.expr_path(should_panic_path("YesWithMessage")),
vec![cx.expr_str(sp, sym)], thin_vec![cx.expr_str(sp, sym)],
), ),
}, },
), ),

9
compiler/rustc_builtin_macros/src/test_harness.rs
View File

@ -14,7 +14,8 @@ use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP}; use rustc_span::{Span, DUMMY_SP};
use rustc_target::spec::PanicStrategy; use rustc_target::spec::PanicStrategy;
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
use thin_vec::thin_vec; use thin_vec::{thin_vec, ThinVec};
use tracing::debug;
use std::{iter, mem}; use std::{iter, mem};
@ -299,7 +300,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
test_runner.span = sp; test_runner.span = sp;
let test_main_path_expr = ecx.expr_path(test_runner); let test_main_path_expr = ecx.expr_path(test_runner);
let call_test_main = ecx.expr_call(sp, test_main_path_expr, vec![mk_tests_slice(cx, sp)]); let call_test_main = ecx.expr_call(sp, test_main_path_expr, thin_vec![mk_tests_slice(cx, sp)]);
let call_test_main = ecx.stmt_expr(call_test_main); let call_test_main = ecx.stmt_expr(call_test_main);
// extern crate test // extern crate test
@ -312,7 +313,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
let main_attr = ecx.attr_word(sym::rustc_main, sp); let main_attr = ecx.attr_word(sym::rustc_main, sp);
// pub fn main() { ... } // pub fn main() { ... }
let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(vec![])); let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(ThinVec::new()));
// If no test runner is provided we need to import the test crate // If no test runner is provided we need to import the test crate
let main_body = if cx.test_runner.is_none() { let main_body = if cx.test_runner.is_none() {
@ -321,7 +322,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
ecx.block(sp, vec![call_test_main]) ecx.block(sp, vec![call_test_main])
}; };
let decl = ecx.fn_decl(vec![], ast::FnRetTy::Ty(main_ret_ty)); let decl = ecx.fn_decl(ThinVec::new(), ast::FnRetTy::Ty(main_ret_ty));
let sig = ast::FnSig { decl, header: ast::FnHeader::default(), span: sp }; let sig = ast::FnSig { decl, header: ast::FnHeader::default(), span: sp };
let defaultness = ast::Defaultness::Final; let defaultness = ast::Defaultness::Final;
let main = ast::ItemKind::Fn(Box::new(ast::Fn { let main = ast::ItemKind::Fn(Box::new(ast::Fn {

7
compiler/rustc_expand/src/base.rs
View File

@ -29,10 +29,11 @@ use rustc_span::source_map::SourceMap;
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{BytePos, FileName, Span, DUMMY_SP}; use rustc_span::{BytePos, FileName, Span, DUMMY_SP};
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
use std::default::Default;
use std::iter; use std::iter;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::rc::Rc; use std::rc::Rc;
use thin_vec::ThinVec;
pub(crate) use rustc_span::hygiene::MacroKind; pub(crate) use rustc_span::hygiene::MacroKind;
@ -554,7 +555,7 @@ impl DummyResult {
pub fn raw_expr(sp: Span, is_error: bool) -> P<ast::Expr> { pub fn raw_expr(sp: Span, is_error: bool) -> P<ast::Expr> {
P(ast::Expr { P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
kind: if is_error { ast::ExprKind::Err } else { ast::ExprKind::Tup(Vec::new()) }, kind: if is_error { ast::ExprKind::Err } else { ast::ExprKind::Tup(ThinVec::new()) },
span: sp, span: sp,
attrs: ast::AttrVec::new(), attrs: ast::AttrVec::new(),
tokens: None, tokens: None,
@ -570,7 +571,7 @@ impl DummyResult {
pub fn raw_ty(sp: Span, is_error: bool) -> P<ast::Ty> { pub fn raw_ty(sp: Span, is_error: bool) -> P<ast::Ty> {
P(ast::Ty { P(ast::Ty {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
kind: if is_error { ast::TyKind::Err } else { ast::TyKind::Tup(Vec::new()) }, kind: if is_error { ast::TyKind::Err } else { ast::TyKind::Tup(ThinVec::new()) },
span: sp, span: sp,
tokens: None, tokens: None,
}) })

39
compiler/rustc_expand/src/build.rs
View File

@ -5,7 +5,7 @@ use rustc_ast::{attr, token, util::literal};
use rustc_span::source_map::Spanned; use rustc_span::source_map::Spanned;
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::Span; use rustc_span::Span;
use thin_vec::ThinVec; use thin_vec::{thin_vec, ThinVec};
impl<'a> ExtCtxt<'a> { impl<'a> ExtCtxt<'a> {
pub fn path(&self, span: Span, strs: Vec<Ident>) -> ast::Path { pub fn path(&self, span: Span, strs: Vec<Ident>) -> ast::Path {
@ -284,18 +284,23 @@ impl<'a> ExtCtxt<'a> {
&self, &self,
span: Span, span: Span,
expr: P<ast::Expr>, expr: P<ast::Expr>,
args: Vec<P<ast::Expr>>, args: ThinVec<P<ast::Expr>>,
) -> P<ast::Expr> { ) -> P<ast::Expr> {
self.expr(span, ast::ExprKind::Call(expr, args)) self.expr(span, ast::ExprKind::Call(expr, args))
} }
pub fn expr_call_ident(&self, span: Span, id: Ident, args: Vec<P<ast::Expr>>) -> P<ast::Expr> { pub fn expr_call_ident(
&self,
span: Span,
id: Ident,
args: ThinVec<P<ast::Expr>>,
) -> P<ast::Expr> {
self.expr(span, ast::ExprKind::Call(self.expr_ident(span, id), args)) self.expr(span, ast::ExprKind::Call(self.expr_ident(span, id), args))
} }
pub fn expr_call_global( pub fn expr_call_global(
&self, &self,
sp: Span, sp: Span,
fn_path: Vec<Ident>, fn_path: Vec<Ident>,
args: Vec<P<ast::Expr>>, args: ThinVec<P<ast::Expr>>,
) -> P<ast::Expr> { ) -> P<ast::Expr> {
let pathexpr = self.expr_path(self.path_global(sp, fn_path)); let pathexpr = self.expr_path(self.path_global(sp, fn_path));
self.expr_call(sp, pathexpr, args) self.expr_call(sp, pathexpr, args)
@ -372,12 +377,12 @@ impl<'a> ExtCtxt<'a> {
} }
/// `[expr1, expr2, ...]` /// `[expr1, expr2, ...]`
pub fn expr_array(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> { pub fn expr_array(&self, sp: Span, exprs: ThinVec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr(sp, ast::ExprKind::Array(exprs)) self.expr(sp, ast::ExprKind::Array(exprs))
} }
/// `&[expr1, expr2, ...]` /// `&[expr1, expr2, ...]`
pub fn expr_array_ref(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> { pub fn expr_array_ref(&self, sp: Span, exprs: ThinVec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr_addr_of(sp, self.expr_array(sp, exprs)) self.expr_addr_of(sp, self.expr_array(sp, exprs))
} }
@ -387,14 +392,14 @@ impl<'a> ExtCtxt<'a> {
pub fn expr_some(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> { pub fn expr_some(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
let some = self.std_path(&[sym::option, sym::Option, sym::Some]); let some = self.std_path(&[sym::option, sym::Option, sym::Some]);
self.expr_call_global(sp, some, vec![expr]) self.expr_call_global(sp, some, thin_vec![expr])
} }
pub fn expr_none(&self, sp: Span) -> P<ast::Expr> { pub fn expr_none(&self, sp: Span) -> P<ast::Expr> {
let none = self.std_path(&[sym::option, sym::Option, sym::None]); let none = self.std_path(&[sym::option, sym::Option, sym::None]);
self.expr_path(self.path_global(sp, none)) self.expr_path(self.path_global(sp, none))
} }
pub fn expr_tuple(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> { pub fn expr_tuple(&self, sp: Span, exprs: ThinVec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr(sp, ast::ExprKind::Tup(exprs)) self.expr(sp, ast::ExprKind::Tup(exprs))
} }
@ -402,7 +407,7 @@ impl<'a> ExtCtxt<'a> {
self.expr_call_global( self.expr_call_global(
span, span,
[sym::std, sym::rt, sym::begin_panic].iter().map(|s| Ident::new(*s, span)).collect(), [sym::std, sym::rt, sym::begin_panic].iter().map(|s| Ident::new(*s, span)).collect(),
vec![self.expr_str(span, msg)], thin_vec![self.expr_str(span, msg)],
) )
} }
@ -412,7 +417,7 @@ impl<'a> ExtCtxt<'a> {
pub fn expr_ok(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> { pub fn expr_ok(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
let ok = self.std_path(&[sym::result, sym::Result, sym::Ok]); let ok = self.std_path(&[sym::result, sym::Result, sym::Ok]);
self.expr_call_global(sp, ok, vec![expr]) self.expr_call_global(sp, ok, thin_vec![expr])
} }
pub fn expr_try(&self, sp: Span, head: P<ast::Expr>) -> P<ast::Expr> { pub fn expr_try(&self, sp: Span, head: P<ast::Expr>) -> P<ast::Expr> {
@ -426,12 +431,12 @@ impl<'a> ExtCtxt<'a> {
let binding_expr = self.expr_ident(sp, binding_variable); let binding_expr = self.expr_ident(sp, binding_variable);
// `Ok(__try_var)` pattern // `Ok(__try_var)` pattern
let ok_pat = self.pat_tuple_struct(sp, ok_path, vec![binding_pat.clone()]); let ok_pat = self.pat_tuple_struct(sp, ok_path, thin_vec![binding_pat.clone()]);
// `Err(__try_var)` (pattern and expression respectively) // `Err(__try_var)` (pattern and expression respectively)
let err_pat = self.pat_tuple_struct(sp, err_path.clone(), vec![binding_pat]); let err_pat = self.pat_tuple_struct(sp, err_path.clone(), thin_vec![binding_pat]);
let err_inner_expr = let err_inner_expr =
self.expr_call(sp, self.expr_path(err_path), vec![binding_expr.clone()]); self.expr_call(sp, self.expr_path(err_path), thin_vec![binding_expr.clone()]);
// `return Err(__try_var)` // `return Err(__try_var)`
let err_expr = self.expr(sp, ast::ExprKind::Ret(Some(err_inner_expr))); let err_expr = self.expr(sp, ast::ExprKind::Ret(Some(err_inner_expr)));
@ -473,7 +478,7 @@ impl<'a> ExtCtxt<'a> {
&self, &self,
span: Span, span: Span,
path: ast::Path, path: ast::Path,
subpats: Vec<P<ast::Pat>>, subpats: ThinVec<P<ast::Pat>>,
) -> P<ast::Pat> { ) -> P<ast::Pat> {
self.pat(span, PatKind::TupleStruct(None, path, subpats)) self.pat(span, PatKind::TupleStruct(None, path, subpats))
} }
@ -485,14 +490,14 @@ impl<'a> ExtCtxt<'a> {
) -> P<ast::Pat> { ) -> P<ast::Pat> {
self.pat(span, PatKind::Struct(None, path, field_pats, false)) self.pat(span, PatKind::Struct(None, path, field_pats, false))
} }
pub fn pat_tuple(&self, span: Span, pats: Vec<P<ast::Pat>>) -> P<ast::Pat> { pub fn pat_tuple(&self, span: Span, pats: ThinVec<P<ast::Pat>>) -> P<ast::Pat> {
self.pat(span, PatKind::Tuple(pats)) self.pat(span, PatKind::Tuple(pats))
} }
pub fn pat_some(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> { pub fn pat_some(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
let some = self.std_path(&[sym::option, sym::Option, sym::Some]); let some = self.std_path(&[sym::option, sym::Option, sym::Some]);
let path = self.path_global(span, some); let path = self.path_global(span, some);
self.pat_tuple_struct(span, path, vec![pat]) self.pat_tuple_struct(span, path, thin_vec![pat])
} }
pub fn arm(&self, span: Span, pat: P<ast::Pat>, expr: P<ast::Expr>) -> ast::Arm { pub fn arm(&self, span: Span, pat: P<ast::Pat>, expr: P<ast::Expr>) -> ast::Arm {
@ -579,7 +584,7 @@ impl<'a> ExtCtxt<'a> {
} }
// `self` is unused but keep it as method for the convenience use. // `self` is unused but keep it as method for the convenience use.
pub fn fn_decl(&self, inputs: Vec<ast::Param>, output: ast::FnRetTy) -> P<ast::FnDecl> { pub fn fn_decl(&self, inputs: ThinVec<ast::Param>, output: ast::FnRetTy) -> P<ast::FnDecl> {
P(ast::FnDecl { inputs, output }) P(ast::FnDecl { inputs, output })
} }

3
compiler/rustc_hir_analysis/Cargo.toml
View File

@ -9,7 +9,6 @@ doctest = false
[dependencies] [dependencies]
rustc_arena = { path = "../rustc_arena" } rustc_arena = { path = "../rustc_arena" }
tracing = "0.1"
rustc_macros = { path = "../rustc_macros" } rustc_macros = { path = "../rustc_macros" }
rustc_middle = { path = "../rustc_middle" } rustc_middle = { path = "../rustc_middle" }
rustc_attr = { path = "../rustc_attr" } rustc_attr = { path = "../rustc_attr" }
@ -27,3 +26,5 @@ rustc_trait_selection = { path = "../rustc_trait_selection" }
rustc_lint = { path = "../rustc_lint" } rustc_lint = { path = "../rustc_lint" }
rustc_type_ir = { path = "../rustc_type_ir" } rustc_type_ir = { path = "../rustc_type_ir" }
rustc_feature = { path = "../rustc_feature" } rustc_feature = { path = "../rustc_feature" }
thin-vec = "0.2.12"
tracing = "0.1"

21
compiler/rustc_incremental/Cargo.toml
View File

@ -6,16 +6,17 @@ edition = "2021"
[lib] [lib]
[dependencies] [dependencies]
rustc_graphviz = { path = "../rustc_graphviz" }
tracing = "0.1"
rand = "0.8.4" rand = "0.8.4"
rustc_middle = { path = "../rustc_middle" }
rustc_data_structures = { path = "../rustc_data_structures" }
rustc_hir = { path = "../rustc_hir" }
rustc_serialize = { path = "../rustc_serialize" }
rustc_ast = { path = "../rustc_ast" } rustc_ast = { path = "../rustc_ast" }
rustc_macros = { path = "../rustc_macros" } rustc_data_structures = { path = "../rustc_data_structures" }
rustc_span = { path = "../rustc_span" }
rustc_fs_util = { path = "../rustc_fs_util" }
rustc_session = { path = "../rustc_session" }
rustc_errors = { path = "../rustc_errors" } rustc_errors = { path = "../rustc_errors" }
rustc_fs_util = { path = "../rustc_fs_util" }
rustc_graphviz = { path = "../rustc_graphviz" }
rustc_hir = { path = "../rustc_hir" }
rustc_macros = { path = "../rustc_macros" }
rustc_middle = { path = "../rustc_middle" }
rustc_serialize = { path = "../rustc_serialize" }
rustc_session = { path = "../rustc_session" }
rustc_span = { path = "../rustc_span" }
thin-vec = "0.2.12"
tracing = "0.1"

3
compiler/rustc_incremental/src/assert_module_sources.rs
View File

@ -30,6 +30,7 @@ use rustc_middle::mir::mono::CodegenUnitNameBuilder;
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use rustc_session::cgu_reuse_tracker::*; use rustc_session::cgu_reuse_tracker::*;
use rustc_span::symbol::{sym, Symbol}; use rustc_span::symbol::{sym, Symbol};
use thin_vec::ThinVec;
#[allow(missing_docs)] #[allow(missing_docs)]
pub fn assert_module_sources(tcx: TyCtxt<'_>) { pub fn assert_module_sources(tcx: TyCtxt<'_>) {
@ -138,7 +139,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
} }
fn field(&self, attr: &ast::Attribute, name: Symbol) -> Symbol { fn field(&self, attr: &ast::Attribute, name: Symbol) -> Symbol {
for item in attr.meta_item_list().unwrap_or_else(Vec::new) { for item in attr.meta_item_list().unwrap_or_else(ThinVec::new) {
if item.has_name(name) { if item.has_name(name) {
if let Some(value) = item.value_str() { if let Some(value) = item.value_str() {
return value; return value;

8
compiler/rustc_incremental/src/persist/dirty_clean.rs
View File

@ -31,6 +31,8 @@ use rustc_middle::hir::nested_filter;
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use rustc_span::symbol::{sym, Symbol}; use rustc_span::symbol::{sym, Symbol};
use rustc_span::Span; use rustc_span::Span;
use std::iter::FromIterator;
use thin_vec::ThinVec;
const LOADED_FROM_DISK: Symbol = sym::loaded_from_disk; const LOADED_FROM_DISK: Symbol = sym::loaded_from_disk;
const EXCEPT: Symbol = sym::except; const EXCEPT: Symbol = sym::except;
@ -205,7 +207,7 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
/// `loaded_from_disk=` attribute value /// `loaded_from_disk=` attribute value
fn loaded_from_disk(&self, attr: &Attribute) -> Labels { fn loaded_from_disk(&self, attr: &Attribute) -> Labels {
for item in attr.meta_item_list().unwrap_or_else(Vec::new) { for item in attr.meta_item_list().unwrap_or_else(ThinVec::new) {
if item.has_name(LOADED_FROM_DISK) { if item.has_name(LOADED_FROM_DISK) {
let value = expect_associated_value(self.tcx, &item); let value = expect_associated_value(self.tcx, &item);
return self.resolve_labels(&item, value); return self.resolve_labels(&item, value);
@ -217,7 +219,7 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
/// `except=` attribute value /// `except=` attribute value
fn except(&self, attr: &Attribute) -> Labels { fn except(&self, attr: &Attribute) -> Labels {
for item in attr.meta_item_list().unwrap_or_else(Vec::new) { for item in attr.meta_item_list().unwrap_or_else(ThinVec::new) {
if item.has_name(EXCEPT) { if item.has_name(EXCEPT) {
let value = expect_associated_value(self.tcx, &item); let value = expect_associated_value(self.tcx, &item);
return self.resolve_labels(&item, value); return self.resolve_labels(&item, value);
@ -397,7 +399,7 @@ fn check_config(tcx: TyCtxt<'_>, attr: &Attribute) -> bool {
let config = &tcx.sess.parse_sess.config; let config = &tcx.sess.parse_sess.config;
debug!("check_config: config={:?}", config); debug!("check_config: config={:?}", config);
let mut cfg = None; let mut cfg = None;
for item in attr.meta_item_list().unwrap_or_else(Vec::new) { for item in attr.meta_item_list().unwrap_or_else(ThinVec::new) {
if item.has_name(CFG) { if item.has_name(CFG) {
let value = expect_associated_value(tcx, &item); let value = expect_associated_value(tcx, &item);
debug!("check_config: searching for cfg {:?}", value); debug!("check_config: searching for cfg {:?}", value);

7
compiler/rustc_parse/src/parser/attr.rs
View File

@ -6,6 +6,9 @@ use rustc_ast::attr;
use rustc_ast::token::{self, Delimiter, Nonterminal}; use rustc_ast::token::{self, Delimiter, Nonterminal};
use rustc_errors::{error_code, fluent, Diagnostic, IntoDiagnostic, PResult}; use rustc_errors::{error_code, fluent, Diagnostic, IntoDiagnostic, PResult};
use rustc_span::{sym, BytePos, Span}; use rustc_span::{sym, BytePos, Span};
use std::convert::TryInto;
use thin_vec::ThinVec;
use tracing::debug;
// Public for rustfmt usage // Public for rustfmt usage
#[derive(Debug)] #[derive(Debug)]
@ -346,9 +349,9 @@ impl<'a> Parser<'a> {
} }
/// Matches `COMMASEP(meta_item_inner)`. /// Matches `COMMASEP(meta_item_inner)`.
pub(crate) fn parse_meta_seq_top(&mut self) -> PResult<'a, Vec<ast::NestedMetaItem>> { pub(crate) fn parse_meta_seq_top(&mut self) -> PResult<'a, ThinVec<ast::NestedMetaItem>> {
// Presumably, the majority of the time there will only be one attr. // Presumably, the majority of the time there will only be one attr.
let mut nmis = Vec::with_capacity(1); let mut nmis = ThinVec::with_capacity(1);
while self.token.kind != token::Eof { while self.token.kind != token::Eof {
nmis.push(self.parse_meta_item_inner()?); nmis.push(self.parse_meta_item_inner()?);
if !self.eat(&token::Comma) { if !self.eat(&token::Comma) {

2
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -2175,7 +2175,7 @@ impl<'a> Parser<'a> {
/// the parameters are *names* (so we don't emit errors about not being able to find `b` in /// the parameters are *names* (so we don't emit errors about not being able to find `b` in
/// the local scope), but if we find the same name multiple times, like in `fn foo(i8, i8)`, /// the local scope), but if we find the same name multiple times, like in `fn foo(i8, i8)`,
/// we deduplicate them to not complain about duplicated parameter names. /// we deduplicate them to not complain about duplicated parameter names.
pub(super) fn deduplicate_recovered_params_names(&self, fn_inputs: &mut Vec<Param>) { pub(super) fn deduplicate_recovered_params_names(&self, fn_inputs: &mut ThinVec<Param>) {
let mut seen_inputs = FxHashSet::default(); let mut seen_inputs = FxHashSet::default();
for input in fn_inputs.iter_mut() { for input in fn_inputs.iter_mut() {
let opt_ident = if let (PatKind::Ident(_, ident, _), TyKind::Err) = let opt_ident = if let (PatKind::Ident(_, ident, _), TyKind::Err) =

11
compiler/rustc_parse/src/parser/expr.rs
View File

@ -31,6 +31,7 @@ use rustc_session::lint::BuiltinLintDiagnostics;
use rustc_span::source_map::{self, Span, Spanned}; use rustc_span::source_map::{self, Span, Spanned};
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{BytePos, Pos}; use rustc_span::{BytePos, Pos};
use thin_vec::{thin_vec, ThinVec};
/// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression /// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression
/// dropped into the token stream, which happens while parsing the result of /// dropped into the token stream, which happens while parsing the result of
@ -124,7 +125,7 @@ impl<'a> Parser<'a> {
} }
/// Parses a sequence of expressions delimited by parentheses. /// Parses a sequence of expressions delimited by parentheses.
fn parse_paren_expr_seq(&mut self) -> PResult<'a, Vec<P<Expr>>> { fn parse_paren_expr_seq(&mut self) -> PResult<'a, ThinVec<P<Expr>>> {
self.parse_paren_comma_seq(|p| p.parse_expr_catch_underscore()).map(|(r, _)| r) self.parse_paren_comma_seq(|p| p.parse_expr_catch_underscore()).map(|(r, _)| r)
} }
@ -1450,7 +1451,7 @@ impl<'a> Parser<'a> {
let close = &token::CloseDelim(close_delim); let close = &token::CloseDelim(close_delim);
let kind = if self.eat(close) { let kind = if self.eat(close) {
// Empty vector // Empty vector
ExprKind::Array(Vec::new()) ExprKind::Array(ThinVec::new())
} else { } else {
// Non-empty vector // Non-empty vector
let first_expr = self.parse_expr()?; let first_expr = self.parse_expr()?;
@ -1468,7 +1469,7 @@ impl<'a> Parser<'a> {
} else { } else {
// Vector with one element // Vector with one element
self.expect(close)?; self.expect(close)?;
ExprKind::Array(vec![first_expr]) ExprKind::Array(thin_vec![first_expr])
} }
}; };
let expr = self.mk_expr(lo.to(self.prev_token.span), kind); let expr = self.mk_expr(lo.to(self.prev_token.span), kind);
@ -2187,7 +2188,7 @@ impl<'a> Parser<'a> {
let arg_start = self.token.span.lo(); let arg_start = self.token.span.lo();
let inputs = if self.eat(&token::OrOr) { let inputs = if self.eat(&token::OrOr) {
Vec::new() ThinVec::new()
} else { } else {
self.expect(&token::BinOp(token::Or))?; self.expect(&token::BinOp(token::Or))?;
let args = self let args = self
@ -3211,7 +3212,7 @@ impl<'a> Parser<'a> {
ExprKind::Index(expr, idx) ExprKind::Index(expr, idx)
} }
fn mk_call(&self, f: P<Expr>, args: Vec<P<Expr>>) -> ExprKind { fn mk_call(&self, f: P<Expr>, args: ThinVec<P<Expr>>) -> ExprKind {
ExprKind::Call(f, args) ExprKind::Call(f, args)
} }

6
compiler/rustc_parse/src/parser/generics.rs
View File

@ -18,7 +18,7 @@ use thin_vec::ThinVec;
enum PredicateOrStructBody { enum PredicateOrStructBody {
Predicate(ast::WherePredicate), Predicate(ast::WherePredicate),
StructBody(Vec<ast::FieldDef>), StructBody(ThinVec<ast::FieldDef>),
} }
impl<'a> Parser<'a> { impl<'a> Parser<'a> {
@ -278,14 +278,14 @@ impl<'a> Parser<'a> {
&mut self, &mut self,
struct_name: Ident, struct_name: Ident,
body_insertion_point: Span, body_insertion_point: Span,
) -> PResult<'a, (WhereClause, Option<Vec<ast::FieldDef>>)> { ) -> PResult<'a, (WhereClause, Option<ThinVec<ast::FieldDef>>)> {
self.parse_where_clause_common(Some((struct_name, body_insertion_point))) self.parse_where_clause_common(Some((struct_name, body_insertion_point)))
} }
fn parse_where_clause_common( fn parse_where_clause_common(
&mut self, &mut self,
struct_: Option<(Ident, Span)>, struct_: Option<(Ident, Span)>,
) -> PResult<'a, (WhereClause, Option<Vec<ast::FieldDef>>)> { ) -> PResult<'a, (WhereClause, Option<ThinVec<ast::FieldDef>>)> {
let mut where_clause = WhereClause { let mut where_clause = WhereClause {
has_where_token: false, has_where_token: false,
predicates: ThinVec::new(), predicates: ThinVec::new(),

14
compiler/rustc_parse/src/parser/item.rs
View File

@ -26,7 +26,7 @@ use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::DUMMY_SP; use rustc_span::DUMMY_SP;
use std::fmt::Write; use std::fmt::Write;
use std::mem; use std::mem;
use thin_vec::ThinVec; use thin_vec::{thin_vec, ThinVec};
impl<'a> Parser<'a> { impl<'a> Parser<'a> {
/// Parses a source module as a crate. This is the main entry point for the parser. /// Parses a source module as a crate. This is the main entry point for the parser.
@ -997,7 +997,7 @@ impl<'a> Parser<'a> {
/// ```text /// ```text
/// USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`] /// USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`]
/// ``` /// ```
fn parse_use_tree_list(&mut self) -> PResult<'a, Vec<(UseTree, ast::NodeId)>> { fn parse_use_tree_list(&mut self) -> PResult<'a, ThinVec<(UseTree, ast::NodeId)>> {
self.parse_delim_comma_seq(Delimiter::Brace, |p| { self.parse_delim_comma_seq(Delimiter::Brace, |p| {
p.recover_diff_marker(); p.recover_diff_marker();
Ok((p.parse_use_tree()?, DUMMY_NODE_ID)) Ok((p.parse_use_tree()?, DUMMY_NODE_ID))
@ -1288,7 +1288,7 @@ impl<'a> Parser<'a> {
let (variants, _) = if self.token == TokenKind::Semi { let (variants, _) = if self.token == TokenKind::Semi {
self.sess.emit_err(errors::UseEmptyBlockNotSemi { span: self.token.span }); self.sess.emit_err(errors::UseEmptyBlockNotSemi { span: self.token.span });
self.bump(); self.bump();
(vec![], false) (thin_vec![], false)
} else { } else {
self.parse_delim_comma_seq(Delimiter::Brace, |p| p.parse_enum_variant()).map_err( self.parse_delim_comma_seq(Delimiter::Brace, |p| p.parse_enum_variant()).map_err(
|mut e| { |mut e| {
@ -1457,8 +1457,8 @@ impl<'a> Parser<'a> {
adt_ty: &str, adt_ty: &str,
ident_span: Span, ident_span: Span,
parsed_where: bool, parsed_where: bool,
) -> PResult<'a, (Vec<FieldDef>, /* recovered */ bool)> { ) -> PResult<'a, (ThinVec<FieldDef>, /* recovered */ bool)> {
let mut fields = Vec::new(); let mut fields = ThinVec::new();
let mut recovered = false; let mut recovered = false;
if self.eat(&token::OpenDelim(Delimiter::Brace)) { if self.eat(&token::OpenDelim(Delimiter::Brace)) {
while self.token != token::CloseDelim(Delimiter::Brace) { while self.token != token::CloseDelim(Delimiter::Brace) {
@ -1498,7 +1498,7 @@ impl<'a> Parser<'a> {
Ok((fields, recovered)) Ok((fields, recovered))
} }
pub(super) fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<FieldDef>> { pub(super) fn parse_tuple_struct_body(&mut self) -> PResult<'a, ThinVec<FieldDef>> {
// This is the case where we find `struct Foo<T>(T) where T: Copy;` // This is the case where we find `struct Foo<T>(T) where T: Copy;`
// Unit like structs are handled in parse_item_struct function // Unit like structs are handled in parse_item_struct function
self.parse_paren_comma_seq(|p| { self.parse_paren_comma_seq(|p| {
@ -2374,7 +2374,7 @@ impl<'a> Parser<'a> {
} }
/// Parses the parameter list of a function, including the `(` and `)` delimiters. /// Parses the parameter list of a function, including the `(` and `)` delimiters.
pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, Vec<Param>> { pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, ThinVec<Param>> {
let mut first_param = true; let mut first_param = true;
// Parse the arguments, starting out with `self` being allowed... // Parse the arguments, starting out with `self` being allowed...
let (mut params, _) = self.parse_paren_comma_seq(|p| { let (mut params, _) = self.parse_paren_comma_seq(|p| {

17
compiler/rustc_parse/src/parser/mod.rs
View File

@ -36,9 +36,10 @@ use rustc_errors::{
use rustc_session::parse::ParseSess; use rustc_session::parse::ParseSess;
use rustc_span::source_map::{Span, DUMMY_SP}; use rustc_span::source_map::{Span, DUMMY_SP};
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use std::ops::Range; use std::ops::Range;
use std::{cmp, mem, slice}; use std::{cmp, mem, slice};
use thin_vec::ThinVec;
use tracing::debug;
use crate::errors::{ use crate::errors::{
DocCommentDoesNotDocumentAnything, IncorrectVisibilityRestriction, MismatchedClosingDelimiter, DocCommentDoesNotDocumentAnything, IncorrectVisibilityRestriction, MismatchedClosingDelimiter,
@ -853,11 +854,11 @@ impl<'a> Parser<'a> {
sep: SeqSep, sep: SeqSep,
expect: TokenExpectType, expect: TokenExpectType,
mut f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>, mut f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
) -> PResult<'a, (Vec<T>, bool /* trailing */, bool /* recovered */)> { ) -> PResult<'a, (ThinVec<T>, bool /* trailing */, bool /* recovered */)> {
let mut first = true; let mut first = true;
let mut recovered = false; let mut recovered = false;
let mut trailing = false; let mut trailing = false;
let mut v = vec![]; let mut v = ThinVec::new();
let unclosed_delims = !self.unclosed_delims.is_empty(); let unclosed_delims = !self.unclosed_delims.is_empty();
while !self.expect_any_with_type(kets, expect) { while !self.expect_any_with_type(kets, expect) {
@ -1037,7 +1038,7 @@ impl<'a> Parser<'a> {
ket: &TokenKind, ket: &TokenKind,
sep: SeqSep, sep: SeqSep,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
) -> PResult<'a, (Vec<T>, bool, bool)> { ) -> PResult<'a, (ThinVec<T>, bool, bool)> {
self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f) self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f)
} }
@ -1049,7 +1050,7 @@ impl<'a> Parser<'a> {
ket: &TokenKind, ket: &TokenKind,
sep: SeqSep, sep: SeqSep,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
) -> PResult<'a, (Vec<T>, bool /* trailing */)> { ) -> PResult<'a, (ThinVec<T>, bool /* trailing */)> {
let (val, trailing, recovered) = self.parse_seq_to_before_end(ket, sep, f)?; let (val, trailing, recovered) = self.parse_seq_to_before_end(ket, sep, f)?;
if !recovered { if !recovered {
self.eat(ket); self.eat(ket);
@ -1066,7 +1067,7 @@ impl<'a> Parser<'a> {
ket: &TokenKind, ket: &TokenKind,
sep: SeqSep, sep: SeqSep,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
) -> PResult<'a, (Vec<T>, bool)> { ) -> PResult<'a, (ThinVec<T>, bool)> {
self.expect(bra)?; self.expect(bra)?;
self.parse_seq_to_end(ket, sep, f) self.parse_seq_to_end(ket, sep, f)
} }
@ -1075,7 +1076,7 @@ impl<'a> Parser<'a> {
&mut self, &mut self,
delim: Delimiter, delim: Delimiter,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
) -> PResult<'a, (Vec<T>, bool)> { ) -> PResult<'a, (ThinVec<T>, bool)> {
self.parse_unspanned_seq( self.parse_unspanned_seq(
&token::OpenDelim(delim), &token::OpenDelim(delim),
&token::CloseDelim(delim), &token::CloseDelim(delim),
@ -1087,7 +1088,7 @@ impl<'a> Parser<'a> {
fn parse_paren_comma_seq<T>( fn parse_paren_comma_seq<T>(
&mut self, &mut self,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
) -> PResult<'a, (Vec<T>, bool)> { ) -> PResult<'a, (ThinVec<T>, bool)> {
self.parse_delim_comma_seq(Delimiter::Parenthesis, f) self.parse_delim_comma_seq(Delimiter::Parenthesis, f)
} }

5
compiler/rustc_parse/src/parser/pat.rs
View File

@ -23,6 +23,7 @@ use rustc_errors::{
use rustc_session::errors::ExprParenthesesNeeded; use rustc_session::errors::ExprParenthesesNeeded;
use rustc_span::source_map::{respan, Span, Spanned}; use rustc_span::source_map::{respan, Span, Spanned};
use rustc_span::symbol::{kw, sym, Ident}; use rustc_span::symbol::{kw, sym, Ident};
use thin_vec::thin_vec;
#[derive(PartialEq, Copy, Clone)] #[derive(PartialEq, Copy, Clone)]
pub enum Expected { pub enum Expected {
@ -155,7 +156,7 @@ impl<'a> Parser<'a> {
// If there was a leading vert, treat this as an or-pattern. This improves // If there was a leading vert, treat this as an or-pattern. This improves
// diagnostics. // diagnostics.
let span = leading_vert_span.to(self.prev_token.span); let span = leading_vert_span.to(self.prev_token.span);
return Ok((self.mk_pat(span, PatKind::Or(vec![first_pat])), trailing_vert)); return Ok((self.mk_pat(span, PatKind::Or(thin_vec![first_pat])), trailing_vert));
} }
return Ok((first_pat, trailing_vert)); return Ok((first_pat, trailing_vert));
@ -163,7 +164,7 @@ impl<'a> Parser<'a> {
// Parse the patterns `p_1 | ... | p_n` where `n > 0`. // Parse the patterns `p_1 | ... | p_n` where `n > 0`.
let lo = leading_vert_span.unwrap_or(first_pat.span); let lo = leading_vert_span.unwrap_or(first_pat.span);
let mut pats = vec![first_pat]; let mut pats = thin_vec![first_pat];
loop { loop {
match self.eat_or_separator(Some(lo)) { match self.eat_or_separator(Some(lo)) {
EatOrResult::AteOr => {} EatOrResult::AteOr => {}

2
compiler/rustc_parse/src/parser/ty.rs
View File

@ -1046,7 +1046,7 @@ impl<'a> Parser<'a> {
// Parse `(T, U) -> R`. // Parse `(T, U) -> R`.
let inputs_lo = self.token.span; let inputs_lo = self.token.span;
let inputs: Vec<_> = let inputs: ThinVec<_> =
self.parse_fn_params(|_| false)?.into_iter().map(|input| input.ty).collect(); self.parse_fn_params(|_| false)?.into_iter().map(|input| input.ty).collect();
let inputs_span = inputs_lo.to(self.prev_token.span); let inputs_span = inputs_lo.to(self.prev_token.span);
let output = self.parse_ret_ty(AllowPlus::No, RecoverQPath::No, RecoverReturnSign::No)?; let output = self.parse_ret_ty(AllowPlus::No, RecoverQPath::No, RecoverReturnSign::No)?;

1
src/librustdoc/Cargo.toml
View File

@ -18,7 +18,6 @@ serde_json = "1.0"
serde = { version = "1.0", features = ["derive"] } serde = { version = "1.0", features = ["derive"] }
smallvec = "1.8.1" smallvec = "1.8.1"
tempfile = "3" tempfile = "3"
thin-vec = "0.2.12"
tracing = "0.1" tracing = "0.1"
tracing-tree = "0.2.0" tracing-tree = "0.2.0"

5
src/librustdoc/clean/cfg/tests.rs
View File

@ -4,6 +4,7 @@ use rustc_ast::{LitKind, MetaItemLit, Path, StrStyle};
use rustc_span::create_default_session_globals_then; use rustc_span::create_default_session_globals_then;
use rustc_span::symbol::{kw, Ident, Symbol}; use rustc_span::symbol::{kw, Ident, Symbol};
use rustc_span::DUMMY_SP; use rustc_span::DUMMY_SP;
use thin_vec::thin_vec;
fn word_cfg(s: &str) -> Cfg { fn word_cfg(s: &str) -> Cfg {
Cfg::Cfg(Symbol::intern(s), None) Cfg::Cfg(Symbol::intern(s), None)
@ -34,7 +35,7 @@ macro_rules! dummy_meta_item_list {
($name:ident, [$($list:ident),* $(,)?]) => { ($name:ident, [$($list:ident),* $(,)?]) => {
MetaItem { MetaItem {
path: Path::from_ident(Ident::from_str(stringify!($name))), path: Path::from_ident(Ident::from_str(stringify!($name))),
kind: MetaItemKind::List(vec![ kind: MetaItemKind::List(thin_vec![
$( $(
NestedMetaItem::MetaItem( NestedMetaItem::MetaItem(
dummy_meta_item_word(stringify!($list)), dummy_meta_item_word(stringify!($list)),
@ -48,7 +49,7 @@ macro_rules! dummy_meta_item_list {
($name:ident, [$($list:expr),* $(,)?]) => { ($name:ident, [$($list:expr),* $(,)?]) => {
MetaItem { MetaItem {
path: Path::from_ident(Ident::from_str(stringify!($name))), path: Path::from_ident(Ident::from_str(stringify!($name))),
kind: MetaItemKind::List(vec![ kind: MetaItemKind::List(thin_vec![
$( $(
NestedMetaItem::MetaItem($list), NestedMetaItem::MetaItem($list),
)* )*

1
src/librustdoc/lib.rs
View File

@ -20,6 +20,7 @@
#![allow(clippy::collapsible_if, clippy::collapsible_else_if)] #![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
#![allow(rustc::potential_query_instability)] #![allow(rustc::potential_query_instability)]
extern crate thin_vec;
#[macro_use] #[macro_use]
extern crate tracing; extern crate tracing;

1
src/tools/clippy/clippy_lints/src/lib.rs
View File

@ -42,6 +42,7 @@ extern crate rustc_session;
extern crate rustc_span; extern crate rustc_span;
extern crate rustc_target; extern crate rustc_target;
extern crate rustc_trait_selection; extern crate rustc_trait_selection;
extern crate thin_vec;
#[macro_use] #[macro_use]
extern crate clippy_utils; extern crate clippy_utils;

50
src/tools/clippy/clippy_lints/src/unnested_or_patterns.rs
View File

@ -12,9 +12,9 @@ use rustc_errors::Applicability;
use rustc_lint::{EarlyContext, EarlyLintPass}; use rustc_lint::{EarlyContext, EarlyLintPass};
use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_session::{declare_tool_lint, impl_lint_pass};
use rustc_span::DUMMY_SP; use rustc_span::DUMMY_SP;
use std::cell::Cell; use std::cell::Cell;
use std::mem; use std::mem;
use thin_vec::{thin_vec, ThinVec};
declare_clippy_lint! { declare_clippy_lint! {
/// ### What it does /// ### What it does
@ -214,7 +214,7 @@ macro_rules! always_pat {
/// Focus on `focus_idx` in `alternatives`, /// Focus on `focus_idx` in `alternatives`,
/// attempting to extend it with elements of the same constructor `C` /// attempting to extend it with elements of the same constructor `C`
/// in `alternatives[focus_idx + 1..]`. /// in `alternatives[focus_idx + 1..]`.
fn transform_with_focus_on_idx(alternatives: &mut Vec<P<Pat>>, focus_idx: usize) -> bool { fn transform_with_focus_on_idx(alternatives: &mut ThinVec<P<Pat>>, focus_idx: usize) -> bool {
// Extract the kind; we'll need to make some changes in it. // Extract the kind; we'll need to make some changes in it.
let mut focus_kind = mem::replace(&mut alternatives[focus_idx].kind, PatKind::Wild); let mut focus_kind = mem::replace(&mut alternatives[focus_idx].kind, PatKind::Wild);
// We'll focus on `alternatives[focus_idx]`, // We'll focus on `alternatives[focus_idx]`,
@ -296,7 +296,7 @@ fn extend_with_struct_pat(
fps1: &mut [ast::PatField], fps1: &mut [ast::PatField],
rest1: bool, rest1: bool,
start: usize, start: usize,
alternatives: &mut Vec<P<Pat>>, alternatives: &mut ThinVec<P<Pat>>,
) -> bool { ) -> bool {
(0..fps1.len()).any(|idx| { (0..fps1.len()).any(|idx| {
let pos_in_2 = Cell::new(None); // The element `k`. let pos_in_2 = Cell::new(None); // The element `k`.
@ -336,9 +336,9 @@ fn extend_with_struct_pat(
fn extend_with_matching_product( fn extend_with_matching_product(
targets: &mut [P<Pat>], targets: &mut [P<Pat>],
start: usize, start: usize,
alternatives: &mut Vec<P<Pat>>, alternatives: &mut ThinVec<P<Pat>>,
predicate: impl Fn(&PatKind, &[P<Pat>], usize) -> bool, predicate: impl Fn(&PatKind, &[P<Pat>], usize) -> bool,
extract: impl Fn(PatKind) -> Vec<P<Pat>>, extract: impl Fn(PatKind) -> ThinVec<P<Pat>>,
) -> bool { ) -> bool {
(0..targets.len()).any(|idx| { (0..targets.len()).any(|idx| {
let tail_or = drain_matching( let tail_or = drain_matching(
@ -365,14 +365,14 @@ fn take_pat(from: &mut Pat) -> Pat {
/// Extend `target` as an or-pattern with the alternatives /// Extend `target` as an or-pattern with the alternatives
/// in `tail_or` if there are any and return if there were. /// in `tail_or` if there are any and return if there were.
fn extend_with_tail_or(target: &mut Pat, tail_or: Vec<P<Pat>>) -> bool { fn extend_with_tail_or(target: &mut Pat, tail_or: ThinVec<P<Pat>>) -> bool {
fn extend(target: &mut Pat, mut tail_or: Vec<P<Pat>>) { fn extend(target: &mut Pat, mut tail_or: ThinVec<P<Pat>>) {
match target { match target {
// On an existing or-pattern in the target, append to it. // On an existing or-pattern in the target, append to it.
Pat { kind: Or(ps), .. } => ps.append(&mut tail_or), Pat { kind: Or(ps), .. } => ps.append(&mut tail_or),
// Otherwise convert the target to an or-pattern. // Otherwise convert the target to an or-pattern.
target => { target => {
let mut init_or = vec![P(take_pat(target))]; let mut init_or = thin_vec![P(take_pat(target))];
init_or.append(&mut tail_or); init_or.append(&mut tail_or);
target.kind = Or(init_or); target.kind = Or(init_or);
}, },
@ -391,26 +391,42 @@ fn extend_with_tail_or(target: &mut Pat, tail_or: Vec<P<Pat>>) -> bool {
// Only elements beginning with `start` are considered for extraction. // Only elements beginning with `start` are considered for extraction.
fn drain_matching( fn drain_matching(
start: usize, start: usize,
alternatives: &mut Vec<P<Pat>>, alternatives: &mut ThinVec<P<Pat>>,
predicate: impl Fn(&PatKind) -> bool, predicate: impl Fn(&PatKind) -> bool,
extract: impl Fn(PatKind) -> P<Pat>, extract: impl Fn(PatKind) -> P<Pat>,
) -> Vec<P<Pat>> { ) -> ThinVec<P<Pat>> {
let mut tail_or = vec![]; let mut tail_or = ThinVec::new();
let mut idx = 0; let mut idx = 0;
for pat in alternatives.drain_filter(|p| {
// Check if we should extract, but only if `idx >= start`. // If `ThinVec` had the `drain_filter` method, this loop could be rewritten
// like so:
//
// for pat in alternatives.drain_filter(|p| {
// // Check if we should extract, but only if `idx >= start`.
// idx += 1;
// idx > start && predicate(&p.kind)
// }) {
// tail_or.push(extract(pat.into_inner().kind));
// }
let mut i = 0;
while i < alternatives.len() {
idx += 1; idx += 1;
idx > start && predicate(&p.kind) // Check if we should extract, but only if `idx >= start`.
}) { if idx > start && predicate(&alternatives[i].kind) {
tail_or.push(extract(pat.into_inner().kind)); let pat = alternatives.remove(i);
tail_or.push(extract(pat.into_inner().kind));
} else {
i += 1;
}
} }
tail_or tail_or
} }
fn extend_with_matching( fn extend_with_matching(
target: &mut Pat, target: &mut Pat,
start: usize, start: usize,
alternatives: &mut Vec<P<Pat>>, alternatives: &mut ThinVec<P<Pat>>,
predicate: impl Fn(&PatKind) -> bool, predicate: impl Fn(&PatKind) -> bool,
extract: impl Fn(PatKind) -> P<Pat>, extract: impl Fn(PatKind) -> P<Pat>,
) -> bool { ) -> bool {

3
src/tools/clippy/clippy_utils/src/ast_utils.rs
View File

@ -144,7 +144,8 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
(_, Paren(r)) => eq_expr(l, r), (_, Paren(r)) => eq_expr(l, r),
(Err, Err) => true, (Err, Err) => true,
(Box(l), Box(r)) | (Try(l), Try(r)) | (Await(l), Await(r)) => eq_expr(l, r), (Box(l), Box(r)) | (Try(l), Try(r)) | (Await(l), Await(r)) => eq_expr(l, r),
(Array(l), Array(r)) | (Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)), (Array(l), Array(r)) => over(l, r, |l, r| eq_expr(l, r)),
(Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)),
(Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value), (Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value),
(Call(lc, la), Call(rc, ra)) => eq_expr(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)), (Call(lc, la), Call(rc, ra)) => eq_expr(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
( (

4
src/tools/rustfmt/src/chains.rs
View File

@ -74,6 +74,8 @@ use crate::utils::{
rewrite_ident, trimmed_last_line_width, wrap_str, rewrite_ident, trimmed_last_line_width, wrap_str,
}; };
use thin_vec::ThinVec;
/// Provides the original input contents from the span /// Provides the original input contents from the span
/// of a chain element with trailing spaces trimmed. /// of a chain element with trailing spaces trimmed.
fn format_overflow_style(span: Span, context: &RewriteContext<'_>) -> Option<String> { fn format_overflow_style(span: Span, context: &RewriteContext<'_>) -> Option<String> {
@ -168,7 +170,7 @@ enum ChainItemKind {
MethodCall( MethodCall(
ast::PathSegment, ast::PathSegment,
Vec<ast::GenericArg>, Vec<ast::GenericArg>,
Vec<ptr::P<ast::Expr>>, ThinVec<ptr::P<ast::Expr>>,
), ),
StructField(symbol::Ident), StructField(symbol::Ident),
TupleField(symbol::Ident, bool), TupleField(symbol::Ident, bool),

1
src/tools/rustfmt/src/lib.rs
View File

@ -23,6 +23,7 @@ extern crate rustc_expand;
extern crate rustc_parse; extern crate rustc_parse;
extern crate rustc_session; extern crate rustc_session;
extern crate rustc_span; extern crate rustc_span;
extern crate thin_vec;
// Necessary to pull in object code as the rest of the rustc crates are shipped only as rmeta // Necessary to pull in object code as the rest of the rustc crates are shipped only as rmeta
// files. // files.

8
tests/ui-fulldeps/pprust-expr-roundtrip.rs
View File

@ -76,17 +76,17 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
for kind in 0..=19 { for kind in 0..=19 {
match kind { match kind {
0 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Box(e))), 0 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Box(e))),
1 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Call(e, vec![]))), 1 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Call(e, thin_vec![]))),
2 => { 2 => {
let seg = PathSegment::from_ident(Ident::from_str("x")); let seg = PathSegment::from_ident(Ident::from_str("x"));
iter_exprs(depth - 1, &mut |e| { iter_exprs(depth - 1, &mut |e| {
g(ExprKind::MethodCall(Box::new(MethodCall { g(ExprKind::MethodCall(Box::new(MethodCall {
seg: seg.clone(), receiver: e, args: vec![make_x()], span: DUMMY_SP seg: seg.clone(), receiver: e, args: thin_vec![make_x()], span: DUMMY_SP
})) }))
)}); )});
iter_exprs(depth - 1, &mut |e| { iter_exprs(depth - 1, &mut |e| {
g(ExprKind::MethodCall(Box::new(MethodCall { g(ExprKind::MethodCall(Box::new(MethodCall {
seg: seg.clone(), receiver: make_x(), args: vec![e], span: DUMMY_SP seg: seg.clone(), receiver: make_x(), args: thin_vec![e], span: DUMMY_SP
})) }))
)}); )});
} }
@ -121,7 +121,7 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
iter_exprs(depth - 1, &mut |e| g(ExprKind::If(e, block.clone(), None))); iter_exprs(depth - 1, &mut |e| g(ExprKind::If(e, block.clone(), None)));
} }
11 => { 11 => {
let decl = P(FnDecl { inputs: vec![], output: FnRetTy::Default(DUMMY_SP) }); let decl = P(FnDecl { inputs: thin_vec![], output: FnRetTy::Default(DUMMY_SP) });
iter_exprs(depth - 1, &mut |e| { iter_exprs(depth - 1, &mut |e| {
g(ExprKind::Closure(Box::new(Closure { g(ExprKind::Closure(Box::new(Closure {
binder: ClosureBinder::NotPresent, binder: ClosureBinder::NotPresent,

152
tests/ui/stats/hir-stats.stderr
View File

@ -1,119 +1,119 @@
ast-stats-1 PRE EXPANSION AST STATS ast-stats-1 PRE EXPANSION AST STATS
ast-stats-1 Name Accumulated Size Count Item Size ast-stats-1 Name Accumulated Size Count Item Size
ast-stats-1 ---------------------------------------------------------------- ast-stats-1 ----------------------------------------------------------------
ast-stats-1 GenericArgs 40 ( 0.6%) 1 40
ast-stats-1 - AngleBracketed 40 ( 0.6%) 1
ast-stats-1 ExprField 48 ( 0.7%) 1 48 ast-stats-1 ExprField 48 ( 0.7%) 1 48
ast-stats-1 WherePredicate 56 ( 0.8%) 1 56 ast-stats-1 WherePredicate 56 ( 0.8%) 1 56
ast-stats-1 - BoundPredicate 56 ( 0.8%) 1 ast-stats-1 - BoundPredicate 56 ( 0.8%) 1
ast-stats-1 GenericArgs 56 ( 0.8%) 1 56
ast-stats-1 - AngleBracketed 56 ( 0.8%) 1
ast-stats-1 Crate 56 ( 0.8%) 1 56 ast-stats-1 Crate 56 ( 0.8%) 1 56
ast-stats-1 Attribute 64 ( 0.9%) 2 32 ast-stats-1 Attribute 64 ( 0.9%) 2 32
ast-stats-1 - Normal 32 ( 0.5%) 1 ast-stats-1 - Normal 32 ( 0.5%) 1
ast-stats-1 - DocComment 32 ( 0.5%) 1 ast-stats-1 - DocComment 32 ( 0.5%) 1
ast-stats-1 Local 72 ( 1.0%) 1 72 ast-stats-1 Local 72 ( 1.1%) 1 72
ast-stats-1 Arm 96 ( 1.4%) 2 48 ast-stats-1 Arm 96 ( 1.4%) 2 48
ast-stats-1 ForeignItem 96 ( 1.4%) 1 96 ast-stats-1 ForeignItem 96 ( 1.4%) 1 96
ast-stats-1 - Fn 96 ( 1.4%) 1 ast-stats-1 - Fn 96 ( 1.4%) 1
ast-stats-1 FnDecl 120 ( 1.8%) 5 24
ast-stats-1 FieldDef 160 ( 2.3%) 2 80 ast-stats-1 FieldDef 160 ( 2.3%) 2 80
ast-stats-1 Stmt 160 ( 2.3%) 5 32 ast-stats-1 Stmt 160 ( 2.3%) 5 32
ast-stats-1 - Local 32 ( 0.5%) 1 ast-stats-1 - Local 32 ( 0.5%) 1
ast-stats-1 - MacCall 32 ( 0.5%) 1 ast-stats-1 - MacCall 32 ( 0.5%) 1
ast-stats-1 - Expr 96 ( 1.4%) 3 ast-stats-1 - Expr 96 ( 1.4%) 3
ast-stats-1 Param 160 ( 2.3%) 4 40 ast-stats-1 Param 160 ( 2.3%) 4 40
ast-stats-1 FnDecl 200 ( 2.8%) 5 40 ast-stats-1 Variant 208 ( 3.0%) 2 104
ast-stats-1 GenericBound 224 ( 3.2%) 4 56 ast-stats-1 GenericBound 224 ( 3.3%) 4 56
ast-stats-1 - Trait 224 ( 3.2%) 4 ast-stats-1 - Trait 224 ( 3.3%) 4
ast-stats-1 Variant 240 ( 3.4%) 2 120 ast-stats-1 Block 288 ( 4.2%) 6 48
ast-stats-1 Block 288 ( 4.1%) 6 48 ast-stats-1 AssocItem 416 ( 6.1%) 4 104
ast-stats-1 AssocItem 416 ( 5.9%) 4 104
ast-stats-1 - Type 208 ( 3.0%) 2 ast-stats-1 - Type 208 ( 3.0%) 2
ast-stats-1 - Fn 208 ( 3.0%) 2 ast-stats-1 - Fn 208 ( 3.0%) 2
ast-stats-1 GenericParam 480 ( 6.8%) 5 96 ast-stats-1 GenericParam 480 ( 7.0%) 5 96
ast-stats-1 Expr 576 ( 8.2%) 8 72 ast-stats-1 Expr 576 ( 8.4%) 8 72
ast-stats-1 - Path 72 ( 1.0%) 1 ast-stats-1 - Path 72 ( 1.1%) 1
ast-stats-1 - Match 72 ( 1.0%) 1 ast-stats-1 - Match 72 ( 1.1%) 1
ast-stats-1 - Struct 72 ( 1.0%) 1 ast-stats-1 - Struct 72 ( 1.1%) 1
ast-stats-1 - Lit 144 ( 2.0%) 2 ast-stats-1 - Lit 144 ( 2.1%) 2
ast-stats-1 - Block 216 ( 3.1%) 3 ast-stats-1 - Block 216 ( 3.2%) 3
ast-stats-1 Pat 616 ( 8.7%) 7 88 ast-stats-1 Pat 616 ( 9.0%) 7 88
ast-stats-1 - Struct 88 ( 1.2%) 1 ast-stats-1 - Struct 88 ( 1.3%) 1
ast-stats-1 - Wild 88 ( 1.2%) 1 ast-stats-1 - Wild 88 ( 1.3%) 1
ast-stats-1 - Ident 440 ( 6.2%) 5 ast-stats-1 - Ident 440 ( 6.4%) 5
ast-stats-1 PathSegment 720 (10.2%) 30 24 ast-stats-1 PathSegment 720 (10.5%) 30 24
ast-stats-1 Ty 896 (12.7%) 14 64 ast-stats-1 Ty 896 (13.1%) 14 64
ast-stats-1 - Ptr 64 ( 0.9%) 1 ast-stats-1 - Ptr 64 ( 0.9%) 1
ast-stats-1 - Ref 64 ( 0.9%) 1 ast-stats-1 - Ref 64 ( 0.9%) 1
ast-stats-1 - ImplicitSelf 128 ( 1.8%) 2 ast-stats-1 - ImplicitSelf 128 ( 1.9%) 2
ast-stats-1 - Path 640 ( 9.1%) 10 ast-stats-1 - Path 640 ( 9.3%) 10
ast-stats-1 Item 1_368 (19.4%) 9 152 ast-stats-1 Item 1_296 (18.9%) 9 144
ast-stats-1 - Trait 152 ( 2.2%) 1 ast-stats-1 - Trait 144 ( 2.1%) 1
ast-stats-1 - Enum 152 ( 2.2%) 1 ast-stats-1 - Enum 144 ( 2.1%) 1
ast-stats-1 - ForeignMod 152 ( 2.2%) 1 ast-stats-1 - ForeignMod 144 ( 2.1%) 1
ast-stats-1 - Impl 152 ( 2.2%) 1 ast-stats-1 - Impl 144 ( 2.1%) 1
ast-stats-1 - Fn 304 ( 4.3%) 2 ast-stats-1 - Fn 288 ( 4.2%) 2
ast-stats-1 - Use 456 ( 6.5%) 3 ast-stats-1 - Use 432 ( 6.3%) 3
ast-stats-1 ---------------------------------------------------------------- ast-stats-1 ----------------------------------------------------------------
ast-stats-1 Total 7_048 ast-stats-1 Total 6_848
ast-stats-1 ast-stats-1
ast-stats-2 POST EXPANSION AST STATS ast-stats-2 POST EXPANSION AST STATS
ast-stats-2 Name Accumulated Size Count Item Size ast-stats-2 Name Accumulated Size Count Item Size
ast-stats-2 ---------------------------------------------------------------- ast-stats-2 ----------------------------------------------------------------
ast-stats-2 GenericArgs 40 ( 0.5%) 1 40
ast-stats-2 - AngleBracketed 40 ( 0.5%) 1
ast-stats-2 ExprField 48 ( 0.6%) 1 48 ast-stats-2 ExprField 48 ( 0.6%) 1 48
ast-stats-2 WherePredicate 56 ( 0.7%) 1 56 ast-stats-2 WherePredicate 56 ( 0.8%) 1 56
ast-stats-2 - BoundPredicate 56 ( 0.7%) 1 ast-stats-2 - BoundPredicate 56 ( 0.8%) 1
ast-stats-2 GenericArgs 56 ( 0.7%) 1 56 ast-stats-2 Crate 56 ( 0.8%) 1 56
ast-stats-2 - AngleBracketed 56 ( 0.7%) 1 ast-stats-2 Local 72 ( 1.0%) 1 72
ast-stats-2 Crate 56 ( 0.7%) 1 56 ast-stats-2 Arm 96 ( 1.3%) 2 48
ast-stats-2 Local 72 ( 0.9%) 1 72 ast-stats-2 ForeignItem 96 ( 1.3%) 1 96
ast-stats-2 Arm 96 ( 1.2%) 2 48 ast-stats-2 - Fn 96 ( 1.3%) 1
ast-stats-2 ForeignItem 96 ( 1.2%) 1 96
ast-stats-2 - Fn 96 ( 1.2%) 1
ast-stats-2 InlineAsm 120 ( 1.6%) 1 120 ast-stats-2 InlineAsm 120 ( 1.6%) 1 120
ast-stats-2 FnDecl 120 ( 1.6%) 5 24
ast-stats-2 Attribute 128 ( 1.7%) 4 32 ast-stats-2 Attribute 128 ( 1.7%) 4 32
ast-stats-2 - DocComment 32 ( 0.4%) 1 ast-stats-2 - DocComment 32 ( 0.4%) 1
ast-stats-2 - Normal 96 ( 1.2%) 3 ast-stats-2 - Normal 96 ( 1.3%) 3
ast-stats-2 FieldDef 160 ( 2.1%) 2 80 ast-stats-2 FieldDef 160 ( 2.1%) 2 80
ast-stats-2 Stmt 160 ( 2.1%) 5 32 ast-stats-2 Stmt 160 ( 2.1%) 5 32
ast-stats-2 - Local 32 ( 0.4%) 1 ast-stats-2 - Local 32 ( 0.4%) 1
ast-stats-2 - Semi 32 ( 0.4%) 1 ast-stats-2 - Semi 32 ( 0.4%) 1
ast-stats-2 - Expr 96 ( 1.2%) 3 ast-stats-2 - Expr 96 ( 1.3%) 3
ast-stats-2 Param 160 ( 2.1%) 4 40 ast-stats-2 Param 160 ( 2.1%) 4 40
ast-stats-2 FnDecl 200 ( 2.6%) 5 40 ast-stats-2 Variant 208 ( 2.8%) 2 104
ast-stats-2 GenericBound 224 ( 2.9%) 4 56 ast-stats-2 GenericBound 224 ( 3.0%) 4 56
ast-stats-2 - Trait 224 ( 2.9%) 4 ast-stats-2 - Trait 224 ( 3.0%) 4
ast-stats-2 Variant 240 ( 3.1%) 2 120 ast-stats-2 Block 288 ( 3.9%) 6 48
ast-stats-2 Block 288 ( 3.8%) 6 48 ast-stats-2 AssocItem 416 ( 5.6%) 4 104
ast-stats-2 AssocItem 416 ( 5.4%) 4 104 ast-stats-2 - Type 208 ( 2.8%) 2
ast-stats-2 - Type 208 ( 2.7%) 2 ast-stats-2 - Fn 208 ( 2.8%) 2
ast-stats-2 - Fn 208 ( 2.7%) 2 ast-stats-2 GenericParam 480 ( 6.4%) 5 96
ast-stats-2 GenericParam 480 ( 6.2%) 5 96 ast-stats-2 Pat 616 ( 8.3%) 7 88
ast-stats-2 Pat 616 ( 8.0%) 7 88 ast-stats-2 - Struct 88 ( 1.2%) 1
ast-stats-2 - Struct 88 ( 1.1%) 1 ast-stats-2 - Wild 88 ( 1.2%) 1
ast-stats-2 - Wild 88 ( 1.1%) 1 ast-stats-2 - Ident 440 ( 5.9%) 5
ast-stats-2 - Ident 440 ( 5.7%) 5 ast-stats-2 Expr 648 ( 8.7%) 9 72
ast-stats-2 Expr 648 ( 8.4%) 9 72 ast-stats-2 - Path 72 ( 1.0%) 1
ast-stats-2 - Path 72 ( 0.9%) 1 ast-stats-2 - Match 72 ( 1.0%) 1
ast-stats-2 - Match 72 ( 0.9%) 1 ast-stats-2 - Struct 72 ( 1.0%) 1
ast-stats-2 - Struct 72 ( 0.9%) 1 ast-stats-2 - InlineAsm 72 ( 1.0%) 1
ast-stats-2 - InlineAsm 72 ( 0.9%) 1
ast-stats-2 - Lit 144 ( 1.9%) 2 ast-stats-2 - Lit 144 ( 1.9%) 2
ast-stats-2 - Block 216 ( 2.8%) 3 ast-stats-2 - Block 216 ( 2.9%) 3
ast-stats-2 PathSegment 792 (10.3%) 33 24 ast-stats-2 PathSegment 792 (10.6%) 33 24
ast-stats-2 Ty 896 (11.7%) 14 64 ast-stats-2 Ty 896 (12.0%) 14 64
ast-stats-2 - Ptr 64 ( 0.8%) 1 ast-stats-2 - Ptr 64 ( 0.9%) 1
ast-stats-2 - Ref 64 ( 0.8%) 1 ast-stats-2 - Ref 64 ( 0.9%) 1
ast-stats-2 - ImplicitSelf 128 ( 1.7%) 2 ast-stats-2 - ImplicitSelf 128 ( 1.7%) 2
ast-stats-2 - Path 640 ( 8.3%) 10 ast-stats-2 - Path 640 ( 8.6%) 10
ast-stats-2 Item 1_672 (21.8%) 11 152 ast-stats-2 Item 1_584 (21.2%) 11 144
ast-stats-2 - Trait 152 ( 2.0%) 1 ast-stats-2 - Trait 144 ( 1.9%) 1
ast-stats-2 - Enum 152 ( 2.0%) 1 ast-stats-2 - Enum 144 ( 1.9%) 1
ast-stats-2 - ExternCrate 152 ( 2.0%) 1 ast-stats-2 - ExternCrate 144 ( 1.9%) 1
ast-stats-2 - ForeignMod 152 ( 2.0%) 1 ast-stats-2 - ForeignMod 144 ( 1.9%) 1
ast-stats-2 - Impl 152 ( 2.0%) 1 ast-stats-2 - Impl 144 ( 1.9%) 1
ast-stats-2 - Fn 304 ( 4.0%) 2 ast-stats-2 - Fn 288 ( 3.9%) 2
ast-stats-2 - Use 608 ( 7.9%) 4 ast-stats-2 - Use 576 ( 7.7%) 4
ast-stats-2 ---------------------------------------------------------------- ast-stats-2 ----------------------------------------------------------------
ast-stats-2 Total 7_680 ast-stats-2 Total 7_464
ast-stats-2 ast-stats-2
hir-stats HIR STATS hir-stats HIR STATS
hir-stats Name Accumulated Size Count Item Size hir-stats Name Accumulated Size Count Item Size