Always make compiler_builtins a private dependency

`compiler_builtins` is always available as an injected dependency,
introduced in AST as `extern crate compiler_builtins as _`. This makes
it indistinguishable from any other user-specified `extern crate`,
meaning `is_private_dep` does not see it as a dependency that should be
marked private; this is the reason that `compiler_builtins` sometimes
leaks into diagnostics, and has slightly different behavior from other
stdlib dependencies tested in [1].

There is no easy way to know that an instance of `extern crate
compiler_builtins` was the injected version; however,
`compiler_builtins`

To get around this, always mark `compiler_builtins` private. The items
in this crate are never used directly, and this is the most

[1]: rust-lang#135278

Author: tgross35

compiler/rustc_builtin_macros/src/standard_library_imports.rs

@@ -53,6 +53,8 @@ pub fn inject(
             //
             // FIXME(#113634) We should inject this during post-processing like
             // we do for the panic runtime, profiler runtime, etc.
+            //
+            // See also `is_private_dep` within `rustc_metadata`.
             cx.item(
                 span,
                 Ident::new(kw::Underscore, ident_span),

compiler/rustc_metadata/src/creader.rs

@@ -414,6 +414,12 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
 
         let extern_private = self.sess.opts.externs.get(name.as_str()).map(|e| e.is_private_dep);
 
+        if name == sym::compiler_builtins {
+            // compiler_builtins is a private implementation detail and should never show up in
+            // diagnostics. See also the note referencing #113634 in
+            // `rustc_builtin_macros::...::inject`.
+            return true;
+        }
         // Any descendants of `std` should be private. These crates are usually not marked
         // private in metadata, so we ignore that field.
         if extern_private.is_none()