Rename `binary` to `bin` (#1802)

Fixes #1799 by renaming `binary` to `bin`.

This turned out to be a smaller change than going the other way (1205
replacements vs. 1496).

Signed-off-by: Samuel Moelius <samuel.moelius@trailofbits.com>

clippy.toml

@@ -1,2 +1,3 @@
 too-many-arguments-threshold = 13
 cognitive-complexity-threshold = 37
+disallowed-names = ["binary"]

src/bin/solang.rs

@@ -411,13 +411,13 @@ fn contract_results(
 
     let context = inkwell::context::Context::create();
 
-    let binary = resolved_contract.binary(ns, &context, opt, contract_no);
+    let bin = resolved_contract.binary(ns, &context, opt, contract_no);
 
-    if save_intermediates(&binary, compiler_output) {
+    if save_intermediates(&bin, compiler_output) {
         return;
     }
 
-    let code = binary.code(Generate::Linked).expect("llvm build");
+    let code = bin.code(Generate::Linked).expect("llvm build");
 
     #[cfg(feature = "wasm_opt")]
     if let Some(level) = opt.wasm_opt.filter(|_| ns.target.is_polkadot() && verbose) {
@@ -429,7 +429,7 @@ fn contract_results(
 
     if std_json {
         json_contracts.insert(
-            binary.name,
+            bin.name,
             JsonContract {
                 abi: abi::ethereum::gen_abi(contract_no, ns),
                 ewasm: Some(EwasmContract {
@@ -441,7 +441,7 @@ fn contract_results(
     } else {
         let bin_filename = output_file(
             compiler_output,
-            &binary.name,
+            &bin.name,
             ns.target.file_extension(),
             false,
         );
@@ -450,7 +450,7 @@ fn contract_results(
             eprintln!(
                 "info: Saving binary {} for contract {}",
                 bin_filename.display(),
-                binary.name
+                bin.name
             );
         }
 
@@ -460,13 +460,13 @@ fn contract_results(
 
         let (metadata, meta_ext) =
             abi::generate_abi(contract_no, ns, &code, verbose, default_authors, version);
-        let meta_filename = output_file(compiler_output, &binary.name, meta_ext, true);
+        let meta_filename = output_file(compiler_output, &bin.name, meta_ext, true);
 
         if verbose {
             eprintln!(
                 "info: Saving metadata {} for contract {}",
                 meta_filename.display(),
-                binary.name
+                bin.name
             );
         }
 
@@ -476,46 +476,46 @@ fn contract_results(
 }
 
 fn save_intermediates(
-    binary: &solang::emit::binary::Binary,
+    bin: &solang::emit::binary::Binary,
     compiler_output: &CompilerOutput,
 ) -> bool {
     let verbose = compiler_output.verbose;
 
     match compiler_output.emit.as_deref() {
         Some("llvm-ir") => {
-            let llvm_filename = output_file(compiler_output, &binary.name, "ll", false);
+            let llvm_filename = output_file(compiler_output, &bin.name, "ll", false);
 
             if verbose {
                 eprintln!(
                     "info: Saving LLVM IR {} for contract {}",
                     llvm_filename.display(),
-                    binary.name
+                    bin.name
                 );
             }
 
-            binary.dump_llvm(&llvm_filename).unwrap();
+            bin.dump_llvm(&llvm_filename).unwrap();
 
             true
         }
 
         Some("llvm-bc") => {
-            let bc_filename = output_file(compiler_output, &binary.name, "bc", false);
+            let bc_filename = output_file(compiler_output, &bin.name, "bc", false);
 
             if verbose {
                 eprintln!(
                     "info: Saving LLVM BC {} for contract {}",
                     bc_filename.display(),
-                    binary.name
+                    bin.name
                 );
             }
 
-            binary.bitcode(&bc_filename);
+            bin.bitcode(&bc_filename);
 
             true
         }
 
         Some("object") => {
-            let obj = match binary.code(Generate::Object) {
+            let obj = match bin.code(Generate::Object) {
                 Ok(o) => o,
                 Err(s) => {
                     println!("error: {s}");
@@ -523,13 +523,13 @@ fn save_intermediates(
                 }
             };
 
-            let obj_filename = output_file(compiler_output, &binary.name, "o", false);
+            let obj_filename = output_file(compiler_output, &bin.name, "o", false);
 
             if verbose {
                 eprintln!(
                     "info: Saving Object {} for contract {}",
                     obj_filename.display(),
-                    binary.name
+                    bin.name
                 );
             }
 
@@ -538,7 +538,7 @@ fn save_intermediates(
             true
         }
         Some("asm") => {
-            let obj = match binary.code(Generate::Assembly) {
+            let obj = match bin.code(Generate::Assembly) {
                 Ok(o) => o,
                 Err(s) => {
                     println!("error: {s}");
@@ -546,13 +546,13 @@ fn save_intermediates(
                 }
             };
 
-            let obj_filename = output_file(compiler_output, &binary.name, "asm", false);
+            let obj_filename = output_file(compiler_output, &bin.name, "asm", false);
 
             if verbose {
                 eprintln!(
                     "info: Saving Assembly {} for contract {}",
                     obj_filename.display(),
-                    binary.name
+                    bin.name
                 );
             }
 

src/emit/expression.rs

@@ -2170,7 +2170,7 @@ pub(super) fn expression<'a, T: TargetRuntime<'a> + ?Sized>(
 
 pub(super) fn compare_address<'a, T: TargetRuntime<'a> + ?Sized>(
     target: &T,
-    binary: &Binary<'a>,
+    bin: &Binary<'a>,
     left: &Expression,
     right: &Expression,
     op: inkwell::IntPredicate,
@@ -2178,24 +2178,23 @@ pub(super) fn compare_address<'a, T: TargetRuntime<'a> + ?Sized>(
     function: FunctionValue<'a>,
     ns: &Namespace,
 ) -> IntValue<'a> {
-    let l = expression(target, binary, left, vartab, function, ns).into_array_value();
-    let r = expression(target, binary, right, vartab, function, ns).into_array_value();
+    let l = expression(target, bin, left, vartab, function, ns).into_array_value();
+    let r = expression(target, bin, right, vartab, function, ns).into_array_value();
 
-    let left = binary.build_alloca(function, binary.address_type(ns), "left");
-    let right = binary.build_alloca(function, binary.address_type(ns), "right");
+    let left = bin.build_alloca(function, bin.address_type(ns), "left");
+    let right = bin.build_alloca(function, bin.address_type(ns), "right");
 
-    binary.builder.build_store(left, l).unwrap();
-    binary.builder.build_store(right, r).unwrap();
+    bin.builder.build_store(left, l).unwrap();
+    bin.builder.build_store(right, r).unwrap();
 
-    let res = binary
+    let res = bin
         .builder
         .build_call(
-            binary.module.get_function("__memcmp_ord").unwrap(),
+            bin.module.get_function("__memcmp_ord").unwrap(),
             &[
                 left.into(),
                 right.into(),
-                binary
-                    .context
+                bin.context
                     .i32_type()
                     .const_int(ns.address_length as u64, false)
                     .into(),
@@ -2208,9 +2207,8 @@ pub(super) fn compare_address<'a, T: TargetRuntime<'a> + ?Sized>(
         .unwrap()
         .into_int_value();
 
-    binary
-        .builder
-        .build_int_compare(op, res, binary.context.i32_type().const_zero(), "")
+    bin.builder
+        .build_int_compare(op, res, bin.context.i32_type().const_zero(), "")
         .unwrap()
 }
 

src/emit/loop_builder.rs

@@ -22,18 +22,17 @@ pub struct LoopBuilder<'a> {
 impl<'a> LoopBuilder<'a> {
     /// Create a new loop. This creates the basic blocks and inserts a branch to start of the loop at
     /// the current location. This function should be called first.
-    pub fn new(binary: &Binary<'a>, function: FunctionValue<'a>) -> Self {
-        let entry_block = binary.builder.get_insert_block().unwrap();
-        let condition_block = binary.context.append_basic_block(function, "cond");
-        let body_block = binary.context.append_basic_block(function, "body");
-        let done_block = binary.context.append_basic_block(function, "done");
+    pub fn new(bin: &Binary<'a>, function: FunctionValue<'a>) -> Self {
+        let entry_block = bin.builder.get_insert_block().unwrap();
+        let condition_block = bin.context.append_basic_block(function, "cond");
+        let body_block = bin.context.append_basic_block(function, "body");
+        let done_block = bin.context.append_basic_block(function, "done");
 
-        binary
-            .builder
+        bin.builder
             .build_unconditional_branch(condition_block)
             .unwrap();
 
-        binary.builder.position_at_end(condition_block);
+        bin.builder.position_at_end(condition_block);
 
         LoopBuilder {
             phis: HashMap::new(),
@@ -51,12 +50,12 @@ impl<'a> LoopBuilder<'a> {
     /// must be given.
     pub fn add_loop_phi<T: BasicType<'a>>(
         &mut self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         name: &'static str,
         ty: T,
         initial_value: BasicValueEnum<'a>,
     ) -> BasicValueEnum<'a> {
-        let phi = binary.builder.build_phi(ty, name).unwrap();
+        let phi = bin.builder.build_phi(ty, name).unwrap();
 
         phi.add_incoming(&[(&initial_value, self.entry_block)]);
 
@@ -70,35 +69,29 @@ impl<'a> LoopBuilder<'a> {
     /// builds the condition and then jumps to do the body; the return value is in the index
     /// which can be used in the body. The body of the loop can be inserted after calling this
     /// function.
-    pub fn over(
-        &mut self,
-        binary: &Binary<'a>,
-        from: IntValue<'a>,
-        to: IntValue<'a>,
-    ) -> IntValue<'a> {
+    pub fn over(&mut self, bin: &Binary<'a>, from: IntValue<'a>, to: IntValue<'a>) -> IntValue<'a> {
         let loop_ty = from.get_type();
-        let loop_phi = binary.builder.build_phi(loop_ty, "index").unwrap();
+        let loop_phi = bin.builder.build_phi(loop_ty, "index").unwrap();
 
         let loop_var = loop_phi.as_basic_value().into_int_value();
 
-        let next = binary
+        let next = bin
             .builder
             .build_int_add(loop_var, loop_ty.const_int(1, false), "next_index")
             .unwrap();
 
-        let comp = binary
+        let comp = bin
             .builder
             .build_int_compare(IntPredicate::ULT, loop_var, to, "loop_cond")
             .unwrap();
 
-        binary
-            .builder
+        bin.builder
             .build_conditional_branch(comp, self.body_block, self.done_block)
             .unwrap();
 
         loop_phi.add_incoming(&[(&from, self.entry_block)]);
 
-        binary.builder.position_at_end(self.body_block);
+        bin.builder.position_at_end(self.body_block);
 
         self.loop_phi = Some(loop_phi);
         self.next_index = Some(next);
@@ -109,29 +102,28 @@ impl<'a> LoopBuilder<'a> {
     /// Use this function to set the loop phis to their values at the end of the body
     pub fn set_loop_phi_value(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         name: &'static str,
         value: BasicValueEnum<'a>,
     ) {
-        let block = binary.builder.get_insert_block().unwrap();
+        let block = bin.builder.get_insert_block().unwrap();
 
         self.phis[name].add_incoming(&[(&value, block)]);
     }
 
     /// Call this once the body of the loop has been generated. This will close the loop
     /// and ensure the exit block has been reached.
-    pub fn finish(&self, binary: &Binary<'a>) {
-        let block = binary.builder.get_insert_block().unwrap();
+    pub fn finish(&self, bin: &Binary<'a>) {
+        let block = bin.builder.get_insert_block().unwrap();
 
         let loop_phi = self.loop_phi.unwrap();
 
         loop_phi.add_incoming(&[(self.next_index.as_ref().unwrap(), block)]);
 
-        binary
-            .builder
+        bin.builder
             .build_unconditional_branch(self.condition_block)
             .unwrap();
 
-        binary.builder.position_at_end(self.done_block);
+        bin.builder.position_at_end(self.done_block);
     }
 }

src/emit/mod.rs

@@ -80,7 +80,7 @@ pub trait TargetRuntime<'a> {
 
     fn storage_load(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         ty: &ast::Type,
         slot: &mut IntValue<'a>,
         function: FunctionValue<'a>,
@@ -91,7 +91,7 @@ pub trait TargetRuntime<'a> {
     /// Recursively store a type to storage
     fn storage_store(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         ty: &ast::Type,
         existing: bool,
         slot: &mut IntValue<'a>,
@@ -229,7 +229,7 @@ pub trait TargetRuntime<'a> {
 
     fn builtin_function(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         function: FunctionValue<'a>,
         builtin_func: &Function,
         args: &[BasicMetadataValueEnum<'a>],
@@ -293,10 +293,10 @@ pub trait TargetRuntime<'a> {
     fn return_data<'b>(&self, bin: &Binary<'b>, function: FunctionValue<'b>) -> PointerValue<'b>;
 
     /// Return the value we received
-    fn value_transferred<'b>(&self, binary: &Binary<'b>, ns: &Namespace) -> IntValue<'b>;
+    fn value_transferred<'b>(&self, bin: &Binary<'b>, ns: &Namespace) -> IntValue<'b>;
 
     /// Terminate execution, destroy bin and send remaining funds to addr
-    fn selfdestruct<'b>(&self, binary: &Binary<'b>, addr: ArrayValue<'b>, ns: &Namespace);
+    fn selfdestruct<'b>(&self, bin: &Binary<'b>, addr: ArrayValue<'b>, ns: &Namespace);
 
     /// Crypto Hash
     fn hash<'b>(
@@ -321,7 +321,7 @@ pub trait TargetRuntime<'a> {
     /// Return ABI encoded data
     fn return_abi_data<'b>(
         &self,
-        binary: &Binary<'b>,
+        bin: &Binary<'b>,
         data: PointerValue<'b>,
         data_len: BasicValueEnum<'b>,
     );
@@ -385,8 +385,8 @@ impl ast::Contract {
         self.code
             .get_or_init(move || {
                 let context = inkwell::context::Context::create();
-                let binary = self.binary(ns, &context, opt, contract_no);
-                binary.code(Generate::Linked).expect("llvm build")
+                let bin = self.binary(ns, &context, opt, contract_no);
+                bin.code(Generate::Linked).expect("llvm build")
             })
             .to_vec()
     }

src/emit/polkadot/mod.rs

@@ -28,7 +28,7 @@ impl PolkadotTarget {
         opt: &'a Options,
     ) -> Binary<'a> {
         let filename = ns.files[contract.loc.file_no()].file_name();
-        let mut binary = Binary::new(
+        let mut bin = Binary::new(
             context,
             ns.target,
             &contract.id.name,
@@ -38,16 +38,16 @@ impl PolkadotTarget {
             None,
         );
 
-        let ptr = binary.context.i8_type().ptr_type(AddressSpace::default());
+        let ptr = bin.context.i8_type().ptr_type(AddressSpace::default());
 
-        binary.vector_init_empty = binary
+        bin.vector_init_empty = bin
             .context
             .i32_type()
             .const_all_ones()
             .const_to_pointer(ptr);
-        binary.set_early_value_aborts(contract, ns);
+        bin.set_early_value_aborts(contract, ns);
 
-        let scratch_len = binary.module.add_global(
+        let scratch_len = bin.module.add_global(
             context.i32_type(),
             Some(AddressSpace::default()),
             "scratch_len",
@@ -55,25 +55,25 @@ impl PolkadotTarget {
         scratch_len.set_linkage(Linkage::Internal);
         scratch_len.set_initializer(&context.i32_type().get_undef());
 
-        binary.scratch_len = Some(scratch_len);
+        bin.scratch_len = Some(scratch_len);
 
-        let scratch = binary.module.add_global(
+        let scratch = bin.module.add_global(
             context.i8_type().array_type(SCRATCH_SIZE),
             Some(AddressSpace::default()),
             "scratch",
         );
         scratch.set_linkage(Linkage::Internal);
         scratch.set_initializer(&context.i8_type().array_type(SCRATCH_SIZE).get_undef());
-        binary.scratch = Some(scratch);
+        bin.scratch = Some(scratch);
 
         let mut target = PolkadotTarget;
 
-        target.declare_externals(&binary);
+        target.declare_externals(&bin);
 
-        emit_functions(&mut target, &mut binary, contract, ns);
+        emit_functions(&mut target, &mut bin, contract, ns);
 
         let function_name = CString::new(STORAGE_INITIALIZER).unwrap();
-        let mut storage_initializers = binary
+        let mut storage_initializers = bin
             .functions
             .values()
             .filter(|f| f.get_name() == function_name.as_c_str());
@@ -82,10 +82,10 @@ impl PolkadotTarget {
             .expect("storage initializer is always present");
         assert!(storage_initializers.next().is_none());
 
-        target.emit_dispatch(Some(storage_initializer), &mut binary, ns);
-        target.emit_dispatch(None, &mut binary, ns);
+        target.emit_dispatch(Some(storage_initializer), &mut bin, ns);
+        target.emit_dispatch(None, &mut bin, ns);
 
-        binary.internalize(&[
+        bin.internalize(&[
             "deploy",
             "call",
             "call_chain_extension",
@@ -121,64 +121,57 @@ impl PolkadotTarget {
             "caller_is_root",
         ]);
 
-        binary
+        bin
     }
 
     fn public_function_prelude<'a>(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         function: FunctionValue<'a>,
         storage_initializer: Option<FunctionValue>,
     ) -> (PointerValue<'a>, IntValue<'a>) {
-        let entry = binary.context.append_basic_block(function, "entry");
+        let entry = bin.context.append_basic_block(function, "entry");
 
-        binary.builder.position_at_end(entry);
+        bin.builder.position_at_end(entry);
 
         // init our heap
-        binary
-            .builder
-            .build_call(binary.module.get_function("__init_heap").unwrap(), &[], "")
+        bin.builder
+            .build_call(bin.module.get_function("__init_heap").unwrap(), &[], "")
             .unwrap();
 
         // Call the storage initializers on deploy
         if let Some(initializer) = storage_initializer {
-            binary.builder.build_call(initializer, &[], "").unwrap();
+            bin.builder.build_call(initializer, &[], "").unwrap();
         }
 
-        let scratch_buf = binary.scratch.unwrap().as_pointer_value();
-        let scratch_len = binary.scratch_len.unwrap().as_pointer_value();
+        let scratch_buf = bin.scratch.unwrap().as_pointer_value();
+        let scratch_len = bin.scratch_len.unwrap().as_pointer_value();
 
         // copy arguments from input buffer
-        binary
-            .builder
+        bin.builder
             .build_store(
                 scratch_len,
-                binary
-                    .context
-                    .i32_type()
-                    .const_int(SCRATCH_SIZE as u64, false),
+                bin.context.i32_type().const_int(SCRATCH_SIZE as u64, false),
             )
             .unwrap();
 
-        binary
-            .builder
+        bin.builder
             .build_call(
-                binary.module.get_function("input").unwrap(),
+                bin.module.get_function("input").unwrap(),
                 &[scratch_buf.into(), scratch_len.into()],
                 "",
             )
             .unwrap();
 
-        let args_length = binary
+        let args_length = bin
             .builder
-            .build_load(binary.context.i32_type(), scratch_len, "input_len")
+            .build_load(bin.context.i32_type(), scratch_len, "input_len")
             .unwrap();
 
         // store the length in case someone wants it via msg.data
-        binary
-            .builder
+        bin.builder
             .build_store(
-                binary.calldata_len.as_pointer_value(),
+                bin.calldata_len.as_pointer_value(),
                 args_length.into_int_value(),
             )
             .unwrap();
@@ -186,8 +179,8 @@ impl PolkadotTarget {
         (scratch_buf, args_length.into_int_value())
     }
 
-    fn declare_externals(&self, binary: &Binary) {
-        let ctx = binary.context;
+    fn declare_externals(&self, bin: &Binary) {
+        let ctx = bin.context;
         let u8_ptr = ctx.i8_type().ptr_type(AddressSpace::default()).into();
         let u32_val = ctx.i32_type().into();
         let u32_ptr = ctx.i32_type().ptr_type(AddressSpace::default()).into();
@@ -195,7 +188,7 @@ impl PolkadotTarget {
 
         macro_rules! external {
             ($name:literal, $fn_type:ident, $( $args:expr ),*) => {
-                binary.module.add_function(
+                bin.module.add_function(
                     $name,
                     ctx.$fn_type().fn_type(&[$($args),*], false),
                     Some(Linkage::External),

src/emit/polkadot/storage.rs

@@ -15,24 +15,24 @@ use num_traits::{One, ToPrimitive};
 impl StorageSlot for PolkadotTarget {
     fn set_storage(
         &self,
-        binary: &Binary,
+        bin: &Binary,
         slot: PointerValue,
         dest: PointerValue,
         dest_ty: BasicTypeEnum,
     ) {
-        emit_context!(binary);
+        emit_context!(bin);
 
         let dest_size = if dest_ty.is_array_type() {
             dest_ty
                 .into_array_type()
                 .size_of()
                 .expect("array should be fixed size")
-                .const_cast(binary.context.i32_type(), false)
+                .const_cast(bin.context.i32_type(), false)
         } else {
             dest_ty
                 .into_int_type()
                 .size_of()
-                .const_cast(binary.context.i32_type(), false)
+                .const_cast(bin.context.i32_type(), false)
         };
 
         seal_set_storage!(
@@ -45,16 +45,15 @@ impl StorageSlot for PolkadotTarget {
 
     fn get_storage_address<'a>(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         slot: PointerValue<'a>,
         ns: &Namespace,
     ) -> ArrayValue<'a> {
-        emit_context!(binary);
+        emit_context!(bin);
 
         let (scratch_buf, scratch_len) = scratch_buf!();
 
-        binary
-            .builder
+        bin.builder
             .build_store(scratch_len, i32_const!(ns.address_length as u64))
             .unwrap();
 
@@ -65,29 +64,27 @@ impl StorageSlot for PolkadotTarget {
             scratch_len.into()
         );
 
-        let exists_is_zero = binary
+        let exists_is_zero = bin
             .builder
             .build_int_compare(IntPredicate::EQ, exists, i32_zero!(), "storage_exists")
             .unwrap();
 
-        binary
-            .builder
+        bin.builder
             .build_select(
                 exists_is_zero,
-                binary
-                    .builder
-                    .build_load(binary.address_type(ns), scratch_buf, "address")
+                bin.builder
+                    .build_load(bin.address_type(ns), scratch_buf, "address")
                     .unwrap()
                     .into_array_value(),
-                binary.address_type(ns).const_zero(),
+                bin.address_type(ns).const_zero(),
                 "retrieved_address",
             )
             .unwrap()
             .into_array_value()
     }
 
-    fn storage_delete_single_slot(&self, binary: &Binary, slot: PointerValue) {
-        emit_context!(binary);
+    fn storage_delete_single_slot(&self, bin: &Binary, slot: PointerValue) {
+        emit_context!(bin);
 
         call!("clear_storage", &[slot.into(), i32_const!(32).into()])
             .try_as_basic_value()

src/emit/soroban/mod.rs

@@ -126,7 +126,7 @@ impl SorobanTarget {
         contract_no: usize,
     ) -> Binary<'a> {
         let filename = ns.files[contract.loc.file_no()].file_name();
-        let mut binary = Binary::new(
+        let mut bin = Binary::new(
             context,
             ns.target,
             &contract.id.name,
@@ -137,29 +137,29 @@ impl SorobanTarget {
         );
 
         let mut export_list = Vec::new();
-        Self::declare_externals(&mut binary);
+        Self::declare_externals(&mut bin);
         Self::emit_functions_with_spec(
             contract,
-            &mut binary,
+            &mut bin,
             ns,
             context,
             contract_no,
             &mut export_list,
         );
-        binary.internalize(export_list.as_slice());
+        bin.internalize(export_list.as_slice());
 
-        Self::emit_initializer(&mut binary, ns);
+        Self::emit_initializer(&mut bin, ns);
 
-        Self::emit_env_meta_entries(context, &mut binary, opt);
+        Self::emit_env_meta_entries(context, &mut bin, opt);
 
-        binary
+        bin
     }
 
     // In Soroban, the public functions specifications is embeded in the contract binary.
     // for each function, emit both the function spec entry and the function body.
     fn emit_functions_with_spec<'a>(
         contract: &'a ast::Contract,
-        binary: &mut Binary<'a>,
+        bin: &mut Binary<'a>,
         ns: &'a ast::Namespace,
         context: &'a Context,
         _contract_no: usize,
@@ -168,7 +168,7 @@ impl SorobanTarget {
         let mut defines = Vec::new();
 
         for (cfg_no, cfg) in contract.cfg.iter().enumerate() {
-            let ftype = binary.function_type(
+            let ftype = bin.function_type(
                 &cfg.params.iter().map(|p| p.ty.clone()).collect::<Vec<_>>(),
                 &cfg.returns.iter().map(|p| p.ty.clone()).collect::<Vec<_>>(),
                 ns,
@@ -187,38 +187,37 @@ impl SorobanTarget {
                 } else {
                     &cfg.name
                 };
-                Self::emit_function_spec_entry(context, cfg, name.to_string(), binary);
+                Self::emit_function_spec_entry(context, cfg, name.to_string(), bin);
                 export_list.push(name);
                 Linkage::External
             } else {
                 Linkage::Internal
             };
 
-            let func_decl = if let Some(func) = binary.module.get_function(&cfg.name) {
+            let func_decl = if let Some(func) = bin.module.get_function(&cfg.name) {
                 // must not have a body yet
                 assert_eq!(func.get_first_basic_block(), None);
 
                 func
             } else {
-                binary.module.add_function(&cfg.name, ftype, Some(linkage))
+                bin.module.add_function(&cfg.name, ftype, Some(linkage))
             };
 
-            binary.functions.insert(cfg_no, func_decl);
+            bin.functions.insert(cfg_no, func_decl);
 
             defines.push((func_decl, cfg));
         }
 
         let init_type = context.i64_type().fn_type(&[], false);
-        binary
-            .module
+        bin.module
             .add_function("storage_initializer", init_type, None);
 
         for (func_decl, cfg) in defines {
-            emit_cfg(&mut SorobanTarget, binary, contract, cfg, func_decl, ns);
+            emit_cfg(&mut SorobanTarget, bin, contract, cfg, func_decl, ns);
         }
     }
 
-    fn emit_env_meta_entries<'a>(context: &'a Context, binary: &mut Binary<'a>, opt: &'a Options) {
+    fn emit_env_meta_entries<'a>(context: &'a Context, bin: &mut Binary<'a>, opt: &'a Options) {
         let mut meta = Limited::new(Vec::new(), Limits::none());
         let soroban_env_interface_version = opt.soroban_version;
         let soroban_env_interface_version = match soroban_env_interface_version {
@@ -231,14 +230,14 @@ impl SorobanTarget {
         ScEnvMetaEntry::ScEnvMetaKindInterfaceVersion(soroban_env_interface_version)
             .write_xdr(&mut meta)
             .expect("writing env meta interface version to xdr");
-        Self::add_custom_section(context, &binary.module, "contractenvmetav0", meta.inner);
+        Self::add_custom_section(context, &bin.module, "contractenvmetav0", meta.inner);
     }
 
     fn emit_function_spec_entry<'a>(
         context: &'a Context,
         cfg: &ControlFlowGraph,
         name: String,
-        binary: &mut Binary<'a>,
+        bin: &mut Binary<'a>,
     ) {
         if cfg.public && !cfg.is_placeholder() {
             // TODO: Emit custom type spec entries
@@ -315,7 +314,7 @@ impl SorobanTarget {
             .write_xdr(&mut spec)
             .unwrap_or_else(|_| panic!("writing spec to xdr for function {}", cfg.name));
 
-            Self::add_custom_section(context, &binary.module, "contractspecv0", spec.inner);
+            Self::add_custom_section(context, &bin.module, "contractspecv0", spec.inner);
         }
     }
 
@@ -342,7 +341,7 @@ impl SorobanTarget {
             .expect("adding spec as metadata");
     }
 
-    fn declare_externals(binary: &mut Binary) {
+    fn declare_externals(bin: &mut Binary) {
         let host_functions = [
             HostFunctions::PutContractData,
             HostFunctions::GetContractData,
@@ -374,25 +373,25 @@ impl SorobanTarget {
         ];
 
         for func in &host_functions {
-            binary.module.add_function(
+            bin.module.add_function(
                 func.name(),
-                func.function_signature(binary),
+                func.function_signature(bin),
                 Some(Linkage::External),
             );
         }
     }
 
-    fn emit_initializer(binary: &mut Binary, _ns: &ast::Namespace) {
+    fn emit_initializer(bin: &mut Binary, _ns: &ast::Namespace) {
         let mut cfg = ControlFlowGraph::new("__constructor".to_string(), ASTFunction::None);
 
         cfg.public = true;
         let void_param = ast::Parameter::new_default(ast::Type::Void);
         cfg.returns = sync::Arc::new(vec![void_param]);
 
-        Self::emit_function_spec_entry(binary.context, &cfg, "__constructor".to_string(), binary);
+        Self::emit_function_spec_entry(bin.context, &cfg, "__constructor".to_string(), bin);
 
         let function_name = CString::new(STORAGE_INITIALIZER).unwrap();
-        let mut storage_initializers = binary
+        let mut storage_initializers = bin
             .functions
             .values()
             .filter(|f: &&inkwell::values::FunctionValue| f.get_name() == function_name.as_c_str());
@@ -401,21 +400,19 @@ impl SorobanTarget {
             .expect("storage initializer is always present");
         assert!(storage_initializers.next().is_none());
 
-        let void_type = binary.context.i64_type().fn_type(&[], false);
+        let void_type = bin.context.i64_type().fn_type(&[], false);
         let constructor =
-            binary
-                .module
+            bin.module
                 .add_function("__constructor", void_type, Some(Linkage::External));
-        let entry = binary.context.append_basic_block(constructor, "entry");
+        let entry = bin.context.append_basic_block(constructor, "entry");
 
-        binary.builder.position_at_end(entry);
-        binary
-            .builder
+        bin.builder.position_at_end(entry);
+        bin.builder
             .build_call(storage_initializer, &[], "storage_initializer")
             .unwrap();
 
         // return zero
-        let zero_val = binary.context.i64_type().const_int(2, false);
-        binary.builder.build_return(Some(&zero_val)).unwrap();
+        let zero_val = bin.context.i64_type().const_int(2, false);
+        bin.builder.build_return(Some(&zero_val)).unwrap();
     }
 }

src/emit/soroban/target.rs

@@ -29,7 +29,7 @@ use std::collections::HashMap;
 impl<'a> TargetRuntime<'a> for SorobanTarget {
     fn get_storage_int(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         function: FunctionValue,
         slot: PointerValue<'a>,
         ty: IntType<'a>,
@@ -39,7 +39,7 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
 
     fn storage_load(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         ty: &ast::Type,
         slot: &mut IntValue<'a>,
         function: FunctionValue<'a>,
@@ -47,19 +47,15 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
         storage_type: &Option<StorageType>,
     ) -> BasicValueEnum<'a> {
         let storage_type = storage_type_to_int(storage_type);
-        emit_context!(binary);
+        emit_context!(bin);
         let ret = call!(
             HostFunctions::GetContractData.name(),
             &[
                 slot.as_basic_value_enum()
                     .into_int_value()
-                    .const_cast(binary.context.i64_type(), false)
-                    .into(),
-                binary
-                    .context
-                    .i64_type()
-                    .const_int(storage_type, false)
+                    .const_cast(bin.context.i64_type(), false)
                     .into(),
+                bin.context.i64_type().const_int(storage_type, false).into(),
             ]
         )
         .try_as_basic_value()
@@ -73,7 +69,7 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
     /// Recursively store a type to storage
     fn storage_store(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         ty: &ast::Type,
         existing: bool,
         slot: &mut IntValue<'a>,
@@ -82,30 +78,26 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
         ns: &ast::Namespace,
         storage_type: &Option<StorageType>,
     ) {
-        emit_context!(binary);
+        emit_context!(bin);
 
         let storage_type = storage_type_to_int(storage_type);
 
-        let function_value = binary
+        let function_value = bin
             .module
             .get_function(HostFunctions::PutContractData.name())
             .unwrap();
 
-        let value = binary
+        let value = bin
             .builder
             .build_call(
                 function_value,
                 &[
                     slot.as_basic_value_enum()
                         .into_int_value()
-                        .const_cast(binary.context.i64_type(), false)
+                        .const_cast(bin.context.i64_type(), false)
                         .into(),
                     dest.into(),
-                    binary
-                        .context
-                        .i64_type()
-                        .const_int(storage_type, false)
-                        .into(),
+                    bin.context.i64_type().const_int(storage_type, false).into(),
                 ],
                 HostFunctions::PutContractData.name(),
             )
@@ -303,7 +295,7 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
 
     fn builtin_function(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         function: FunctionValue<'a>,
         builtin_func: &Function,
         args: &[BasicMetadataValueEnum<'a>],
@@ -618,12 +610,12 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
     }
 
     /// Return the value we received
-    fn value_transferred<'b>(&self, binary: &Binary<'b>, ns: &Namespace) -> IntValue<'b> {
+    fn value_transferred<'b>(&self, bin: &Binary<'b>, ns: &Namespace) -> IntValue<'b> {
         unimplemented!()
     }
 
     /// Terminate execution, destroy bin and send remaining funds to addr
-    fn selfdestruct<'b>(&self, binary: &Binary<'b>, addr: ArrayValue<'b>, ns: &Namespace) {
+    fn selfdestruct<'b>(&self, bin: &Binary<'b>, addr: ArrayValue<'b>, ns: &Namespace) {
         unimplemented!()
     }
 
@@ -654,7 +646,7 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
     /// Return ABI encoded data
     fn return_abi_data<'b>(
         &self,
-        binary: &Binary<'b>,
+        bin: &Binary<'b>,
         data: PointerValue<'b>,
         data_len: BasicValueEnum<'b>,
     ) {

src/emit/storage.rs

@@ -9,7 +9,7 @@ use inkwell::values::{ArrayValue, BasicValueEnum, FunctionValue, IntValue, Point
 pub(super) trait StorageSlot {
     fn set_storage(
         &self,
-        binary: &Binary,
+        bin: &Binary,
         slot: PointerValue,
         dest: PointerValue,
         dest_ty: BasicTypeEnum,
@@ -17,13 +17,13 @@ pub(super) trait StorageSlot {
 
     fn get_storage_address<'a>(
         &self,
-        binary: &Binary<'a>,
+        bin: &Binary<'a>,
         slot: PointerValue<'a>,
         ns: &Namespace,
     ) -> ArrayValue<'a>;
 
     /// Clear a particlar storage slot (slot-based storage chains should implement)
-    fn storage_delete_single_slot(&self, binary: &Binary, slot: PointerValue);
+    fn storage_delete_single_slot(&self, bin: &Binary, slot: PointerValue);
 
     /// Recursively load a type from storage for slot based storage
     fn storage_load_slot<'a>(