Take small copy types by value per clippy's prescription

Author: TheDan64

src/attributes.rs

@@ -41,7 +41,7 @@ impl Attribute {
     ///
     /// assert!(enum_attribute.is_enum());
     /// ```
-    pub fn is_enum(&self) -> bool {
+    pub fn is_enum(self) -> bool {
         unsafe {
             LLVMIsEnumAttribute(self.attribute) == 1
         }
@@ -61,7 +61,7 @@ impl Attribute {
     ///
     /// assert!(string_attribute.is_string());
     /// ```
-    pub fn is_string(&self) -> bool {
+    pub fn is_string(self) -> bool {
         unsafe {
             LLVMIsStringAttribute(self.attribute) == 1
         }
@@ -99,7 +99,7 @@ impl Attribute {
     ///
     /// assert_eq!(enum_attribute.get_enum_kind_id(), 0);
     /// ```
-    pub fn get_enum_kind_id(&self) -> u32 {
+    pub fn get_enum_kind_id(self) -> u32 {
         assert!(self.is_enum()); // FIXME: SubTypes
 
         unsafe {
@@ -134,7 +134,7 @@ impl Attribute {
     ///
     /// assert_eq!(enum_attribute.get_enum_value(), 10);
     /// ```
-    pub fn get_enum_value(&self) -> u64 {
+    pub fn get_enum_value(self) -> u64 {
         assert!(self.is_enum()); // FIXME: SubTypes
 
         unsafe {
@@ -207,11 +207,11 @@ pub enum AttributeLoc {
 }
 
 impl AttributeLoc {
-    pub(crate) fn get_index(&self) -> u32 {
+    pub(crate) fn get_index(self) -> u32 {
         match self {
             AttributeLoc::Return => 0,
             AttributeLoc::Param(index) => {
-                assert!(*index <= u32::max_value() - 2, "Param index must be <= u32::max_value() - 2");
+                assert!(index <= u32::max_value() - 2, "Param index must be <= u32::max_value() - 2");
 
                 index + 1
             },

src/basic_block.rs

@@ -61,7 +61,7 @@ impl<'ctx> BasicBlock<'ctx> {
     ///
     /// assert!(basic_block.get_parent().is_none());
     /// ```
-    pub fn get_parent(&self) -> Option<FunctionValue<'ctx>> {
+    pub fn get_parent(self) -> Option<FunctionValue<'ctx>> {
         let value = unsafe {
             LLVMGetBasicBlockParent(self.basic_block)
         };
@@ -95,7 +95,7 @@ impl<'ctx> BasicBlock<'ctx> {
     /// assert!(basic_block2.get_previous_basic_block().is_none());
     /// assert_eq!(basic_block3.get_previous_basic_block().unwrap(), basic_block2);
     /// ```
-    pub fn get_previous_basic_block(&self) -> Option<BasicBlock<'ctx>> {
+    pub fn get_previous_basic_block(self) -> Option<BasicBlock<'ctx>> {
         self.get_parent()?;
 
         let bb = unsafe {
@@ -132,7 +132,7 @@ impl<'ctx> BasicBlock<'ctx> {
     /// assert_eq!(basic_block2.get_next_basic_block().unwrap(), basic_block3);
     /// assert!(basic_block3.get_next_basic_block().is_none());
     /// ```
-    pub fn get_next_basic_block(&self) -> Option<BasicBlock<'ctx>> {
+    pub fn get_next_basic_block(self) -> Option<BasicBlock<'ctx>> {
         self.get_parent()?;
 
         let bb = unsafe {
@@ -166,7 +166,7 @@ impl<'ctx> BasicBlock<'ctx> {
     /// assert_eq!(basic_block2.get_next_basic_block().unwrap(), basic_block1);
     /// ```
     // REVIEW: What happens if blocks are from different scopes?
-    pub fn move_before(&self, basic_block: BasicBlock<'ctx>) -> Result<(), ()> {
+    pub fn move_before(self, basic_block: BasicBlock<'ctx>) -> Result<(), ()> {
         // This method is UB if the parent no longer exists, so we must check for parent (or encode into type system)
         if self.get_parent().is_none() || basic_block.get_parent().is_none() {
             return Err(());
@@ -203,7 +203,7 @@ impl<'ctx> BasicBlock<'ctx> {
     /// assert_eq!(basic_block2.get_next_basic_block().unwrap(), basic_block1);
     /// ```
     // REVIEW: What happens if blocks are from different scopes?
-    pub fn move_after(&self, basic_block: BasicBlock<'ctx>) -> Result<(), ()> {
+    pub fn move_after(self, basic_block: BasicBlock<'ctx>) -> Result<(), ()> {
         // This method is UB if the parent no longer exists, so we must check for parent (or encode into type system)
         if self.get_parent().is_none() || basic_block.get_parent().is_none() {
             return Err(());
@@ -238,7 +238,7 @@ impl<'ctx> BasicBlock<'ctx> {
     ///
     /// assert_eq!(basic_block.get_first_instruction().unwrap().get_opcode(), InstructionOpcode::Return);
     /// ```
-    pub fn get_first_instruction(&self) -> Option<InstructionValue<'ctx>> {
+    pub fn get_first_instruction(self) -> Option<InstructionValue<'ctx>> {
         let value = unsafe {
             LLVMGetFirstInstruction(self.basic_block)
         };
@@ -272,7 +272,7 @@ impl<'ctx> BasicBlock<'ctx> {
     ///
     /// assert_eq!(basic_block.get_last_instruction().unwrap().get_opcode(), InstructionOpcode::Return);
     /// ```
-    pub fn get_last_instruction(&self) -> Option<InstructionValue<'ctx>> {
+    pub fn get_last_instruction(self) -> Option<InstructionValue<'ctx>> {
         let value = unsafe {
             LLVMGetLastInstruction(self.basic_block)
         };
@@ -310,7 +310,7 @@ impl<'ctx> BasicBlock<'ctx> {
     // if getting a value over an instruction is preferable
     // TODOC: Every BB must have a terminating instruction or else it is invalid
     // REVIEW: Unclear how this differs from get_last_instruction
-    pub fn get_terminator(&self) -> Option<InstructionValue<'ctx>> {
+    pub fn get_terminator(self) -> Option<InstructionValue<'ctx>> {
         let value = unsafe {
             LLVMGetBasicBlockTerminator(self.basic_block)
         };
@@ -348,7 +348,7 @@ impl<'ctx> BasicBlock<'ctx> {
     // by taking ownership of self (though BasicBlock's are not uniquely obtained...)
     // might have to make some methods do something like -> Result<..., BasicBlock<Orphan>> for BasicBlock<HasParent>
     // and would move_before/after make it no longer orphaned? etc..
-    pub fn remove_from_function(&self) -> Result<(), ()> {
+    pub fn remove_from_function(self) -> Result<(), ()> {
         // This method is UB if the parent no longer exists, so we must check for parent (or encode into type system)
         if self.get_parent().is_none() {
             return Err(());
@@ -410,7 +410,7 @@ impl<'ctx> BasicBlock<'ctx> {
     ///
     /// assert_eq!(context, *basic_block.get_context());
     /// ```
-    pub fn get_context(&self) -> ContextRef<'ctx> {
+    pub fn get_context(self) -> ContextRef<'ctx> {
         let context = unsafe {
             LLVMGetTypeContext(LLVMTypeOf(LLVMBasicBlockAsValue(self.basic_block)))
         };
@@ -470,7 +470,7 @@ impl<'ctx> BasicBlock<'ctx> {
     ///
     /// assert_eq!(branch_inst.get_operand(0).unwrap().right().unwrap(), bb2);
     /// ```
-    pub fn replace_all_uses_with(&self, other: &BasicBlock<'ctx>) {
+    pub fn replace_all_uses_with(self, other: &BasicBlock<'ctx>) {
         let value = unsafe { LLVMBasicBlockAsValue(self.basic_block) };
         let other = unsafe { LLVMBasicBlockAsValue(other.basic_block) };
 
@@ -506,7 +506,7 @@ impl<'ctx> BasicBlock<'ctx> {
     /// assert!(bb2.get_first_use().is_none());
     /// assert!(bb1.get_first_use().is_some());
     /// ```
-    pub fn get_first_use(&self) -> Option<BasicValueUse> {
+    pub fn get_first_use(self) -> Option<BasicValueUse<'ctx>> {
         let use_ = unsafe {
             LLVMGetFirstUse(LLVMBasicBlockAsValue(self.basic_block))
         };

src/comdat.rs

@@ -33,7 +33,7 @@ impl Comdat {
     }
 
     /// Gets what kind of `Comdat` this is.
-    pub fn get_selection_kind(&self) -> ComdatSelectionKind {
+    pub fn get_selection_kind(self) -> ComdatSelectionKind {
         let kind_ptr = unsafe {
             LLVMGetComdatSelectionKind(self.0)
         };
@@ -42,7 +42,7 @@ impl Comdat {
     }
 
     /// Sets what kind of `Comdat` this should be.
-    pub fn set_selection_kind(&self, kind: ComdatSelectionKind) {
+    pub fn set_selection_kind(self, kind: ComdatSelectionKind) {
         unsafe {
             LLVMSetComdatSelectionKind(self.0, kind.as_llvm_enum())
         }

src/execution_engine.rs

@@ -368,7 +368,7 @@ impl<'ctx> ExecutionEngine<'ctx> {
 
     // TODOC: Marked as unsafe because input function could very well do something unsafe. It's up to the caller
     // to ensure that doesn't happen by defining their function correctly.
-    pub unsafe fn run_function(&self, function: FunctionValue<'ctx>, args: &[&GenericValue]) -> GenericValue {
+    pub unsafe fn run_function(&self, function: FunctionValue<'ctx>, args: &[&GenericValue<'ctx>]) -> GenericValue<'ctx> {
         let mut args: Vec<LLVMGenericValueRef> = args.iter()
                                                      .map(|val| val.generic_value)
                                                      .collect();

src/types/array_type.rs

@@ -36,7 +36,7 @@ impl<'ctx> ArrayType<'ctx> {
     /// let i8_array_type = i8_type.array_type(3);
     /// let i8_array_type_size = i8_array_type.size_of();
     /// ```
-    pub fn size_of(&self) -> Option<IntValue<'ctx>> {
+    pub fn size_of(self) -> Option<IntValue<'ctx>> {
         self.array_type.size_of()
     }
 
@@ -52,7 +52,7 @@ impl<'ctx> ArrayType<'ctx> {
     /// let i8_array_type = i8_type.array_type(3);
     /// let i8_array_type_alignment = i8_array_type.get_alignment();
     /// ```
-    pub fn get_alignment(&self) -> IntValue<'ctx> {
+    pub fn get_alignment(self) -> IntValue<'ctx> {
         self.array_type.get_alignment()
     }
 
@@ -71,7 +71,7 @@ impl<'ctx> ArrayType<'ctx> {
     ///
     /// assert_eq!(i8_array_ptr_type.get_element_type().into_array_type(), i8_array_type);
     /// ```
-    pub fn ptr_type(&self, address_space: AddressSpace) -> PointerType<'ctx> {
+    pub fn ptr_type(self, address_space: AddressSpace) -> PointerType<'ctx> {
         self.array_type.ptr_type(address_space)
     }
 
@@ -88,7 +88,7 @@ impl<'ctx> ArrayType<'ctx> {
     ///
     /// assert_eq!(*i8_array_type.get_context(), context);
     /// ```
-    pub fn get_context(&self) -> ContextRef<'ctx> {
+    pub fn get_context(self) -> ContextRef<'ctx> {
         self.array_type.get_context()
     }
 
@@ -104,7 +104,7 @@ impl<'ctx> ArrayType<'ctx> {
     /// let i8_array_type = i8_type.array_type(3);
     /// let fn_type = i8_array_type.fn_type(&[], false);
     /// ```
-    pub fn fn_type(&self, param_types: &[BasicTypeEnum<'ctx>], is_var_args: bool) -> FunctionType<'ctx> {
+    pub fn fn_type(self, param_types: &[BasicTypeEnum<'ctx>], is_var_args: bool) -> FunctionType<'ctx> {
         self.array_type.fn_type(param_types, is_var_args)
     }
 
@@ -123,7 +123,7 @@ impl<'ctx> ArrayType<'ctx> {
     /// assert_eq!(i8_array_array_type.len(), 3);
     /// assert_eq!(i8_array_array_type.get_element_type().into_array_type(), i8_array_type);
     /// ```
-    pub fn array_type(&self, size: u32) -> ArrayType<'ctx> {
+    pub fn array_type(self, size: u32) -> ArrayType<'ctx> {
         self.array_type.array_type(size)
     }
 
@@ -141,7 +141,7 @@ impl<'ctx> ArrayType<'ctx> {
     ///
     /// assert!(f32_array_array.is_const());
     /// ```
-    pub fn const_array(&self, values: &[ArrayValue<'ctx>]) -> ArrayValue<'ctx> {
+    pub fn const_array(self, values: &[ArrayValue<'ctx>]) -> ArrayValue<'ctx> {
         let mut values: Vec<LLVMValueRef> = values.iter()
                                                   .map(|val| val.as_value_ref())
                                                   .collect();
@@ -164,7 +164,7 @@ impl<'ctx> ArrayType<'ctx> {
     /// let i8_array_type = i8_type.array_type(3);
     /// let i8_array_zero = i8_array_type.const_zero();
     /// ```
-    pub fn const_zero(&self) -> ArrayValue<'ctx> {
+    pub fn const_zero(self) -> ArrayValue<'ctx> {
         ArrayValue::new(self.array_type.const_zero())
     }
 
@@ -181,21 +181,21 @@ impl<'ctx> ArrayType<'ctx> {
     ///
     /// assert_eq!(i8_array_type.len(), 3);
     /// ```
-    pub fn len(&self) -> u32 {
+    pub fn len(self) -> u32 {
         unsafe {
             LLVMGetArrayLength(self.as_type_ref())
         }
     }
 
     /// Prints the definition of a `ArrayType` to a `LLVMString`.
-    pub fn print_to_string(&self) -> LLVMString {
+    pub fn print_to_string(self) -> LLVMString {
         self.array_type.print_to_string()
     }
 
     // See Type::print_to_stderr note on 5.0+ status
     /// Prints the definition of an `ArrayType` to stderr. Not available in newer LLVM versions.
     #[llvm_versions(3.7..=4.0)]
-    pub fn print_to_stderr(&self) {
+    pub fn print_to_stderr(self) {
         self.array_type.print_to_stderr()
     }
 
@@ -212,7 +212,7 @@ impl<'ctx> ArrayType<'ctx> {
     ///
     /// assert!(i8_array_undef.is_undef());
     /// ```
-    pub fn get_undef(&self) -> ArrayValue<'ctx> {
+    pub fn get_undef(self) -> ArrayValue<'ctx> {
         ArrayValue::new(self.array_type.get_undef())
     }
 
@@ -230,7 +230,7 @@ impl<'ctx> ArrayType<'ctx> {
     ///
     /// assert_eq!(i8_array_type.get_element_type().into_int_type(), i8_type);
     /// ```
-    pub fn get_element_type(&self) -> BasicTypeEnum<'ctx> {
+    pub fn get_element_type(self) -> BasicTypeEnum<'ctx> {
         self.array_type.get_element_type().to_basic_type_enum()
     }