Cleanup

Author: saethlin

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -292,7 +292,7 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
-    if let Some((value, _ty)) = tcx.is_trivial_const(key.value.instance.def_id()) {
+    if let Some((value, _ty)) = tcx.trivial_const(key.value.instance.def_id()) {
         return Ok(value);
     }
     tcx.eval_to_allocation_raw(key).map(|val| turn_into_const_value(tcx, val, key))
@@ -359,7 +359,6 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
     typing_env: ty::TypingEnv<'tcx>,
 ) -> Result<R, ErrorHandled> {
     let def = cid.instance.def.def_id();
-
     let is_static = tcx.is_static(def);
 
     let mut ecx = InterpCx::new(
@@ -373,7 +372,7 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
         CompileTimeMachine::new(CanAccessMutGlobal::from(is_static), CheckAlignment::Error),
     );
 
-    if let Some((value, ty)) = tcx.is_trivial_const(def) {
+    if let Some((value, ty)) = tcx.trivial_const(def) {
         let layout = ecx.layout_of(ty).unwrap();
         let opty = ecx.const_val_to_op(value, ty, Some(layout)).unwrap();
         let res = ecx.allocate(layout, MemoryKind::Stack).unwrap();

compiler/rustc_interface/src/passes.rs

@@ -1088,7 +1088,7 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
 
     sess.time("MIR_borrow_checking", || {
         tcx.par_hir_body_owners(|def_id| {
-            if tcx.is_trivial_const(def_id).is_some() {
+            if tcx.is_trivial_const(def_id) {
                 return;
             }
             if !tcx.is_typeck_child(def_id.to_def_id()) {
@@ -1201,7 +1201,7 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) {
     if tcx.sess.opts.unstable_opts.validate_mir {
         sess.time("ensuring_final_MIR_is_computable", || {
             tcx.par_hir_body_owners(|def_id| {
-                if tcx.is_trivial_const(def_id).is_none() {
+                if !tcx.is_trivial_const(def_id) {
                     tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
                 }
             });

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

@@ -240,7 +240,7 @@ provide! { tcx, def_id, other, cdata,
     thir_abstract_const => { table }
     optimized_mir => { table }
     mir_for_ctfe => { table }
-    is_trivial_const => { table }
+    trivial_const => { table }
     closure_saved_names_of_captured_variables => { table }
     mir_coroutine_witnesses => { table }
     promoted_mir => { table }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1793,9 +1793,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             }
             let mut is_trivial = false;
             if encode_const {
-                if let Some((val, ty)) = tcx.is_trivial_const(def_id) {
+                if let Some((val, ty)) = tcx.trivial_const(def_id) {
                     is_trivial = true;
-                    record!(self.tables.is_trivial_const[def_id.to_def_id()] <- (val, ty));
+                    record!(self.tables.trivial_const[def_id.to_def_id()] <- (val, ty));
                 } else {
                     is_trivial = false;
                     record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
@@ -2243,7 +2243,7 @@ fn prefetch_mir(tcx: TyCtxt<'_>) {
 
     let reachable_set = tcx.reachable_set(());
     par_for_each_in(tcx.mir_keys(()), |&&def_id| {
-        if tcx.is_trivial_const(def_id).is_some() {
+        if tcx.is_trivial_const(def_id) {
             return;
         }
         let (encode_const, encode_opt) = should_encode_mir(tcx, reachable_set, def_id);

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -427,7 +427,7 @@ define_tables! {
     object_lifetime_default: Table<DefIndex, LazyValue<ObjectLifetimeDefault>>,
     optimized_mir: Table<DefIndex, LazyValue<mir::Body<'static>>>,
     mir_for_ctfe: Table<DefIndex, LazyValue<mir::Body<'static>>>,
-    is_trivial_const: Table<DefIndex, LazyValue<(ConstValue, Ty<'static>)>>,
+    trivial_const: Table<DefIndex, LazyValue<(ConstValue, Ty<'static>)>>,
     closure_saved_names_of_captured_variables: Table<DefIndex, LazyValue<IndexVec<FieldIdx, Symbol>>>,
     mir_coroutine_witnesses: Table<DefIndex, LazyValue<mir::CoroutineLayout<'static>>>,
     promoted_mir: Table<DefIndex, LazyValue<IndexVec<mir::Promoted, mir::Body<'static>>>>,

compiler/rustc_middle/src/mir/graphviz.rs

@@ -16,7 +16,7 @@ where
 
     let mirs = def_ids
         .iter()
-        .filter(|def_id| tcx.is_trivial_const(*def_id).is_none())
+        .filter(|def_id| !tcx.is_trivial_const(*def_id))
         .flat_map(|def_id| {
             if tcx.is_const_fn(*def_id) {
                 vec![tcx.optimized_mir(*def_id), tcx.mir_for_ctfe(*def_id)]

compiler/rustc_middle/src/mir/pretty.rs

@@ -353,7 +353,7 @@ pub fn write_mir_pretty<'tcx>(
             // are shared between mir_for_ctfe and optimized_mir
             writer.write_mir_fn(tcx.mir_for_ctfe(def_id), w)?;
         } else {
-            if tcx.is_trivial_const(def_id).is_none() {
+            if !tcx.is_trivial_const(def_id) {
                 let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));
                 render_body(w, instance_mir)?;
             }

compiler/rustc_middle/src/query/erase.rs

@@ -160,10 +160,6 @@ impl EraseType for Result<mir::ConstValue, mir::interpret::ErrorHandled> {
     type Result = [u8; size_of::<Result<mir::ConstValue, mir::interpret::ErrorHandled>>()];
 }
 
-impl EraseType for Option<mir::ConstValue> {
-    type Result = [u8; size_of::<Option<mir::ConstValue>>()];
-}
-
 impl EraseType for Option<(mir::ConstValue, Ty<'_>)> {
     type Result = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];
 }

compiler/rustc_middle/src/query/mod.rs

@@ -2719,7 +2719,7 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    query is_trivial_const(def_id: DefId) -> Option<(mir::ConstValue, Ty<'tcx>)> {
+    query trivial_const(def_id: DefId) -> Option<(mir::ConstValue, Ty<'tcx>)> {
         desc { |tcx| "checking if `{}` is a trivial const", tcx.def_path_str(def_id) }
         cache_on_disk_if { def_id.is_local() }
         separate_provide_extern

compiler/rustc_middle/src/ty/context.rs

@@ -3546,6 +3546,13 @@ impl<'tcx> TyCtxt<'tcx> {
         self.get_diagnostic_attr(def_id, sym::do_not_recommend).is_some()
     }
 
+    pub fn is_trivial_const<P>(self, def_id: P) -> bool
+    where
+        P: IntoQueryParam<DefId>,
+    {
+        self.trivial_const(def_id).is_some()
+    }
+
     /// Whether this def is one of the special bin crate entrypoint functions that must have a
     /// monomorphization and also not be internalized in the bin crate.
     pub fn is_entrypoint(self, def_id: DefId) -> bool {