Make Iterator a lang item

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1414,7 +1414,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             && let Some(loop_span) = finder.loop_span
             && let Some(def_id) = typeck_results.type_dependent_def_id(body_expr.hir_id)
             && let Some(trait_did) = tcx.trait_of_item(def_id)
-            && tcx.is_diagnostic_item(sym::Iterator, trait_did)
+            && tcx.lang_items().iterator_trait() == Some(trait_did)
         {
             if let Some(loop_bind) = finder.loop_bind {
                 err.note(format!(
@@ -2457,7 +2457,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             let return_ty = self.regioncx.universal_regions().unnormalized_output_ty;
 
             // to avoid panics
-            if let Some(iter_trait) = tcx.get_diagnostic_item(sym::Iterator)
+            if let Some(iter_trait) = tcx.lang_items().iterator_trait()
                 && self
                     .infcx
                     .type_implements_trait(iter_trait, [return_ty], self.param_env)

compiler/rustc_hir/src/lang_items.rs

@@ -210,6 +210,7 @@ language_item_table! {
 
     FnOnceOutput,            sym::fn_once_output,      fn_once_output,             Target::AssocTy,        GenericRequirement::None;
 
+    Iterator,                sym::iterator,            iterator_trait,             Target::Trait,          GenericRequirement::Exact(0);
     Future,                  sym::future_trait,        future_trait,               Target::Trait,          GenericRequirement::Exact(0);
     CoroutineState,          sym::coroutine_state,     gen_state,                  Target::Enum,           GenericRequirement::None;
     Coroutine,               sym::coroutine,           gen_trait,                  Target::Trait,          GenericRequirement::Minimum(1);

compiler/rustc_hir_analysis/src/collect.rs

@@ -1296,7 +1296,7 @@ fn suggest_impl_trait<'tcx>(
 
     for (trait_def_id, assoc_item_def_id, formatter) in [
         (
-            tcx.get_diagnostic_item(sym::Iterator),
+            tcx.lang_items().iterator_trait(),
             tcx.get_diagnostic_item(sym::IteratorItem),
             format_as_assoc,
         ),

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -549,7 +549,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             } else {
                 err.span_label(span, msg);
             }
-            if let Some(iterator_trait) = self.tcx.get_diagnostic_item(sym::Iterator) {
+            if let Some(iterator_trait) = self.tcx.lang_items().iterator_trait() {
                 let iterator_trait = self.tcx.def_path_str(iterator_trait);
                 err.note(format!(
                     "`count` is defined on `{iterator_trait}`, which `{rcvr_ty}` does not implement"

compiler/rustc_interface/src/passes.rs

@@ -856,6 +856,11 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
         // This check has to be run after all lints are done processing. We don't
         // define a lint filter, as all lint checks should have finished at this point.
         sess.time("check_lint_expectations", || tcx.ensure().check_expectations(None));
+
+        // This query is only invoked normally if a diagnostic is emitted that needs any
+        // diagnostic item. If the crate compiles without checking any diagnostic items,
+        // we will fail to emit overlap diagnostics. Thus we invoke it here unconditionally.
+        let _ = tcx.all_diagnostic_items(());
     });
 
     if sess.opts.unstable_opts.print_vtable_sizes {

compiler/rustc_lint/src/builtin.rs

@@ -685,7 +685,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations {
 
         // We shouldn't recommend implementing `Copy` on stateful things,
         // such as iterators.
-        if let Some(iter_trait) = cx.tcx.get_diagnostic_item(sym::Iterator)
+        if let Some(iter_trait) = cx.tcx.lang_items().iterator_trait()
             && cx
                 .tcx
                 .infer_ctxt()

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -1517,7 +1517,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                     "expected `{self_ty}` to be a future that resolves to `{expected_ty}`, but it \
                      resolves to `{normalized_ty}`"
                 ))
-            } else if Some(trait_def_id) == self.tcx.get_diagnostic_item(sym::Iterator) {
+            } else if Some(trait_def_id) == self.tcx.lang_items().iterator_trait() {
                 Some(format!(
                     "expected `{self_ty}` to be an iterator that yields `{expected_ty}`, but it \
                      yields `{normalized_ty}`"

library/core/src/iter/traits/iterator.rs

@@ -69,6 +69,7 @@ fn _assert_is_object_safe(_: &dyn Iterator<Item = ()>) {}
     message = "`{Self}` is not an iterator"
 )]
 #[doc(notable_trait)]
+#[cfg_attr(not(bootstrap), lang = "iterator")]
 #[rustc_diagnostic_item = "Iterator"]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub trait Iterator {