language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-26 20:09:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

internal: switch to Arc::from_iter

Browse source
This commit is contained in:
David Barsky 2023-11-28 10:36:01 -05:00
parent 7e8a3391bb
commit c17dcc8d90
7 changed files with 114 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

35
crates/hir-expand/src/attrs.rs
View file

@ -44,8 +44,7 @@ impl RawAttrs {
owner: &dyn ast::HasAttrs, owner: &dyn ast::HasAttrs,
span_map: SpanMapRef<'_>, span_map: SpanMapRef<'_>,
) -> Self { ) -> Self {
let entries = collect_attrs(owner) let entries = collect_attrs(owner).filter_map(|(id, attr)| match attr {
.filter_map(|(id, attr)| match attr {
Either::Left(attr) => { Either::Left(attr) => {
attr.meta().and_then(|meta| Attr::from_src(db, meta, span_map, id)) attr.meta().and_then(|meta| Attr::from_src(db, meta, span_map, id))
} }
@ -55,10 +54,8 @@ impl RawAttrs {
path: Interned::new(ModPath::from(crate::name!(doc))), path: Interned::new(ModPath::from(crate::name!(doc))),
ctxt: span_map.span_for_range(comment.syntax().text_range()).ctx, ctxt: span_map.span_for_range(comment.syntax().text_range()).ctx,
}), }),
}) });
.collect::<Vec<_>>(); let entries: Arc<[Attr]> = Arc::from_iter(entries);
// FIXME: use `Arc::from_iter` when it becomes available
let entries: Arc<[Attr]> = Arc::from(entries);
Self { entries: if entries.is_empty() { None } else { Some(entries) } } Self { entries: if entries.is_empty() { None } else { Some(entries) } }
} }
@ -79,19 +76,13 @@ impl RawAttrs {
(Some(a), Some(b)) => { (Some(a), Some(b)) => {
let last_ast_index = a.last().map_or(0, |it| it.id.ast_index() + 1) as u32; let last_ast_index = a.last().map_or(0, |it| it.id.ast_index() + 1) as u32;
Self { Self {
entries: Some(Arc::from( entries: Some(Arc::from_iter(a.iter().cloned().chain(b.iter().map(|it| {
a.iter()
.cloned()
.chain(b.iter().map(|it| {
let mut it = it.clone(); let mut it = it.clone();
it.id.id = it.id.ast_index() as u32 + last_ast_index it.id.id = it.id.ast_index() as u32 + last_ast_index
| (it.id.cfg_attr_index().unwrap_or(0) as u32) | (it.id.cfg_attr_index().unwrap_or(0) as u32)
<< AttrId::AST_INDEX_BITS; << AttrId::AST_INDEX_BITS;
it it
})) })))),
// FIXME: use `Arc::from_iter` when it becomes available
.collect::<Vec<_>>(),
)),
} }
} }
} }
@ -108,9 +99,7 @@ impl RawAttrs {
} }
let crate_graph = db.crate_graph(); let crate_graph = db.crate_graph();
let new_attrs = Arc::from( let new_attrs = Arc::from_iter(self.iter().flat_map(|attr| -> SmallVec<[_; 1]> {
self.iter()
.flat_map(|attr| -> SmallVec<[_; 1]> {
let is_cfg_attr = let is_cfg_attr =
attr.path.as_ident().map_or(false, |name| *name == crate::name![cfg_attr]); attr.path.as_ident().map_or(false, |name| *name == crate::name![cfg_attr]);
if !is_cfg_attr { if !is_cfg_attr {
@ -127,15 +116,14 @@ impl RawAttrs {
None => return smallvec![attr.clone()], None => return smallvec![attr.clone()],
}; };
let index = attr.id; let index = attr.id;
let attrs = parts.enumerate().take(1 << AttrId::CFG_ATTR_BITS).filter_map( let attrs =
|(idx, attr)| { parts.enumerate().take(1 << AttrId::CFG_ATTR_BITS).filter_map(|(idx, attr)| {
let tree = Subtree { let tree = Subtree {
delimiter: tt::Delimiter::dummy_invisible(), delimiter: tt::Delimiter::dummy_invisible(),
token_trees: attr.to_vec(), token_trees: attr.to_vec(),
}; };
Attr::from_tt(db, &tree, index.with_cfg_attr(idx)) Attr::from_tt(db, &tree, index.with_cfg_attr(idx))
}, });
);
let cfg_options = &crate_graph[krate].cfg_options; let cfg_options = &crate_graph[krate].cfg_options;
let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg.to_vec() }; let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg.to_vec() };
@ -147,10 +135,7 @@ impl RawAttrs {
attrs.collect() attrs.collect()
} }
}) }));
// FIXME: use `Arc::from_iter` when it becomes available
.collect::<Vec<_>>(),
);
RawAttrs { entries: Some(new_attrs) } RawAttrs { entries: Some(new_attrs) }
} }

6
crates/hir-ty/src/lib.rs
View file

@ -322,8 +322,7 @@ impl CallableSig {
pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig { pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig {
CallableSig { CallableSig {
// FIXME: what to do about lifetime params? -> return PolyFnSig // FIXME: what to do about lifetime params? -> return PolyFnSig
// FIXME: use `Arc::from_iter` when it becomes available params_and_return: Arc::from_iter(
params_and_return: Arc::from(
fn_ptr fn_ptr
.substitution .substitution
.clone() .clone()
@ -332,8 +331,7 @@ impl CallableSig {
.0 .0
.as_slice(Interner) .as_slice(Interner)
.iter() .iter()
.map(|arg| arg.assert_ty_ref(Interner).clone()) .map(|arg| arg.assert_ty_ref(Interner).clone()),
.collect::<Vec<_>>(),
), ),
is_varargs: fn_ptr.sig.variadic, is_varargs: fn_ptr.sig.variadic,
safety: fn_ptr.sig.safety, safety: fn_ptr.sig.safety,

30
crates/hir-ty/src/lower.rs
View file

@ -1459,8 +1459,7 @@ pub(crate) fn generic_predicates_for_param_recover(
_param_id: &TypeOrConstParamId, _param_id: &TypeOrConstParamId,
_assoc_name: &Option<Name>, _assoc_name: &Option<Name>,
) -> Arc<[Binders<QuantifiedWhereClause>]> { ) -> Arc<[Binders<QuantifiedWhereClause>]> {
// FIXME: use `Arc::from_iter` when it becomes available Arc::from_iter(None)
Arc::from(vec![])
} }
pub(crate) fn trait_environment_for_body_query( pub(crate) fn trait_environment_for_body_query(
@ -1603,17 +1602,11 @@ pub(crate) fn generic_defaults_query(
let generic_params = generics(db.upcast(), def); let generic_params = generics(db.upcast(), def);
let parent_start_idx = generic_params.len_self(); let parent_start_idx = generic_params.len_self();
let defaults = Arc::from( let defaults = Arc::from_iter(generic_params.iter().enumerate().map(|(idx, (id, p))| {
generic_params
.iter()
.enumerate()
.map(|(idx, (id, p))| {
match p { match p {
TypeOrConstParamData::TypeParamData(p) => { TypeOrConstParamData::TypeParamData(p) => {
let mut ty = p let mut ty =
.default p.default.as_ref().map_or(TyKind::Error.intern(Interner), |t| ctx.lower_ty(t));
.as_ref()
.map_or(TyKind::Error.intern(Interner), |t| ctx.lower_ty(t));
// Each default can only refer to previous parameters. // Each default can only refer to previous parameters.
// Type variable default referring to parameter coming // Type variable default referring to parameter coming
// after it is forbidden (FIXME: report diagnostic) // after it is forbidden (FIXME: report diagnostic)
@ -1637,10 +1630,7 @@ pub(crate) fn generic_defaults_query(
make_binders(db, &generic_params, val) make_binders(db, &generic_params, val)
} }
} }
}) }));
// FIXME: use `Arc::from_iter` when it becomes available
.collect::<Vec<_>>(),
);
defaults defaults
} }
@ -1653,19 +1643,13 @@ pub(crate) fn generic_defaults_recover(
let generic_params = generics(db.upcast(), *def); let generic_params = generics(db.upcast(), *def);
// FIXME: this code is not covered in tests. // FIXME: this code is not covered in tests.
// we still need one default per parameter // we still need one default per parameter
let defaults = Arc::from( let defaults = Arc::from_iter(generic_params.iter_id().map(|id| {
generic_params
.iter_id()
.map(|id| {
let val = match id { let val = match id {
Either::Left(_) => TyKind::Error.intern(Interner).cast(Interner), Either::Left(_) => TyKind::Error.intern(Interner).cast(Interner),
Either::Right(id) => unknown_const_as_generic(db.const_param_ty(id)), Either::Right(id) => unknown_const_as_generic(db.const_param_ty(id)),
}; };
crate::make_binders(db, &generic_params, val) crate::make_binders(db, &generic_params, val)
}) }));
// FIXME: use `Arc::from_iter` when it becomes available
.collect::<Vec<_>>(),
);
defaults defaults
} }

9
crates/hir-ty/src/method_resolution.rs
View file

@ -168,12 +168,9 @@ impl TraitImpls {
) -> Arc<[Arc<Self>]> { ) -> Arc<[Arc<Self>]> {
let _p = profile::span("trait_impls_in_deps_query").detail(|| format!("{krate:?}")); let _p = profile::span("trait_impls_in_deps_query").detail(|| format!("{krate:?}"));
let crate_graph = db.crate_graph(); let crate_graph = db.crate_graph();
// FIXME: use `Arc::from_iter` when it becomes available
Arc::from( Arc::from_iter(
crate_graph crate_graph.transitive_deps(krate).map(|krate| db.trait_impls_in_crate(krate)),
.transitive_deps(krate)
.map(|krate| db.trait_impls_in_crate(krate))
.collect::<Vec<_>>(),
) )
} }

8
crates/rust-analyzer/src/global_state.rs
View file

@ -187,11 +187,9 @@ impl GlobalState {
config_errors: Default::default(), config_errors: Default::default(),
proc_macro_changed: false, proc_macro_changed: false,
// FIXME: use `Arc::from_iter` when it becomes available proc_macro_clients: Arc::from_iter([]),
proc_macro_clients: Arc::from(Vec::new()),
// FIXME: use `Arc::from_iter` when it becomes available flycheck: Arc::from_iter([]),
flycheck: Arc::from(Vec::new()),
flycheck_sender, flycheck_sender,
flycheck_receiver, flycheck_receiver,
last_flycheck_error: None, last_flycheck_error: None,
@ -202,7 +200,7 @@ impl GlobalState {
vfs_progress_n_total: 0, vfs_progress_n_total: 0,
vfs_progress_n_done: 0, vfs_progress_n_done: 0,
workspaces: Arc::new(Vec::new()), workspaces: Arc::from(Vec::new()),
crate_graph_file_dependencies: FxHashSet::default(), crate_graph_file_dependencies: FxHashSet::default(),
fetch_workspaces_queue: OpQueue::default(), fetch_workspaces_queue: OpQueue::default(),
fetch_build_data_queue: OpQueue::default(), fetch_build_data_queue: OpQueue::default(),

6
crates/rust-analyzer/src/handlers/request.rs
View file

@ -51,8 +51,7 @@ use crate::{
}; };
pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> anyhow::Result<()> { pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> anyhow::Result<()> {
// FIXME: use `Arc::from_iter` when it becomes available state.proc_macro_clients = Arc::from_iter([]);
state.proc_macro_clients = Arc::from(Vec::new());
state.proc_macro_changed = false; state.proc_macro_changed = false;
state.fetch_workspaces_queue.request_op("reload workspace request".to_string(), false); state.fetch_workspaces_queue.request_op("reload workspace request".to_string(), false);
@ -60,8 +59,7 @@ pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> anyhow:
} }
pub(crate) fn handle_proc_macros_rebuild(state: &mut GlobalState, _: ()) -> anyhow::Result<()> { pub(crate) fn handle_proc_macros_rebuild(state: &mut GlobalState, _: ()) -> anyhow::Result<()> {
// FIXME: use `Arc::from_iter` when it becomes available state.proc_macro_clients = Arc::from_iter([]);
state.proc_macro_clients = Arc::from(Vec::new());
state.proc_macro_changed = false; state.proc_macro_changed = false;
state.fetch_build_data_queue.request_op("rebuild proc macros request".to_string(), ()); state.fetch_build_data_queue.request_op("rebuild proc macros request".to_string(), ());

10
crates/rust-analyzer/src/reload.rs
View file

@ -437,11 +437,7 @@ impl GlobalState {
if self.config.expand_proc_macros() { if self.config.expand_proc_macros() {
tracing::info!("Spawning proc-macro servers"); tracing::info!("Spawning proc-macro servers");
// FIXME: use `Arc::from_iter` when it becomes available self.proc_macro_clients = Arc::from_iter(self.workspaces.iter().map(|ws| {
self.proc_macro_clients = Arc::from(
self.workspaces
.iter()
.map(|ws| {
let path = match self.config.proc_macro_srv() { let path = match self.config.proc_macro_srv() {
Some(path) => path, Some(path) => path,
None => ws.find_sysroot_proc_macro_srv()?, None => ws.find_sysroot_proc_macro_srv()?,
@ -456,9 +452,7 @@ impl GlobalState {
"Failed to run proc-macro server from path {path}, error: {err:?}", "Failed to run proc-macro server from path {path}, error: {err:?}",
) )
}) })
}) }))
.collect::<Vec<_>>(),
)
}; };
} }