Apply review remarks

Author: Kobzol

compiler/rustc_ast/src/ast.rs

@@ -3348,18 +3348,8 @@ impl UseTree {
 /// Distinguishes between `Attribute`s that decorate items and Attributes that
 /// are contained as statements within items. These two cases need to be
 /// distinguished for pretty-printing.
-#[derive(
-    Clone,
-    PartialEq,
-    Eq,
-    Encodable,
-    Decodable,
-    Hash,
-    Debug,
-    Copy,
-    HashStable_Generic,
-    Walkable
-)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug, Copy)]
+#[derive(Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum AttrStyle {
     Outer,
     Inner,

compiler/rustc_expand/src/lib.rs

@@ -29,7 +29,7 @@ pub mod module;
 #[allow(rustc::untranslatable_diagnostic)]
 pub mod proc_macro;
 
-pub fn provide(providers: &mut rustc_middle::util::Providers) {
+pub fn provide(providers: &mut rustc_middle::query::Providers) {
     providers.derive_macro_expansion = proc_macro::provide_derive_macro_expansion;
 }
 

compiler/rustc_expand/src/proc_macro.rs

@@ -139,8 +139,8 @@ impl MultiItemModifier for DeriveProcMacro {
             && ecx.sess.opts.unstable_opts.cache_proc_macros
         {
             ty::tls::with(|tcx| {
-                let input = tcx.arena.alloc(input) as &TokenStream;
-                let key = (invoc_id, input);
+                let input = &*tcx.arena.alloc(input);
+                let key: (LocalExpnId, &TokenStream) = (invoc_id, input);
 
                 QueryDeriveExpandCtx::enter(ecx, self.client, move || {
                     tcx.derive_macro_expansion(key).cloned()
@@ -196,8 +196,7 @@ pub(super) fn provide_derive_macro_expansion<'tcx>(
     let _ = tcx.crate_hash(invoc_id.expn_data().macro_def_id.unwrap().krate);
 
     QueryDeriveExpandCtx::with(|ecx, client| {
-        expand_derive_macro(invoc_id, input.clone(), ecx, client)
-            .map(|ts| tcx.arena.alloc(ts) as &TokenStream)
+        expand_derive_macro(invoc_id, input.clone(), ecx, client).map(|ts| &*tcx.arena.alloc(ts))
     })
 }
 
@@ -209,11 +208,11 @@ fn expand_derive_macro(
     ecx: &mut ExtCtxt<'_>,
     client: DeriveClient,
 ) -> Result<TokenStream, ()> {
-    let invoc_expn_data = invoc_id.expn_data();
-    let span = invoc_expn_data.call_site;
-    let event_arg = invoc_expn_data.kind.descr();
     let _timer =
         ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
+            let invoc_expn_data = invoc_id.expn_data();
+            let span = invoc_expn_data.call_site;
+            let event_arg = invoc_expn_data.kind.descr();
             recorder.record_arg_with_span(ecx.sess.source_map(), event_arg.clone(), span);
         });
 
@@ -224,6 +223,8 @@ fn expand_derive_macro(
     match client.run(&strategy, server, input, proc_macro_backtrace) {
         Ok(stream) => Ok(stream),
         Err(e) => {
+            let invoc_expn_data = invoc_id.expn_data();
+            let span = invoc_expn_data.call_site;
             ecx.dcx().emit_err({
                 errors::ProcMacroDerivePanicked {
                     span,

compiler/rustc_incremental/src/persist/dirty_clean.rs

@@ -26,10 +26,9 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{
     Attribute, ImplItemKind, ItemKind as HirItem, Node as HirNode, TraitItemKind, intravisit,
 };
-use rustc_middle::dep_graph::{DepKind, DepNode, DepNodeExt, dep_kind_from_label, label_strs};
+use rustc_middle::dep_graph::{DepNode, DepNodeExt, dep_kind_from_label, label_strs};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
-use rustc_span::def_id::DefPathHash;
 use rustc_span::{Span, Symbol, sym};
 use thin_vec::ThinVec;
 use tracing::debug;
@@ -358,29 +357,6 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
         }
     }
 
-    fn assert_loaded_from_disk(&self, item_span: Span, dep_item: DepItem) {
-        debug!("assert_loaded_from_disk({:?})", dep_item);
-
-        match dep_item {
-            DepItem::DepNode(dep_node) => {
-                if !self.tcx.dep_graph.debug_was_loaded_from_disk(dep_node) {
-                    let dep_node_str = self.dep_node_str(&dep_node);
-                    self.tcx.dcx().emit_err(errors::NotLoaded {
-                        span: item_span,
-                        dep_node_str: &dep_node_str,
-                    });
-                }
-            }
-            DepItem::DepKind { kind, label } => {
-                if !self.tcx.dep_graph.debug_dep_kind_was_loaded_from_disk(kind) {
-                    self.tcx
-                        .dcx()
-                        .emit_err(errors::NotLoaded { span: item_span, dep_node_str: &label });
-                }
-            }
-        }
-    }
-
     fn check_item(&mut self, item_id: LocalDefId) {
         let item_span = self.tcx.def_span(item_id.to_def_id());
         let def_path_hash = self.tcx.def_path_hash(item_id.to_def_id());
@@ -398,34 +374,32 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
                 self.assert_dirty(item_span, dep_node);
             }
             for label in assertion.loaded_from_disk.items().into_sorted_stable_ord() {
-                let dep_item = resolve_dep_item(self.tcx, label, def_path_hash);
-                self.assert_loaded_from_disk(item_span, dep_item);
+                let dep_kind = dep_kind_from_label(label);
+                match DepNode::from_label_string(self.tcx, label, def_path_hash) {
+                    Ok(dep_node) => {
+                        if !self.tcx.dep_graph.debug_was_loaded_from_disk(dep_node) {
+                            let dep_node_str = self.dep_node_str(&dep_node);
+                            self.tcx.dcx().emit_err(errors::NotLoaded {
+                                span: item_span,
+                                dep_node_str: &dep_node_str,
+                            });
+                        }
+                    }
+                    // Opaque/unit hash, we only know the dep kind
+                    Err(()) => {
+                        if !self.tcx.dep_graph.debug_dep_kind_was_loaded_from_disk(dep_kind) {
+                            self.tcx.dcx().emit_err(errors::NotLoaded {
+                                span: item_span,
+                                dep_node_str: &label,
+                            });
+                        }
+                    }
+                }
             }
         }
     }
 }
 
-/// Represents a query that we want to test for dirtiness.
-#[derive(Debug)]
-enum DepItem {
-    /// We have a DepNode for this query.
-    DepNode(DepNode),
-    /// This query has an opaque or a unit hash fingerprint, so we cannot resolve a DepNode for it.
-    /// We thus only store the DepKind, so that we can check if *any* query with the given label
-    /// was executed, regardless of its query arguments.
-    DepKind { kind: DepKind, label: String },
-}
-
-fn resolve_dep_item(tcx: TyCtxt<'_>, label: &str, def_path_hash: DefPathHash) -> DepItem {
-    let dep_kind = dep_kind_from_label(label).unwrap(); // Ensure that the query label is known
-
-    match DepNode::from_label_string(tcx, label, def_path_hash) {
-        Ok(dep_node) => DepItem::DepNode(dep_node),
-        // Opaque/unit hash, we only know the dep kind
-        Err(()) => DepItem::DepKind { kind: dep_kind, label: label.to_owned() },
-    }
-}
-
 /// Given a `#[rustc_clean]` attribute, scan for a `cfg="foo"` attribute and check whether we have
 /// a cfg flag called `foo`.
 fn check_config(tcx: TyCtxt<'_>, attr: &Attribute) -> bool {

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -176,9 +176,10 @@ impl DepNodeExt for DepNode {
     }
 }
 
-/// Maps a query label to its DepKind, if it exists.
-pub fn dep_kind_from_label(label: &str) -> Option<DepKind> {
-    dep_kind_from_label_string(label).ok()
+/// Maps a query label to its DepKind. Panics if a query with the given label does not exist.
+pub fn dep_kind_from_label(label: &str) -> DepKind {
+    dep_kind_from_label_string(label)
+        .unwrap_or_else(|_| panic!("Query label {label} does not exist"))
 }
 
 impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for () {

tests/incremental/derive_macro_expansion/auxiliary/derive_nothing.rs

@@ -1,8 +1,3 @@
-//@ force-host
-//@ no-prefer-dynamic
-
-#![crate_type = "proc-macro"]
-
 extern crate proc_macro;
 use proc_macro::TokenStream;
 

tests/incremental/derive_macro_expansion/proc_macro_unchanged.rs

@@ -1,8 +1,9 @@
-// This test tests that derive-macro execution is cached.
+// This test tests that derive proc macro execution is cached.
 
-//@ aux-build:derive_nothing.rs
+//@ proc-macro:derive_nothing.rs
 //@ revisions:rpass1 rpass2
 //@ compile-flags: -Zquery-dep-graph -Zcache-proc-macros
+//@ ignore-backends: gcc
 
 #![feature(rustc_attrs)]