From d060e7df444923a015df58295fd1bc2a7150a807 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Wed, 20 Mar 2019 16:53:55 +0100 Subject: [PATCH] Add no_force to query macro and move some queries over --- src/librustc/dep_graph/dep_node.rs | 4 --- src/librustc/query/mod.rs | 25 ++++++++++++- src/librustc/ty/query/config.rs | 26 +------------- src/librustc/ty/query/mod.rs | 16 --------- src/librustc/ty/query/plumbing.rs | 9 +---- src/librustc_macros/src/query.rs | 56 ++++++++++++++++++++++++------ 6 files changed, 71 insertions(+), 65 deletions(-) diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index ab9c9b24718..a4950c01162 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -538,7 +538,6 @@ pub fn to_dep_node(self, tcx: TyCtxt<'_, '_, '_>, kind: DepKind) -> DepNode { [anon] TraitSelect, [] ParamEnv(DefId), - [] Environment(DefId), [] DescribeDef(DefId), // FIXME(mw): DefSpans are not really inputs since they are derived from @@ -661,9 +660,6 @@ pub fn to_dep_node(self, tcx: TyCtxt<'_, '_, '_>, kind: DepKind) -> DepNode { [input] Features, - [] ProgramClausesFor(DefId), - [] ProgramClausesForEnv(traits::Environment<'tcx>), - [] WasmImportModuleMap(CrateNum), [] ForeignModules(CrateNum), [] UpstreamMonomorphizations(CrateNum), diff --git a/src/librustc/query/mod.rs b/src/librustc/query/mod.rs index b99bffd3bd3..361d8129002 100644 --- a/src/librustc/query/mod.rs +++ b/src/librustc/query/mod.rs @@ -2,8 +2,9 @@ use crate::ty::query::queries; use crate::ty::TyCtxt; use crate::ty; -use crate::hir::def_id::CrateNum; +use crate::hir::def_id::{DefId, CrateNum}; use crate::dep_graph::SerializedDepNodeIndex; +use crate::traits; use std::borrow::Cow; // Each of these queries corresponds to a function pointer field in the @@ -106,4 +107,26 @@ } } } + + TypeChecking { + query program_clauses_for(_: DefId) -> Clauses<'tcx> { + desc { "generating chalk-style clauses" } + } + + query program_clauses_for_env(_: traits::Environment<'tcx>) -> Clauses<'tcx> { + no_force + desc { "generating chalk-style clauses for environment" } + } + + // Get the chalk-style environment of the given item. + query environment(_: DefId) -> traits::Environment<'tcx> { + desc { "return a chalk-style environment" } + } + } + + Linking { + query wasm_import_module_map(_: CrateNum) -> Lrc> { + desc { "wasm import module map" } + } + } } diff --git a/src/librustc/ty/query/config.rs b/src/librustc/ty/query/config.rs index 4e07f400f82..72fb649a946 100644 --- a/src/librustc/ty/query/config.rs +++ b/src/librustc/ty/query/config.rs @@ -916,33 +916,9 @@ fn describe(tcx: TyCtxt<'_, '_, '_>, def: ty::InstanceDef<'tcx>) -> Cow<'static, } } -impl<'tcx> QueryDescription<'tcx> for queries::program_clauses_for<'tcx> { - fn describe(_tcx: TyCtxt<'_, '_, '_>, _: DefId) -> Cow<'static, str> { - "generating chalk-style clauses".into() - } -} - -impl<'tcx> QueryDescription<'tcx> for queries::program_clauses_for_env<'tcx> { - fn describe(_tcx: TyCtxt<'_, '_, '_>, _: traits::Environment<'tcx>) -> Cow<'static, str> { - "generating chalk-style clauses for environment".into() - } -} - -impl<'tcx> QueryDescription<'tcx> for queries::environment<'tcx> { - fn describe(_tcx: TyCtxt<'_, '_, '_>, _: DefId) -> Cow<'static, str> { - "return a chalk-style environment".into() - } -} - -impl<'tcx> QueryDescription<'tcx> for queries::wasm_import_module_map<'tcx> { - fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> { - "wasm import module map".into() - } -} - impl<'tcx> QueryDescription<'tcx> for queries::dllimport_foreign_items<'tcx> { fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> { - "wasm import module map".into() + "dllimport_foreign_items".into() } } diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index 1038401244f..4cfddf08461 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -683,22 +683,6 @@ [] fn features_query: features_node(CrateNum) -> Lrc, }, - - TypeChecking { - [] fn program_clauses_for: ProgramClausesFor(DefId) -> Clauses<'tcx>, - - [] fn program_clauses_for_env: ProgramClausesForEnv( - traits::Environment<'tcx> - ) -> Clauses<'tcx>, - - // Get the chalk-style environment of the given item. - [] fn environment: Environment(DefId) -> traits::Environment<'tcx>, - }, - - Linking { - [] fn wasm_import_module_map: WasmImportModuleMap(CrateNum) - -> Lrc>, - }, ]} ////////////////////////////////////////////////////////////////////// diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs index 9b4341e6355..331f68c11d0 100644 --- a/src/librustc/ty/query/plumbing.rs +++ b/src/librustc/ty/query/plumbing.rs @@ -1240,11 +1240,7 @@ macro_rules! force { DepKind::TypeOpNormalizeFnSig | DepKind::SubstituteNormalizeAndTestPredicates | DepKind::MethodAutoderefSteps | - DepKind::InstanceDefSizeEstimate | - DepKind::ProgramClausesForEnv | - - // This one should never occur in this context - DepKind::Null => { + DepKind::InstanceDefSizeEstimate => { bug!("force_from_dep_node() - Encountered {:?}", dep_node) } @@ -1311,7 +1307,6 @@ macro_rules! force { DepKind::CheckMatch => { force!(check_match, def_id!()); } DepKind::ParamEnv => { force!(param_env, def_id!()); } - DepKind::Environment => { force!(environment, def_id!()); } DepKind::DescribeDef => { force!(describe_def, def_id!()); } DepKind::DefSpan => { force!(def_span, def_id!()); } DepKind::LookupStability => { force!(lookup_stability, def_id!()); } @@ -1419,8 +1414,6 @@ macro_rules! force { DepKind::Features => { force!(features_query, LOCAL_CRATE); } - DepKind::ProgramClausesFor => { force!(program_clauses_for, def_id!()); } - DepKind::WasmImportModuleMap => { force!(wasm_import_module_map, krate!()); } DepKind::ForeignModules => { force!(foreign_modules, krate!()); } DepKind::UpstreamMonomorphizations => { diff --git a/src/librustc_macros/src/query.rs b/src/librustc_macros/src/query.rs index c7d164d3297..90bd46d0350 100644 --- a/src/librustc_macros/src/query.rs +++ b/src/librustc_macros/src/query.rs @@ -45,6 +45,9 @@ enum QueryModifier { /// Don't hash the result, instead just mark a query red if it runs NoHash, + + /// Don't force the query + NoForce, } impl Parse for QueryModifier { @@ -94,6 +97,8 @@ fn parse(input: ParseStream<'_>) -> Result { Ok(QueryModifier::FatalCycle) } else if modifier == "no_hash" { Ok(QueryModifier::NoHash) + } else if modifier == "no_force" { + Ok(QueryModifier::NoForce) } else { Err(Error::new(modifier.span(), "unknown query modifier")) } @@ -194,6 +199,9 @@ struct QueryModifiers { /// Don't hash the result, instead just mark a query red if it runs no_hash: bool, + + /// Don't force the query + no_force: bool, } /// Process query modifiers into a struct, erroring on duplicates @@ -203,6 +211,7 @@ fn process_modifiers(query: &mut Query) -> QueryModifiers { let mut desc = None; let mut fatal_cycle = false; let mut no_hash = false; + let mut no_force = false; for modifier in query.modifiers.0.drain(..) { match modifier { QueryModifier::LoadCached(tcx, id, block) => { @@ -235,6 +244,12 @@ fn process_modifiers(query: &mut Query) -> QueryModifiers { } no_hash = true; } + QueryModifier::NoForce => { + if no_force { + panic!("duplicate modifier `no_force` for query `{}`", query.name); + } + no_force = true; + } } } QueryModifiers { @@ -243,6 +258,7 @@ fn process_modifiers(query: &mut Query) -> QueryModifiers { desc, fatal_cycle, no_hash, + no_force, } } @@ -329,6 +345,7 @@ pub fn rustc_queries(input: TokenStream) -> TokenStream { let mut query_description_stream = quote! {}; let mut dep_node_def_stream = quote! {}; let mut dep_node_force_stream = quote! {}; + let mut no_force_queries = Vec::new(); for group in groups.0 { let mut group_stream = quote! {}; @@ -364,29 +381,46 @@ pub fn rustc_queries(input: TokenStream) -> TokenStream { [#attribute_stream] fn #name: #name(#arg) #result, }); - add_query_description_impl(&query, modifiers, &mut query_description_stream); - // Create a dep node for the query dep_node_def_stream.extend(quote! { [] #name(#arg), }); - // Add a match arm to force the query given the dep node - dep_node_force_stream.extend(quote! { - DepKind::#name => { - if let Some(key) = RecoverKey::recover($tcx, $dep_node) { - force_ex!($tcx, #name, key); - } else { - return false; + if modifiers.no_force { + no_force_queries.push(name.clone()); + } else { + // Add a match arm to force the query given the dep node + dep_node_force_stream.extend(quote! { + DepKind::#name => { + if let Some(key) = RecoverKey::recover($tcx, $dep_node) { + force_ex!($tcx, #name, key); + } else { + return false; + } } - } - }); + }); + } + + add_query_description_impl(&query, modifiers, &mut query_description_stream); } let name = &group.name; query_stream.extend(quote! { #name { #group_stream }, }); } + + // Add an arm for the no force queries to panic when trying to force them + for query in no_force_queries { + dep_node_force_stream.extend(quote! { + DepKind::#query | + }); + } + dep_node_force_stream.extend(quote! { + DepKind::Null => { + bug!("Cannot force dep node: {:?}", $dep_node) + } + }); + TokenStream::from(quote! { macro_rules! rustc_query_append { ([$($macro:tt)*][$($other:tt)*]) => {