Remove old vector / hash_map hook (rust-lang#40) (rust-lang#612)

We no longer plan to use these hooks so I am deleting them.

Author: celinval

compiler/rustc_codegen_rmc/src/codegen/statement.rs

@@ -285,7 +285,7 @@ impl<'tcx> GotocCtx<'tcx> {
             };
 
             // Unwrap as needed
-            for (i, t) in tupled_args.iter().enumerate() {
+            for (i, _) in tupled_args.iter().enumerate() {
                 // Access the tupled parameters through the `member` operation
                 let index_param = tupe.clone().member(&i.to_string(), &self.symbol_table);
                 fargs.push(index_param);

compiler/rustc_codegen_rmc/src/codegen/typ.rs

@@ -489,10 +489,6 @@ impl<'tcx> GotocCtx<'tcx> {
     }
 
     fn codegen_ty_inner(&mut self, ty: Ty<'tcx>) -> Type {
-        if let Some(handler) = self.type_hooks.hook_applies(self.tcx, ty) {
-            return handler.handle(self, ty);
-        }
-
         match ty.kind() {
             ty::Int(k) => self.codegen_iint(*k),
             ty::Bool => Type::c_bool(),

compiler/rustc_codegen_rmc/src/compiler_interface.rs

@@ -22,7 +22,6 @@ use rustc_session::cstore::MetadataLoaderDyn;
 use rustc_session::Session;
 use std::collections::BTreeMap;
 use std::iter::FromIterator;
-use std::path::PathBuf;
 use tracing::{debug, warn};
 
 // #[derive(RustcEncodable, RustcDecodable)]

compiler/rustc_codegen_rmc/src/context/goto_ctx.rs

@@ -15,7 +15,7 @@
 //! this structure as input.
 
 use super::current_fn::CurrentFnCtx;
-use crate::overrides::{type_and_fn_hooks, GotocHooks, GotocTypeHooks};
+use crate::overrides::{fn_hooks, GotocHooks};
 use crate::utils::full_crate_name;
 use cbmc::goto_program::{DatatypeComponent, Expr, Location, Stmt, Symbol, SymbolTable, Type};
 use cbmc::utils::aggr_name;
@@ -42,7 +42,6 @@ pub struct GotocCtx<'tcx> {
     /// the generated symbol table for gotoc
     pub symbol_table: SymbolTable,
     pub hooks: GotocHooks<'tcx>,
-    pub type_hooks: GotocTypeHooks<'tcx>,
     /// the full crate name, including versioning info
     pub full_crate_name: String,
     /// a global counter for generating unique names for global variables
@@ -56,14 +55,13 @@ pub struct GotocCtx<'tcx> {
 /// Constructor
 impl<'tcx> GotocCtx<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>) -> GotocCtx<'tcx> {
-        let (thks, fhks) = type_and_fn_hooks();
+        let fhks = fn_hooks();
         let mm = machine_model_from_session(tcx.sess);
         let symbol_table = SymbolTable::new(mm);
         GotocCtx {
             tcx,
             symbol_table,
             hooks: fhks,
-            type_hooks: thks,
             full_crate_name: full_crate_name(tcx),
             global_var_count: 0,
             alloc_map: FxHashMap::default(),

compiler/rustc_codegen_rmc/src/overrides/hooks.rs

@@ -8,23 +8,17 @@
 //! It would be too nasty if we spread around these sort of undocumented hooks in place, so
 //! this module addresses this issue.
 
-use super::stubs::{HashMapStub, VecStub};
 use crate::utils::{instance_name_is, instance_name_starts_with};
 use crate::GotocCtx;
 use cbmc::goto_program::{BuiltinFn, Expr, Location, Stmt, Symbol, Type};
 use rustc_middle::mir::{BasicBlock, Place};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, Instance, InstanceDef, Ty, TyCtxt};
+use rustc_middle::ty::{self, Instance, InstanceDef, TyCtxt};
 use rustc_span::Span;
 use std::rc::Rc;
 use tracing::{debug, warn};
 
-pub trait GotocTypeHook<'tcx> {
-    fn hook_applies(&self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool;
-    fn handle(&self, tcx: &mut GotocCtx<'tcx>, ty: Ty<'tcx>) -> Type;
-}
-
 pub trait GotocHook<'tcx> {
     /// if the hook applies, it means the codegen would do something special to it
     fn hook_applies(&self, tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> bool;
@@ -654,7 +648,7 @@ impl<'tcx> GotocHook<'tcx> for SliceFromRawPart {
     }
 }
 
-fn fn_hooks<'tcx>() -> GotocHooks<'tcx> {
+pub fn fn_hooks<'tcx>() -> GotocHooks<'tcx> {
     GotocHooks {
         hooks: vec![
             Rc::new(Panic), //Must go first, so it overrides Nevers
@@ -672,42 +666,10 @@ fn fn_hooks<'tcx>() -> GotocHooks<'tcx> {
             Rc::new(RustDealloc),
             Rc::new(RustRealloc),
             Rc::new(SliceFromRawPart),
-            Rc::new(VecStub::new()),
-            Rc::new(HashMapStub::new()),
         ],
     }
 }
 
-pub fn type_and_fn_hooks<'tcx>() -> (GotocTypeHooks<'tcx>, GotocHooks<'tcx>) {
-    let thks = GotocTypeHooks { hooks: vec![Rc::new(HashMapStub::new()), Rc::new(VecStub::new())] };
-    let fhks = fn_hooks();
-    (thks, fhks)
-}
-
-pub struct GotocTypeHooks<'tcx> {
-    hooks: Vec<Rc<dyn GotocTypeHook<'tcx> + 'tcx>>,
-}
-
-impl<'tcx> GotocTypeHooks<'tcx> {
-    #[allow(dead_code)]
-    pub fn default() -> GotocTypeHooks<'tcx> {
-        type_and_fn_hooks().0
-    }
-
-    pub fn hook_applies(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> Option<Rc<dyn GotocTypeHook<'tcx> + 'tcx>> {
-        for h in &self.hooks {
-            if h.hook_applies(tcx, ty) {
-                return Some(h.clone());
-            }
-        }
-        None
-    }
-}
-
 pub struct GotocHooks<'tcx> {
     hooks: Vec<Rc<dyn GotocHook<'tcx> + 'tcx>>,
 }

compiler/rustc_codegen_rmc/src/overrides/mod.rs

@@ -7,6 +7,5 @@
 //! Instead, we use a "hook" to generate the correct CBMC intrinsic.
 
 mod hooks;
-mod stubs;
 
-pub use hooks::{skip_monomorphize, type_and_fn_hooks, GotocHooks, GotocTypeHooks};
+pub use hooks::{fn_hooks, skip_monomorphize, GotocHooks};