prepare for PR (tidy should pass, caching=yes by default for rustc-perf)

Author: futile

compiler/rustc_ast/src/tokenstream.rs

@@ -142,7 +142,7 @@ impl fmt::Debug for LazyAttrTokenStream {
 
 impl<S: SpanEncoder> Encodable<S> for LazyAttrTokenStream {
     fn encode(&self, _s: &mut S) {
-        // TODO(pr-time): Just a reminder that this exists/was tried out,
+        // FIXME(pr-time): Just a reminder that this exists/was tried out,
         // but probably not necessary anymore (see below).
         // self.to_attr_token_stream().encode(s)
         // We should not need to anymore, now that we `flatten`?

compiler/rustc_expand/src/derive_macro_expansion.rs

@@ -28,7 +28,7 @@ pub(super) fn provide_derive_macro_expansion<'tcx>(
         let strategy = crate::proc_macro::exec_strategy(ecx);
         let server = crate::proc_macro_server::Rustc::new(ecx);
         let res = match client.run(&strategy, server, input.clone(), proc_macro_backtrace) {
-            // TODO(pr-time): without flattened some (weird) tests fail, but no idea if it's correct/enough
+            // FIXME(pr-time): without flattened some (weird) tests fail, but no idea if it's correct/enough
             Ok(stream) => Ok(tcx.arena.alloc(stream.flattened()) as &TokenStream),
             Err(e) => {
                 ecx.dcx().emit_err({
@@ -102,11 +102,11 @@ where
     } else {
         // We could get an `CONTEXT` pointer from another thread.
         // Ensure that `CONTEXT` is `DynSync`.
-        // TODO(pr-time): we should not be able to?
+        // FIXME(pr-time): we should not be able to?
         // sync::assert_dyn_sync::<CONTEXT<'_>>();
 
         // prevent double entering, as that would allow creating two `&mut ExtCtxt`s
-        // TODO(pr-time): probably use a RefCell instead (which checks this properly)?
+        // FIXME(pr-time): probably use a RefCell instead (which checks this properly)?
         enter_context_erased((ptr::null_mut(), None), || unsafe {
             let ectx = downcast(ectx);
             f(Some(&mut (ectx, client_opt.unwrap())))

compiler/rustc_expand/src/proc_macro.rs

@@ -133,11 +133,11 @@ impl MultiItemModifier for DeriveProcMacro {
         crate::base::ann_pretty_printing_compatibility_hack(&item, &ecx.sess.psess);
         let input = item.to_tokens();
         let res = ty::tls::with(|tcx| {
-            // TODO(pr-time): without flattened some (weird) tests fail, but no idea if it's correct/enough
+            // FIXME(pr-time): without flattened some (weird) tests fail, but no idea if it's correct/enough
             let input = tcx.arena.alloc(input.flattened()) as &TokenStream;
             let invoc_id = ecx.current_expansion.id;
 
-            // TODO(pr-time): Just using the crate hash to notice when the proc-macro code has
+            // FIXME(pr-time): Just using the crate hash to notice when the proc-macro code has
             // changed. How to *correctly* depend on exactly the macro definition?
             // I.e., depending on the crate hash is just a HACK (and leaves garbage in the
             // incremental compilation dir).

compiler/rustc_session/src/options.rs

@@ -2104,8 +2104,8 @@ options! {
         "emit noalias metadata for box (default: yes)"),
     branch_protection: Option<BranchProtection> = (None, parse_branch_protection, [TRACKED],
         "set options for branch target identification and pointer authentication on AArch64"),
-    cache_all_derive_macros: bool = (false, parse_bool, [UNTRACKED],
-        "cache the results of ALL derive macro invocations (potentially unsound!) (default: no)"),
+    cache_all_derive_macros: bool = (true, parse_bool, [UNTRACKED],
+        "cache the results of ALL derive macro invocations (potentially unsound!) (default: YES -- for rustc-perf)"),
     cf_protection: CFProtection = (CFProtection::None, parse_cfprotection, [TRACKED],
         "instrument control-flow architecture protection"),
     check_cfg_all_expected: bool = (false, parse_bool, [UNTRACKED],

tests/incremental/derive_macro_expansion/proc_macro_unchanged.rs

@@ -4,7 +4,7 @@
 // The proc-macro (for `Nothing`) prints a message to stderr when invoked,
 // and this message should only be present during the second invocation
 // (which has `cfail2` set via cfg).
-// TODO(pr-time): Properly have the test check this, but how? UI-test that tests for `.stderr`?
+// FIXME(pr-time): Properly have the test check this, but how? UI-test that tests for `.stderr`?
 
 //@ aux-build:derive_nothing.rs
 //@ revisions:cfail1 cfail2