From b53761969fa7954e4de4d6bb890addc23d668608 Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Thu, 11 Aug 2022 19:54:42 -0500 Subject: Remove `$tcx` metavariable from `rustc_query_append` It's not actually necessary and it makes the code harder to read. --- compiler/rustc_query_impl/src/lib.rs | 2 +- compiler/rustc_query_impl/src/plumbing.rs | 58 ++++++++++------------ compiler/rustc_query_impl/src/profiling_support.rs | 4 +- 3 files changed, 30 insertions(+), 34 deletions(-) (limited to 'compiler/rustc_query_impl/src') diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs index df187ea0c94..d8c85ab9faa 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -55,7 +55,7 @@ fn describe_as_module(def_id: LocalDefId, tcx: TyCtxt<'_>) -> String { } } -rustc_query_append! { [define_queries!][<'tcx>] } +rustc_query_append! { [define_queries!] } impl<'tcx> Queries<'tcx> { // Force codegen in the dyn-trait transformation in this crate. diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index 339683cf689..cb54edb2952 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -234,11 +234,10 @@ macro_rules! get_provider { } macro_rules! define_queries { - (<$tcx:tt> + ( $($(#[$attr:meta])* [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty,)*) => { define_queries_struct! { - tcx: $tcx, input: ($(([$($modifiers)*] [$($attr)*] [$name]))*) } @@ -247,7 +246,7 @@ macro_rules! define_queries { // Create an eponymous constructor for each query. $(#[allow(nonstandard_style)] $(#[$attr])* - pub fn $name<$tcx>(tcx: QueryCtxt<$tcx>, key: query_keys::$name<$tcx>) -> QueryStackFrame { + pub fn $name<'tcx>(tcx: QueryCtxt<'tcx>, key: query_keys::$name<'tcx>) -> QueryStackFrame { let kind = dep_graph::DepKind::$name; let name = stringify!($name); // Disable visible paths printing for performance reasons. @@ -295,32 +294,32 @@ macro_rules! define_queries { mod queries { use std::marker::PhantomData; - $(pub struct $name<$tcx> { - data: PhantomData<&$tcx ()> + $(pub struct $name<'tcx> { + data: PhantomData<&'tcx ()> })* } - $(impl<$tcx> QueryConfig for queries::$name<$tcx> { - type Key = query_keys::$name<$tcx>; - type Value = query_values::$name<$tcx>; - type Stored = query_stored::$name<$tcx>; + $(impl<'tcx> QueryConfig for queries::$name<'tcx> { + type Key = query_keys::$name<'tcx>; + type Value = query_values::$name<'tcx>; + type Stored = query_stored::$name<'tcx>; const NAME: &'static str = stringify!($name); } - impl<$tcx> QueryDescription> for queries::$name<$tcx> { - rustc_query_description! { $name<$tcx> } + impl<'tcx> QueryDescription> for queries::$name<'tcx> { + rustc_query_description! { $name<'tcx> } - type Cache = query_storage::$name<$tcx>; + type Cache = query_storage::$name<'tcx>; #[inline(always)] - fn query_state<'a>(tcx: QueryCtxt<$tcx>) -> &'a QueryState - where QueryCtxt<$tcx>: 'a + fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState + where QueryCtxt<'tcx>: 'a { &tcx.queries.$name } #[inline(always)] - fn query_cache<'a>(tcx: QueryCtxt<$tcx>) -> &'a Self::Cache + fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cache where 'tcx:'a { &tcx.query_caches.$name @@ -328,7 +327,7 @@ macro_rules! define_queries { #[inline] fn make_vtable(tcx: QueryCtxt<'tcx>, key: &Self::Key) -> - QueryVTable, Self::Key, Self::Value> + QueryVTable, Self::Key, Self::Value> { let compute = get_provider!([$($modifiers)*][tcx, $name, key]); let cache_on_disk = Self::cache_on_disk(tcx.tcx, key); @@ -465,28 +464,25 @@ macro_rules! define_queries { } } -// FIXME(eddyb) this macro (and others?) use `$tcx` and `'tcx` interchangeably. -// We should either not take `$tcx` at all and use `'tcx` everywhere, or use -// `$tcx` everywhere (even if that isn't necessary due to lack of hygiene). macro_rules! define_queries_struct { - (tcx: $tcx:tt, + ( input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => { - pub struct Queries<$tcx> { + pub struct Queries<'tcx> { local_providers: Box, extern_providers: Box, - pub on_disk_cache: Option>, + pub on_disk_cache: Option>, jobs: AtomicU64, - $($(#[$attr])* $name: QueryState>,)* + $($(#[$attr])* $name: QueryState>,)* } - impl<$tcx> Queries<$tcx> { + impl<'tcx> Queries<'tcx> { pub fn new( local_providers: Providers, extern_providers: ExternProviders, - on_disk_cache: Option>, + on_disk_cache: Option>, ) -> Self { Queries { local_providers: Box::new(local_providers), @@ -498,8 +494,8 @@ macro_rules! define_queries_struct { } pub(crate) fn try_collect_active_jobs( - &$tcx self, - tcx: TyCtxt<$tcx>, + &'tcx self, + tcx: TyCtxt<'tcx>, ) -> Option { let tcx = QueryCtxt { tcx, queries: self }; let mut jobs = QueryMap::default(); @@ -532,13 +528,13 @@ macro_rules! define_queries_struct { #[tracing::instrument(level = "trace", skip(self, tcx))] fn $name( &'tcx self, - tcx: TyCtxt<$tcx>, + tcx: TyCtxt<'tcx>, span: Span, - key: query_keys::$name<$tcx>, + key: query_keys::$name<'tcx>, mode: QueryMode, - ) -> Option> { + ) -> Option> { let qcx = QueryCtxt { tcx, queries: self }; - get_query::, _>(qcx, span, key, mode) + get_query::, _>(qcx, span, key, mode) })* } }; diff --git a/compiler/rustc_query_impl/src/profiling_support.rs b/compiler/rustc_query_impl/src/profiling_support.rs index 551f094209e..34586750947 100644 --- a/compiler/rustc_query_impl/src/profiling_support.rs +++ b/compiler/rustc_query_impl/src/profiling_support.rs @@ -306,7 +306,7 @@ pub fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) { let mut string_cache = QueryKeyStringCache::new(); macro_rules! alloc_once { - (<$tcx:tt> + ( $($(#[$attr:meta])* [$($modifiers:tt)*] fn $name:ident($K:ty) -> $V:ty,)* ) => { $({ @@ -320,5 +320,5 @@ pub fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) { } } - rustc_query_append! { [alloc_once!][<'tcx>] } + rustc_query_append! { [alloc_once!] } } -- cgit 1.4.1-3-g733a5 From 1de08b19d1ee7ae337b93b11fb971d37ffbb6968 Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Thu, 11 Aug 2022 20:20:46 -0500 Subject: Get rid of some usages of `query_keys` Rustdoc documents these with the name of the type alias instead of normalizing them to the underlying type. Use associated types instead so that the generated docs for nightly-rustc are easier to read. --- compiler/rustc_query_impl/src/plumbing.rs | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) (limited to 'compiler/rustc_query_impl/src') diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index cb54edb2952..30ca93c7233 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -246,7 +246,7 @@ macro_rules! define_queries { // Create an eponymous constructor for each query. $(#[allow(nonstandard_style)] $(#[$attr])* - pub fn $name<'tcx>(tcx: QueryCtxt<'tcx>, key: query_keys::$name<'tcx>) -> QueryStackFrame { + pub fn $name<'tcx>(tcx: QueryCtxt<'tcx>, key: as QueryConfig>::Key) -> QueryStackFrame { let kind = dep_graph::DepKind::$name; let name = stringify!($name); // Disable visible paths printing for performance reasons. @@ -348,7 +348,6 @@ macro_rules! define_queries { mod query_callbacks { use super::*; use rustc_middle::dep_graph::DepNode; - use rustc_middle::ty::query::query_keys; use rustc_query_system::dep_graph::DepNodeParams; use rustc_query_system::query::{force_query, QueryDescription}; use rustc_query_system::dep_graph::FingerprintStyle; @@ -410,7 +409,7 @@ macro_rules! define_queries { let is_eval_always = is_eval_always!([$($modifiers)*]); let fingerprint_style = - as DepNodeParams>>::fingerprint_style(); + < as QueryConfig>::Key as DepNodeParams>>::fingerprint_style(); if is_anon || !fingerprint_style.reconstructible() { return DepKindStruct { @@ -423,8 +422,8 @@ macro_rules! define_queries { } #[inline(always)] - fn recover<'tcx>(tcx: TyCtxt<'tcx>, dep_node: DepNode) -> Option> { - as DepNodeParams>>::recover(tcx, &dep_node) + fn recover<'tcx>(tcx: TyCtxt<'tcx>, dep_node: DepNode) -> Option< as QueryConfig>::Key> { + < as QueryConfig>::Key as DepNodeParams>>::recover(tcx, &dep_node) } fn force_from_dep_node(tcx: TyCtxt<'_>, dep_node: DepNode) -> bool { @@ -475,7 +474,7 @@ macro_rules! define_queries_struct { jobs: AtomicU64, - $($(#[$attr])* $name: QueryState>,)* + $($(#[$attr])* $name: QueryState< as QueryConfig>::Key>,)* } impl<'tcx> Queries<'tcx> { @@ -530,7 +529,7 @@ macro_rules! define_queries_struct { &'tcx self, tcx: TyCtxt<'tcx>, span: Span, - key: query_keys::$name<'tcx>, + key: as QueryConfig>::Key, mode: QueryMode, ) -> Option> { let qcx = QueryCtxt { tcx, queries: self }; -- cgit 1.4.1-3-g733a5 From 0bedd354ca3c5438f5f5a3b0b06b3ead6ffec374 Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Thu, 11 Aug 2022 20:36:13 -0500 Subject: Move most of `make_query` into a generic function, away from the macro This should both make the code easier to read and also greatly reduce the amount of codegen the compiler has to do, since it only needs to monomorphize `create_query_frame` for each new key and not for each query. --- compiler/rustc_query_impl/src/lib.rs | 1 - compiler/rustc_query_impl/src/plumbing.rs | 97 ++++++++++++++++++------------- 2 files changed, 56 insertions(+), 42 deletions(-) (limited to 'compiler/rustc_query_impl/src') diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs index d8c85ab9faa..946bc34fea1 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -15,7 +15,6 @@ extern crate rustc_macros; #[macro_use] extern crate rustc_middle; -use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::sync::AtomicU64; use rustc_middle::arena::Arena; use rustc_middle::dep_graph::{self, DepKindStruct, SerializedDepNodeIndex}; diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index 30ca93c7233..7b4ff850df6 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -2,13 +2,18 @@ //! generate the actual methods on tcx which find and execute the provider, //! manage the caches, and so forth. +use crate::keys::Key; use crate::{on_disk_cache, Queries}; -use rustc_middle::dep_graph::{DepNodeIndex, SerializedDepNodeIndex}; +use rustc_middle::dep_graph::{self, DepKind, DepNodeIndex, SerializedDepNodeIndex}; use rustc_middle::ty::tls::{self, ImplicitCtxt}; -use rustc_middle::ty::TyCtxt; +use rustc_middle::ty::{self, TyCtxt}; use rustc_query_system::dep_graph::HasDepContext; -use rustc_query_system::query::{QueryContext, QueryJobId, QueryMap, QuerySideEffects}; +use rustc_query_system::ich::StableHashingContext; +use rustc_query_system::query::{ + QueryContext, QueryJobId, QueryMap, QuerySideEffects, QueryStackFrame, +}; +use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::sync::Lock; use rustc_data_structures::thin_vec::ThinVec; use rustc_errors::{Diagnostic, Handler}; @@ -233,6 +238,53 @@ macro_rules! get_provider { }; } +pub(crate) fn create_query_frame< + 'tcx, + K: Copy + Key + for<'a> HashStable>, +>( + tcx: QueryCtxt<'tcx>, + do_describe: fn(QueryCtxt<'tcx>, K) -> String, + key: K, + kind: DepKind, + name: &'static str, +) -> QueryStackFrame { + // Disable visible paths printing for performance reasons. + // Showing visible path instead of any path is not that important in production. + let description = ty::print::with_no_visible_paths!( + // Force filename-line mode to avoid invoking `type_of` query. + ty::print::with_forced_impl_filename_line!(do_describe(tcx, key)) + ); + let description = + if tcx.sess.verbose() { format!("{} [{}]", description, name) } else { description }; + let span = if kind == dep_graph::DepKind::def_span { + // The `def_span` query is used to calculate `default_span`, + // so exit to avoid infinite recursion. + None + } else { + Some(key.default_span(*tcx)) + }; + let def_kind = if kind == dep_graph::DepKind::opt_def_kind { + // Try to avoid infinite recursion. + None + } else { + key.key_as_def_id() + .and_then(|def_id| def_id.as_local()) + .and_then(|def_id| tcx.opt_def_kind(def_id)) + }; + let hash = || { + tcx.with_stable_hashing_context(|mut hcx| { + let mut hasher = StableHasher::new(); + std::mem::discriminant(&kind).hash_stable(&mut hcx, &mut hasher); + key.hash_stable(&mut hcx, &mut hasher); + hasher.finish::() + }) + }; + + QueryStackFrame::new(name, description, span, def_kind, hash) +} + +// NOTE: `$V` isn't used here, but we still need to match on it so it can be passed to other macros +// invoked by `rustc_query_append`. macro_rules! define_queries { ( $($(#[$attr:meta])* @@ -249,44 +301,7 @@ macro_rules! define_queries { pub fn $name<'tcx>(tcx: QueryCtxt<'tcx>, key: as QueryConfig>::Key) -> QueryStackFrame { let kind = dep_graph::DepKind::$name; let name = stringify!($name); - // Disable visible paths printing for performance reasons. - // Showing visible path instead of any path is not that important in production. - let description = ty::print::with_no_visible_paths!( - // Force filename-line mode to avoid invoking `type_of` query. - ty::print::with_forced_impl_filename_line!( - queries::$name::describe(tcx, key) - ) - ); - let description = if tcx.sess.verbose() { - format!("{} [{}]", description, name) - } else { - description - }; - let span = if kind == dep_graph::DepKind::def_span { - // The `def_span` query is used to calculate `default_span`, - // so exit to avoid infinite recursion. - None - } else { - Some(key.default_span(*tcx)) - }; - let def_kind = if kind == dep_graph::DepKind::opt_def_kind { - // Try to avoid infinite recursion. - None - } else { - key.key_as_def_id() - .and_then(|def_id| def_id.as_local()) - .and_then(|def_id| tcx.opt_def_kind(def_id)) - }; - let hash = || { - tcx.with_stable_hashing_context(|mut hcx|{ - let mut hasher = StableHasher::new(); - std::mem::discriminant(&kind).hash_stable(&mut hcx, &mut hasher); - key.hash_stable(&mut hcx, &mut hasher); - hasher.finish::() - }) - }; - - QueryStackFrame::new(name, description, span, def_kind, hash) + $crate::plumbing::create_query_frame(tcx, queries::$name::describe, key, kind, name) })* } -- cgit 1.4.1-3-g733a5