Remove deduce_param_attrs.

Author: cjgillot

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -282,20 +282,6 @@ provide! { tcx, def_id, other, cdata,
             .unwrap_or_else(|| panic!("{def_id:?} does not have eval_static_initializer")))
     }
     trait_def => { table }
-    deduced_param_attrs => {
-        // FIXME: `deduced_param_attrs` has some sketchy encoding settings,
-        // where we don't encode unless we're optimizing, doing codegen,
-        // and not incremental (see `encoder.rs`). I don't think this is right!
-        cdata
-            .root
-            .tables
-            .deduced_param_attrs
-            .get(cdata, def_id.index)
-            .map(|lazy| {
-                &*tcx.arena.alloc_from_iter(lazy.decode((cdata, tcx)))
-            })
-            .unwrap_or_default()
-    }
     opaque_ty_origin => { table }
     assumed_wf_types_for_rpitit => { table }
     collect_return_position_impl_trait_in_trait_tys => {

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -27,7 +27,7 @@ use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::fast_reject::{self, TreatParams};
 use rustc_middle::{bug, span_bug};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque};
-use rustc_session::config::{CrateType, OptLevel, TargetModifier};
+use rustc_session::config::{CrateType, TargetModifier};
 use rustc_span::hygiene::HygieneEncodeContext;
 use rustc_span::{
     ByteSymbol, ExternalSource, FileName, SourceFile, SpanData, SpanEncoder, StableSourceFileId,
@@ -1822,21 +1822,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses);
             }
         }
-
-        // Encode all the deduced parameter attributes for everything that has MIR, even for items
-        // that can't be inlined. But don't if we aren't optimizing in non-incremental mode, to
-        // save the query traffic.
-        if tcx.sess.opts.output_types.should_codegen()
-            && tcx.sess.opts.optimize != OptLevel::No
-            && tcx.sess.opts.incremental.is_none()
-        {
-            for &local_def_id in tcx.mir_keys(()) {
-                if let DefKind::AssocFn | DefKind::Fn = tcx.def_kind(local_def_id) {
-                    record_array!(self.tables.deduced_param_attrs[local_def_id.to_def_id()] <-
-                        self.tcx.deduced_param_attrs(local_def_id.to_def_id()));
-                }
-            }
-        }
     }
 
     #[instrument(level = "debug", skip(self))]

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -29,7 +29,7 @@ use rustc_middle::middle::lib_features::FeatureStability;
 use rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault;
 use rustc_middle::mir;
 use rustc_middle::ty::fast_reject::SimplifiedType;
-use rustc_middle::ty::{self, DeducedParamAttrs, Ty, TyCtxt, UnusedGenericParams};
+use rustc_middle::ty::{self, Ty, TyCtxt, UnusedGenericParams};
 use rustc_middle::util::Providers;
 use rustc_serialize::opaque::FileEncoder;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
@@ -462,7 +462,6 @@ define_tables! {
     assoc_container: Table<DefIndex, ty::AssocItemContainer>,
     macro_definition: Table<DefIndex, LazyValue<ast::DelimArgs>>,
     proc_macro: Table<DefIndex, MacroKind>,
-    deduced_param_attrs: Table<DefIndex, LazyArray<DeducedParamAttrs>>,
     trait_impl_trait_tys: Table<DefIndex, LazyValue<DefIdMap<ty::EarlyBinder<'static, Ty<'static>>>>>,
     doc_link_resolutions: Table<DefIndex, LazyValue<DocLinkResMap>>,
     doc_link_traits_in_scope: Table<DefIndex, LazyArray<DefId>>,

compiler/rustc_metadata/src/rmeta/parameterized.rs

@@ -105,7 +105,6 @@ trivially_parameterized_over_tcx! {
     rustc_middle::ty::AssocItemContainer,
     rustc_middle::ty::AsyncDestructor,
     rustc_middle::ty::Asyncness,
-    rustc_middle::ty::DeducedParamAttrs,
     rustc_middle::ty::Destructor,
     rustc_middle::ty::Generics,
     rustc_middle::ty::ImplTraitInTraitData,

compiler/rustc_middle/src/query/erase.rs

@@ -323,7 +323,6 @@ trivial! {
     rustc_middle::ty::AsyncDestructor,
     rustc_middle::ty::BoundVariableKind,
     rustc_middle::ty::AnonConstKind,
-    rustc_middle::ty::DeducedParamAttrs,
     rustc_middle::ty::Destructor,
     rustc_middle::ty::fast_reject::SimplifiedType,
     rustc_middle::ty::ImplPolarity,

compiler/rustc_middle/src/query/mod.rs

@@ -2656,11 +2656,6 @@ rustc_queries! {
         return_result_from_ensure_ok
     }
 
-    query deduced_param_attrs(def_id: DefId) -> &'tcx [ty::DeducedParamAttrs] {
-        desc { |tcx| "deducing parameter attributes for {}", tcx.def_path_str(def_id) }
-        separate_provide_extern
-    }
-
     query doc_link_resolutions(def_id: DefId) -> &'tcx DocLinkResMap {
         eval_always
         desc { "resolutions for documentation links for a module" }

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -799,7 +799,6 @@ impl_ref_decoder! {<'tcx>
     rustc_span::def_id::DefId,
     rustc_span::def_id::LocalDefId,
     (rustc_middle::middle::exported_symbols::ExportedSymbol<'tcx>, rustc_middle::middle::exported_symbols::SymbolExportInfo),
-    ty::DeducedParamAttrs,
 }
 
 //- ENCODING -------------------------------------------------------------------

compiler/rustc_middle/src/ty/codec.rs

@@ -583,7 +583,6 @@ impl_arena_copy_decoder! {<'tcx>
     rustc_span::def_id::DefId,
     rustc_span::def_id::LocalDefId,
     (rustc_middle::middle::exported_symbols::ExportedSymbol<'tcx>, rustc_middle::middle::exported_symbols::SymbolExportInfo),
-    ty::DeducedParamAttrs,
 }
 
 #[macro_export]

compiler/rustc_middle/src/ty/context.rs

@@ -40,7 +40,6 @@ use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{self as hir, Attribute, HirId, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
-use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_query_system::cache::WithDepNode;
 use rustc_query_system::dep_graph::DepNodeIndex;
 use rustc_query_system::ich::StableHashingContext;
@@ -3495,21 +3494,6 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
-/// Parameter attributes that can only be determined by examining the body of a function instead
-/// of just its signature.
-///
-/// These can be useful for optimization purposes when a function is directly called. We compute
-/// them and store them into the crate metadata so that downstream crates can make use of them.
-///
-/// Right now, we only have `read_only`, but `no_capture` and `no_alias` might be useful in the
-/// future.
-#[derive(Clone, Copy, PartialEq, Debug, Default, TyDecodable, TyEncodable, HashStable)]
-pub struct DeducedParamAttrs {
-    /// The parameter is marked immutable in the function and contains no `UnsafeCell` (i.e. its
-    /// type is freeze).
-    pub read_only: bool,
-}
-
 pub fn provide(providers: &mut Providers) {
     providers.is_panic_runtime =
         |tcx, LocalCrate| contains_name(tcx.hir_krate_attrs(), sym::panic_runtime);

compiler/rustc_middle/src/ty/mod.rs

@@ -77,8 +77,7 @@ pub use self::consts::{
     ExprKind, ScalarInt, UnevaluatedConst, ValTree, ValTreeKind, Value,
 };
 pub use self::context::{
-    CtxtInterners, CurrentGcx, DeducedParamAttrs, Feed, FreeRegionInfo, GlobalCtxt, Lift, TyCtxt,
-    TyCtxtFeed, tls,
+    CtxtInterners, CurrentGcx, Feed, FreeRegionInfo, GlobalCtxt, Lift, TyCtxt, TyCtxtFeed, tls,
 };
 pub use self::fold::*;
 pub use self::instance::{Instance, InstanceKind, ReifyReason, UnusedGenericParams};