.collect() directly into Arc<[T]>

crates/ra_hir/src/ty.rs

@@ -329,8 +329,7 @@ impl Substs {
                 .params_including_parent()
                 .into_iter()
                 .map(|p| Ty::Param { idx: p.idx, name: p.name.clone() })
-                .collect::<Vec<_>>()
-                .into(),
+                .collect(),
         )
     }
 
@@ -341,8 +340,7 @@ impl Substs {
                 .params_including_parent()
                 .into_iter()
                 .map(|p| Ty::Bound(p.idx))
-                .collect::<Vec<_>>()
-                .into(),
+                .collect(),
         )
     }
 

crates/ra_hir/src/ty/lower.rs

@@ -31,11 +31,11 @@ impl Ty {
         match type_ref {
             TypeRef::Never => Ty::simple(TypeCtor::Never),
             TypeRef::Tuple(inner) => {
-                let inner_tys =
-                    inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
+                let inner_tys: Arc<[Ty]> =
+                    inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect();
                 Ty::apply(
                     TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
-                    Substs(inner_tys.into()),
+                    Substs(inner_tys),
                 )
             }
             TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path),
@@ -57,9 +57,7 @@ impl Ty {
             }
             TypeRef::Placeholder => Ty::Unknown,
             TypeRef::Fn(params) => {
-                let inner_tys =
-                    params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
-                let sig = Substs(inner_tys.into());
+                let sig = Substs(params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect());
                 Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
             }
             TypeRef::DynTrait(bounds) => {
@@ -69,8 +67,8 @@ impl Ty {
                     .flat_map(|b| {
                         GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
                     })
-                    .collect::<Vec<_>>();
-                Ty::Dyn(predicates.into())
+                    .collect();
+                Ty::Dyn(predicates)
             }
             TypeRef::ImplTrait(bounds) => {
                 let self_ty = Ty::Bound(0);
@@ -79,8 +77,8 @@ impl Ty {
                     .flat_map(|b| {
                         GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
                     })
-                    .collect::<Vec<_>>();
-                Ty::Opaque(predicates.into())
+                    .collect();
+                Ty::Opaque(predicates)
             }
             TypeRef::Error => Ty::Unknown,
         }
@@ -557,13 +555,12 @@ pub(crate) fn generic_predicates_for_param_query(
     param_idx: u32,
 ) -> Arc<[GenericPredicate]> {
     let resolver = def.resolver(db);
-    let predicates = resolver
+    resolver
         .where_predicates_in_scope()
         // we have to filter out all other predicates *first*, before attempting to lower them
         .filter(|pred| Ty::from_hir_only_param(db, &resolver, &pred.type_ref) == Some(param_idx))
         .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
-        .collect::<Vec<_>>();
-    predicates.into()
+        .collect()
 }
 
 pub(crate) fn trait_env(
@@ -584,11 +581,10 @@ pub(crate) fn generic_predicates_query(
     def: GenericDef,
 ) -> Arc<[GenericPredicate]> {
     let resolver = def.resolver(db);
-    let predicates = resolver
+    resolver
         .where_predicates_in_scope()
         .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
-        .collect::<Vec<_>>();
-    predicates.into()
+        .collect()
 }
 
 /// Resolve the default type params from generics
@@ -602,9 +598,9 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) ->
         .map(|p| {
             p.default.as_ref().map_or(Ty::Unknown, |path| Ty::from_hir_path(db, &resolver, path))
         })
-        .collect::<Vec<_>>();
+        .collect();
 
-    Substs(defaults.into())
+    Substs(defaults)
 }
 
 fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {

crates/ra_hir/src/ty/traits.rs

@@ -89,7 +89,7 @@ pub(crate) fn impls_for_trait_query(
     }
     let crate_impl_blocks = db.impls_in_crate(krate);
     impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_));
-    impls.into_iter().collect::<Vec<_>>().into()
+    impls.into_iter().collect()
 }
 
 /// A set of clauses that we assume to be true. E.g. if we are inside this function:

crates/ra_hir/src/ty/traits/chalk.rs

@@ -126,8 +126,7 @@ impl ToChalk for Substs {
                 chalk_ir::Parameter(chalk_ir::ParameterKind::Ty(ty)) => from_chalk(db, ty),
                 chalk_ir::Parameter(chalk_ir::ParameterKind::Lifetime(_)) => unimplemented!(),
             })
-            .collect::<Vec<_>>()
-            .into();
+            .collect();
         Substs(tys)
     }
 }