Revert "fixup warnings around the compiler"

This reverts commit f201752.

Author: jdonszelmann

compiler/rustc_codegen_ssa/src/back/metadata.rs

@@ -86,8 +86,7 @@ impl MetadataLoader for DefaultMetadataLoader {
                     format!("failed to parse aix dylib '{}': {}", path.display(), e)
                 })?;
 
-                // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-                match Itertools::exactly_one(archive.members()) {
+                match archive.members().exactly_one() {
                     Ok(lib) => {
                         let lib = lib.map_err(|e| {
                             format!("failed to parse aix dylib '{}': {}", path.display(), e)

src/librustdoc/html/format.rs

@@ -1126,8 +1126,7 @@ pub(crate) fn print_impl(
             }
             if impl_.kind.is_fake_variadic()
                 && let Some(generics) = ty.generics()
-                // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-                && let Ok(inner_type) = Itertools::exactly_one(generics)
+                && let Ok(inner_type) = generics.exactly_one()
             {
                 let last = ty.last();
                 if f.alternate() {
@@ -1207,8 +1206,7 @@ impl clean::Impl {
             }
         } else if let clean::Type::Path { path } = type_
             && let Some(generics) = path.generics()
-            // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-            && let Ok(ty) = Itertools::exactly_one(generics)
+            && let Ok(ty) = generics.exactly_one()
             && self.kind.is_fake_variadic()
         {
             print_anchor(path.def_id(), path.last(), cx).fmt(f)?;

src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs

@@ -92,8 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
                     (matches!(v.data, VariantData::Unit(_, _)) && is_doc_hidden(cx.tcx.hir_attrs(v.hir_id)))
                         .then_some((v.def_id, v.span))
                 });
-                // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-                if let Ok((id, span)) = Itertools::exactly_one(iter)
+                if let Ok((id, span)) = iter.exactly_one()
                     && !find_attr!(cx.tcx.hir_attrs(item.hir_id()), AttributeKind::NonExhaustive(..))
                 {
                     self.potential_enums.push((item.owner_id.def_id, id, item.span, span));
@@ -105,8 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
                     .iter()
                     .filter(|field| !cx.effective_visibilities.is_exported(field.def_id));
                 if fields.len() > 1
-                    // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-                    && let Ok(field) = Itertools::exactly_one(private_fields)
+                    && let Ok(field) = private_fields.exactly_one()
                     && let TyKind::Tup([]) = field.ty.kind
                 {
                     span_lint_and_then(

src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs

@@ -786,8 +786,7 @@ fn parse_string(tt: &tt::TopSubtree) -> Result<(Symbol, Span), ExpandError> {
             && let DelimiterKind::Parenthesis | DelimiterKind::Invisible = sub.delimiter.kind
         {
             tt =
-                // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-                Itertools::exactly_one(tt_iter).map_err(|_| sub.delimiter.open.cover(sub.delimiter.close))?;
+                tt_iter.exactly_one().map_err(|_| sub.delimiter.open.cover(sub.delimiter.close))?;
         }
 
         match tt {

src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs

@@ -163,8 +163,7 @@ pub(crate) fn convert_bool_then_to_if(acc: &mut Assists, ctx: &AssistContext<'_>
     let name_ref = ctx.find_node_at_offset::<ast::NameRef>()?;
     let mcall = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast)?;
     let receiver = mcall.receiver()?;
-    // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-    let closure_body = Itertools::exactly_one(mcall.arg_list()?.args()).ok()?;
+    let closure_body = mcall.arg_list()?.args().exactly_one().ok()?;
     let closure_body = match closure_body {
         ast::Expr::ClosureExpr(expr) => expr.body()?,
         _ => return None,

src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_range_for_to_while.rs

@@ -113,7 +113,7 @@ fn extract_range(iterable: &ast::Expr) -> Option<(ast::Expr, Option<ast::Expr>,
             (range.start()?, range.end(), make::expr_literal("1").into(), inclusive)
         }
         ast::Expr::MethodCallExpr(call) if call.name_ref()?.text() == "step_by" => {
-            let [step] = Itertools::collect_array(call.arg_list()?.args())?;
+            let [step] = call.arg_list()?.args().collect_array()?;
             let (start, end, _, inclusive) = extract_range(&call.receiver()?)?;
             (start, end, step, inclusive)
         }

src/tools/rust-analyzer/crates/ide-completion/src/tests/raw_identifiers.rs

@@ -8,8 +8,9 @@ fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
     let completions = completion_list_with_config_raw(TEST_CONFIG, ra_fixture, true, None);
     let (db, position) = position(ra_fixture);
     let mut actual = db.file_text(position.file_id).text(&db).to_string();
-    // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-    Itertools::exactly_one(completions.into_iter())
+    completions
+        .into_iter()
+        .exactly_one()
         .expect("more than one completion")
         .text_edit
         .apply(&mut actual);

src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/support.rs

@@ -113,8 +113,7 @@ impl Project<'_> {
         let mut buf = Vec::new();
         flags::Lsif::run(
             flags::Lsif {
-                // FIXME: rewrite in terms of `#![feature(exact_length_collection)]`. See: #149266
-                path: tmp_dir_path.join(Itertools::exactly_one(self.roots.iter()).unwrap()).into(),
+                path: tmp_dir_path.join(self.roots.iter().exactly_one().unwrap()).into(),
                 exclude_vendored_libraries: false,
             },
             &mut buf,

tests/ui/const-generics/type-dependent/issue-71805.rs

@@ -4,7 +4,7 @@ use std::mem::MaybeUninit;
 trait CollectSlice<'a>: Iterator {
     fn inner_array<const N: usize>(&mut self) -> [Self::Item; N];
 
-    fn custom_collect_array<const N: usize>(&mut self) -> [Self::Item; N] {
+    fn collect_array<const N: usize>(&mut self) -> [Self::Item; N] {
         let result = self.inner_array();
         assert!(self.next().is_none());
         result
@@ -34,5 +34,5 @@ where
 
 fn main() {
     let mut foos = [0u64; 9].iter().cloned();
-    let _bar: [u64; 9] = foos.custom_collect_array::<9_usize>();
+    let _bar: [u64; 9] = foos.collect_array::<9_usize>();
 }

tests/ui/mir/mir-inlining/ice-issue-77564.rs

@@ -29,11 +29,10 @@ where
 
 fn main() {
     assert_eq!(
-        CollectArray::collect_array(
-            &mut [[1, 2], [3, 4]]
+        [[1, 2], [3, 4]]
             .iter()
-            .map(|row| CollectArray::collect_array(&mut row.iter()))
-        ),
+            .map(|row| row.iter().collect_array())
+            .collect_array(),
         [[&1, &2], [&3, &4]]
     );
 }