Skip to content

Commit 159a617

Browse files
jackh726jackh726
committed
Remove paste
1 parent 130b085 commit 159a617

File tree

3 files changed

+138
-117
lines changed

3 files changed

+138
-117
lines changed

‎Cargo.lock

Lines changed: 0 additions & 1 deletion
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎crates/hir-ty/Cargo.toml

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,6 @@ rustc_apfloat = "0.2.3"
3636
query-group.workspace = true
3737
salsa.workspace = true
3838
salsa-macros.workspace = true
39-
paste = "1.0.15"
4039
extension-traits = "2.0.0"
4140

4241
ra-ap-rustc_abi.workspace = true

‎crates/hir-ty/src/next_solver/interner.rs

Lines changed: 138 additions & 115 deletions
Original file line numberDiff line numberDiff line change
@@ -68,79 +68,91 @@ use super::{ClauseKind, SolverDefId, Valtree};
6868
#[doc(hidden)]
6969
macro_rules! _interned_vec_nolifetime_salsa {
7070
($name:ident, $ty:ty) => {
71-
paste::paste! {
72-
interned_vec_nolifetime_salsa!($name, $ty, nofold);
73-
74-
impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for $name {
75-
fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Result<Self, F::Error> {
76-
use rustc_type_ir::inherent::{SliceLike as _};
77-
let inner: smallvec::SmallVec<[_; 2]> = self.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?;
78-
Ok($name::new_(folder.cx().db(), inner))
79-
}
80-
fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
81-
use rustc_type_ir::inherent::{SliceLike as _};
82-
let inner: smallvec::SmallVec<[_; 2]> = self.iter().map(|v| v.fold_with(folder)).collect();
83-
$name::new_(folder.cx().db(), inner)
84-
}
71+
interned_vec_nolifetime_salsa!($name, $ty, nofold);
72+
73+
impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for $name {
74+
fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
75+
self,
76+
folder: &mut F,
77+
) -> Result<Self, F::Error> {
78+
use rustc_type_ir::inherent::SliceLike as _;
79+
let inner: smallvec::SmallVec<[_; 2]> =
80+
self.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?;
81+
Ok($name::new_(folder.cx().db(), inner))
82+
}
83+
fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
84+
self,
85+
folder: &mut F,
86+
) -> Self {
87+
use rustc_type_ir::inherent::SliceLike as _;
88+
let inner: smallvec::SmallVec<[_; 2]> =
89+
self.iter().map(|v| v.fold_with(folder)).collect();
90+
$name::new_(folder.cx().db(), inner)
8591
}
92+
}
8693

87-
impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for $name {
88-
fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(&self, visitor: &mut V) -> V::Result {
89-
use rustc_type_ir::inherent::{SliceLike as _};
90-
use rustc_ast_ir::visit::VisitorResult;
91-
rustc_ast_ir::walk_visitable_list!(visitor, self.as_slice().iter());
92-
V::Result::output()
93-
}
94+
impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for $name {
95+
fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
96+
&self,
97+
visitor: &mut V,
98+
) -> V::Result {
99+
use rustc_ast_ir::visit::VisitorResult;
100+
use rustc_type_ir::inherent::SliceLike as _;
101+
rustc_ast_ir::walk_visitable_list!(visitor, self.as_slice().iter());
102+
V::Result::output()
94103
}
95104
}
96105
};
97106
($name:ident, $ty:ty, nofold) => {
98-
paste::paste! {
99-
#[salsa::interned(no_lifetime, constructor = new_, debug)]
100-
pub struct $name {
101-
#[returns(ref)]
102-
inner_: smallvec::SmallVec<[$ty; 2]>,
103-
}
107+
#[salsa::interned(no_lifetime, constructor = new_, debug)]
108+
pub struct $name {
109+
#[returns(ref)]
110+
inner_: smallvec::SmallVec<[$ty; 2]>,
111+
}
104112

105-
impl $name {
106-
pub fn new_from_iter<'db>(interner: DbInterner<'db>, data: impl IntoIterator<Item = $ty>) -> Self {
107-
$name::new_(interner.db(), data.into_iter().collect::<smallvec::SmallVec<[_; 2]>>())
108-
}
113+
impl $name {
114+
pub fn new_from_iter<'db>(
115+
interner: DbInterner<'db>,
116+
data: impl IntoIterator<Item = $ty>,
117+
) -> Self {
118+
$name::new_(interner.db(), data.into_iter().collect::<smallvec::SmallVec<[_; 2]>>())
119+
}
109120

110-
pub fn inner(&self) -> &smallvec::SmallVec<[$ty; 2]> {
111-
// SAFETY: ¯\_(ツ)_/¯
112-
crate::next_solver::tls::with_db_out_of_thin_air(|db| {
113-
let inner = self.inner_(db);
114-
unsafe { std::mem::transmute(inner) }
115-
})
116-
}
121+
pub fn inner(&self) -> &smallvec::SmallVec<[$ty; 2]> {
122+
// SAFETY: ¯\_(ツ)_/¯
123+
crate::next_solver::tls::with_db_out_of_thin_air(|db| {
124+
let inner = self.inner_(db);
125+
unsafe { std::mem::transmute(inner) }
126+
})
117127
}
128+
}
118129

119-
impl rustc_type_ir::inherent::SliceLike for $name {
120-
type Item = $ty;
130+
impl rustc_type_ir::inherent::SliceLike for $name {
131+
type Item = $ty;
121132

122-
type IntoIter = <smallvec::SmallVec<[$ty; 2]> as IntoIterator>::IntoIter;
133+
type IntoIter = <smallvec::SmallVec<[$ty; 2]> as IntoIterator>::IntoIter;
123134

124-
fn iter(self) -> Self::IntoIter {
125-
self.inner().clone().into_iter()
126-
}
135+
fn iter(self) -> Self::IntoIter {
136+
self.inner().clone().into_iter()
137+
}
127138

128-
fn as_slice(&self) -> &[Self::Item] {
129-
self.inner().as_slice()
130-
}
139+
fn as_slice(&self) -> &[Self::Item] {
140+
self.inner().as_slice()
131141
}
142+
}
132143

133-
impl IntoIterator for $name {
134-
type Item = $ty;
135-
type IntoIter = <Self as rustc_type_ir::inherent::SliceLike>::IntoIter;
144+
impl IntoIterator for $name {
145+
type Item = $ty;
146+
type IntoIter = <Self as rustc_type_ir::inherent::SliceLike>::IntoIter;
136147

137-
fn into_iter(self) -> Self::IntoIter { rustc_type_ir::inherent::SliceLike::iter(self) }
148+
fn into_iter(self) -> Self::IntoIter {
149+
rustc_type_ir::inherent::SliceLike::iter(self)
138150
}
151+
}
139152

140-
impl Default for $name {
141-
fn default() -> Self {
142-
$name::new_from_iter(DbInterner::new(), [])
143-
}
153+
impl Default for $name {
154+
fn default() -> Self {
155+
$name::new_from_iter(DbInterner::new(), [])
144156
}
145157
}
146158
};
@@ -152,86 +164,97 @@ pub use crate::_interned_vec_nolifetime_salsa as interned_vec_nolifetime_salsa;
152164
#[doc(hidden)]
153165
macro_rules! _interned_vec_db {
154166
($name:ident, $ty:ident) => {
155-
paste::paste! {
156-
interned_vec_db!($name, $ty, nofold);
157-
158-
impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for $name<'db> {
159-
fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Result<Self, F::Error> {
160-
use rustc_type_ir::inherent::{SliceLike as _};
161-
let inner: smallvec::SmallVec<[_; 2]> = self.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?;
162-
Ok($name::new_(folder.cx().db(), inner))
163-
}
164-
fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
165-
use rustc_type_ir::inherent::{SliceLike as _};
166-
let inner: smallvec::SmallVec<[_; 2]> = self.iter().map(|v| v.fold_with(folder)).collect();
167-
$name::new_(folder.cx().db(), inner)
168-
}
167+
interned_vec_db!($name, $ty, nofold);
169168

169+
impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for $name<'db> {
170+
fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
171+
self,
172+
folder: &mut F,
173+
) -> Result<Self, F::Error> {
174+
use rustc_type_ir::inherent::SliceLike as _;
175+
let inner: smallvec::SmallVec<[_; 2]> =
176+
self.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?;
177+
Ok($name::new_(folder.cx().db(), inner))
178+
}
179+
fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
180+
self,
181+
folder: &mut F,
182+
) -> Self {
183+
use rustc_type_ir::inherent::SliceLike as _;
184+
let inner: smallvec::SmallVec<[_; 2]> =
185+
self.iter().map(|v| v.fold_with(folder)).collect();
186+
$name::new_(folder.cx().db(), inner)
170187
}
188+
}
171189

172-
impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for $name<'db> {
173-
fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(&self, visitor: &mut V) -> V::Result {
174-
use rustc_type_ir::inherent::{SliceLike as _};
175-
use rustc_ast_ir::visit::VisitorResult;
176-
rustc_ast_ir::walk_visitable_list!(visitor, self.as_slice().iter());
177-
V::Result::output()
178-
}
190+
impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for $name<'db> {
191+
fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
192+
&self,
193+
visitor: &mut V,
194+
) -> V::Result {
195+
use rustc_ast_ir::visit::VisitorResult;
196+
use rustc_type_ir::inherent::SliceLike as _;
197+
rustc_ast_ir::walk_visitable_list!(visitor, self.as_slice().iter());
198+
V::Result::output()
179199
}
180200
}
181201
};
182-
($name:ty, $ty:ty, nofold) => {
183-
paste::paste! {
184-
#[salsa::interned(constructor = new_)]
185-
pub struct $name<'db> {
186-
#[returns(ref)]
187-
inner_: smallvec::SmallVec<[$ty<'db>; 2]>,
188-
}
202+
($name:ident, $ty:ident, nofold) => {
203+
#[salsa::interned(constructor = new_)]
204+
pub struct $name<'db> {
205+
#[returns(ref)]
206+
inner_: smallvec::SmallVec<[$ty<'db>; 2]>,
207+
}
189208

190-
impl<'db> std::fmt::Debug for $name<'db> {
191-
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
192-
self.as_slice().fmt(fmt)
193-
}
209+
impl<'db> std::fmt::Debug for $name<'db> {
210+
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
211+
self.as_slice().fmt(fmt)
194212
}
213+
}
195214

196-
impl<'db> $name<'db> {
197-
pub fn new_from_iter(interner: DbInterner<'db>, data: impl IntoIterator<Item = $ty<'db>>) -> Self {
198-
$name::new_(interner.db(), data.into_iter().collect::<smallvec::SmallVec<[_; 2]>>())
199-
}
215+
impl<'db> $name<'db> {
216+
pub fn new_from_iter(
217+
interner: DbInterner<'db>,
218+
data: impl IntoIterator<Item = $ty<'db>>,
219+
) -> Self {
220+
$name::new_(interner.db(), data.into_iter().collect::<smallvec::SmallVec<[_; 2]>>())
221+
}
200222

201-
pub fn inner(&self) -> &smallvec::SmallVec<[$ty<'db>; 2]> {
202-
// SAFETY: ¯\_(ツ)_/¯
203-
crate::next_solver::tls::with_db_out_of_thin_air(|db| {
204-
let inner = self.inner_(db);
205-
unsafe { std::mem::transmute(inner) }
206-
})
207-
}
223+
pub fn inner(&self) -> &smallvec::SmallVec<[$ty<'db>; 2]> {
224+
// SAFETY: ¯\_(ツ)_/¯
225+
crate::next_solver::tls::with_db_out_of_thin_air(|db| {
226+
let inner = self.inner_(db);
227+
unsafe { std::mem::transmute(inner) }
228+
})
208229
}
230+
}
209231

210-
impl<'db> rustc_type_ir::inherent::SliceLike for $name<'db> {
211-
type Item = $ty<'db>;
232+
impl<'db> rustc_type_ir::inherent::SliceLike for $name<'db> {
233+
type Item = $ty<'db>;
212234

213-
type IntoIter = <smallvec::SmallVec<[$ty<'db>; 2]> as IntoIterator>::IntoIter;
235+
type IntoIter = <smallvec::SmallVec<[$ty<'db>; 2]> as IntoIterator>::IntoIter;
214236

215-
fn iter(self) -> Self::IntoIter {
216-
self.inner().clone().into_iter()
217-
}
237+
fn iter(self) -> Self::IntoIter {
238+
self.inner().clone().into_iter()
239+
}
218240

219-
fn as_slice(&self) -> &[Self::Item] {
220-
self.inner().as_slice()
221-
}
241+
fn as_slice(&self) -> &[Self::Item] {
242+
self.inner().as_slice()
222243
}
244+
}
223245

224-
impl<'db> IntoIterator for $name<'db> {
225-
type Item = $ty<'db>;
226-
type IntoIter = <Self as rustc_type_ir::inherent::SliceLike>::IntoIter;
246+
impl<'db> IntoIterator for $name<'db> {
247+
type Item = $ty<'db>;
248+
type IntoIter = <Self as rustc_type_ir::inherent::SliceLike>::IntoIter;
227249

228-
fn into_iter(self) -> Self::IntoIter { rustc_type_ir::inherent::SliceLike::iter(self) }
250+
fn into_iter(self) -> Self::IntoIter {
251+
rustc_type_ir::inherent::SliceLike::iter(self)
229252
}
253+
}
230254

231-
impl<'db> Default for $name<'db> {
232-
fn default() -> Self {
233-
$name::new_from_iter(DbInterner::new(), [])
234-
}
255+
impl<'db> Default for $name<'db> {
256+
fn default() -> Self {
257+
$name::new_from_iter(DbInterner::new(), [])
235258
}
236259
}
237260
};

0 commit comments

Comments
 (0)