Fixed rust-lang#97

Author: TheDan64

src/attributes.rs

@@ -189,3 +189,28 @@ impl Attribute {
         }
     }
 }
+
+/// An `AttributeLoc` determines where on a function an attribute is assigned to.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum AttributeLoc {
+    /// Assign to the `FunctionValue`'s return type.
+    Return,
+    /// Assign to one of the `FunctionValue`'s params (0-indexed).
+    Param(u32),
+    /// Assign to the `FunctionValue` itself.
+    Function,
+}
+
+impl AttributeLoc {
+    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");
+
+                index + 1
+            },
+            AttributeLoc::Function => u32::max_value(),
+        }
+    }
+}

src/values/call_site_value.rs

@@ -4,7 +4,7 @@ use llvm_sys::core::{LLVMIsTailCall, LLVMSetTailCall, LLVMGetTypeKind, LLVMTypeO
 use llvm_sys::prelude::LLVMValueRef;
 
 #[llvm_versions(3.9..=latest)]
-use crate::attributes::Attribute;
+use crate::attributes::{Attribute, AttributeLoc};
 use crate::support::LLVMString;
 use crate::values::{AsValueRef, BasicValueEnum, InstructionValue, Value};
 #[llvm_versions(3.9..=latest)]
@@ -112,6 +112,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -128,15 +129,15 @@ impl CallSiteValue {
     ///
     /// let call_site_value = builder.build_call(fn_value, &[], "my_fn");
     ///
-    /// call_site_value.add_attribute(0, string_attribute);
-    /// call_site_value.add_attribute(0, enum_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, string_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, enum_attribute);
     /// ```
     #[llvm_versions(3.9..=latest)]
-    pub fn add_attribute(&self, index: u32, attribute: Attribute) {
+    pub fn add_attribute(&self, loc: AttributeLoc, attribute: Attribute) {
         use llvm_sys::core::LLVMAddCallSiteAttribute;
 
         unsafe {
-            LLVMAddCallSiteAttribute(self.as_value_ref(), index, attribute.attribute)
+            LLVMAddCallSiteAttribute(self.as_value_ref(), loc.get_index(), attribute.attribute)
         }
     }
 
@@ -179,6 +180,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -195,17 +197,17 @@ impl CallSiteValue {
     ///
     /// let call_site_value = builder.build_call(fn_value, &[], "my_fn");
     ///
-    /// call_site_value.add_attribute(0, string_attribute);
-    /// call_site_value.add_attribute(0, enum_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, string_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, enum_attribute);
     ///
-    /// assert_eq!(call_site_value.count_attributes(0), 2);
+    /// assert_eq!(call_site_value.count_attributes(AttributeLoc::Return), 2);
     /// ```
     #[llvm_versions(3.9..=latest)]
-    pub fn count_attributes(&self, index: u32) -> u32 {
+    pub fn count_attributes(&self, loc: AttributeLoc) -> u32 {
         use llvm_sys::core::LLVMGetCallSiteAttributeCount;
 
         unsafe {
-            LLVMGetCallSiteAttributeCount(self.as_value_ref(), index)
+            LLVMGetCallSiteAttributeCount(self.as_value_ref(), loc.get_index())
         }
     }
 
@@ -214,6 +216,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -230,18 +233,18 @@ impl CallSiteValue {
     ///
     /// let call_site_value = builder.build_call(fn_value, &[], "my_fn");
     ///
-    /// call_site_value.add_attribute(0, string_attribute);
-    /// call_site_value.add_attribute(0, enum_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, string_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, enum_attribute);
     ///
-    /// assert_eq!(call_site_value.get_enum_attribute(0, 1).unwrap(), enum_attribute);
+    /// assert_eq!(call_site_value.get_enum_attribute(AttributeLoc::Return, 1).unwrap(), enum_attribute);
     /// ```
     // SubTypes: -> Attribute<Enum>
     #[llvm_versions(3.9..=latest)]
-    pub fn get_enum_attribute(&self, index: u32, kind_id: u32) -> Option<Attribute> {
+    pub fn get_enum_attribute(&self, loc: AttributeLoc, kind_id: u32) -> Option<Attribute> {
         use llvm_sys::core::LLVMGetCallSiteEnumAttribute;
 
         let ptr = unsafe {
-            LLVMGetCallSiteEnumAttribute(self.as_value_ref(), index, kind_id)
+            LLVMGetCallSiteEnumAttribute(self.as_value_ref(), loc.get_index(), kind_id)
         };
 
         if ptr.is_null() {
@@ -256,6 +259,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -272,18 +276,18 @@ impl CallSiteValue {
     ///
     /// let call_site_value = builder.build_call(fn_value, &[], "my_fn");
     ///
-    /// call_site_value.add_attribute(0, string_attribute);
-    /// call_site_value.add_attribute(0, enum_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, string_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, enum_attribute);
     ///
-    /// assert_eq!(call_site_value.get_string_attribute(0, "my_key").unwrap(), string_attribute);
+    /// assert_eq!(call_site_value.get_string_attribute(AttributeLoc::Return, "my_key").unwrap(), string_attribute);
     /// ```
     // SubTypes: -> Attribute<String>
     #[llvm_versions(3.9..=latest)]
-    pub fn get_string_attribute(&self, index: u32, key: &str) -> Option<Attribute> {
+    pub fn get_string_attribute(&self, loc: AttributeLoc, key: &str) -> Option<Attribute> {
         use llvm_sys::core::LLVMGetCallSiteStringAttribute;
 
         let ptr = unsafe {
-            LLVMGetCallSiteStringAttribute(self.as_value_ref(), index, key.as_ptr() as *const i8, key.len() as u32)
+            LLVMGetCallSiteStringAttribute(self.as_value_ref(), loc.get_index(), key.as_ptr() as *const i8, key.len() as u32)
         };
 
         if ptr.is_null() {
@@ -298,6 +302,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -314,18 +319,18 @@ impl CallSiteValue {
     ///
     /// let call_site_value = builder.build_call(fn_value, &[], "my_fn");
     ///
-    /// call_site_value.add_attribute(0, string_attribute);
-    /// call_site_value.add_attribute(0, enum_attribute);
-    /// call_site_value.remove_enum_attribute(0, 1);
+    /// call_site_value.add_attribute(AttributeLoc::Return, string_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, enum_attribute);
+    /// call_site_value.remove_enum_attribute(AttributeLoc::Return, 1);
     ///
-    /// assert_eq!(call_site_value.get_enum_attribute(0, 1), None);
+    /// assert_eq!(call_site_value.get_enum_attribute(AttributeLoc::Return, 1), None);
     /// ```
     #[llvm_versions(3.9..=latest)]
-    pub fn remove_enum_attribute(&self, index: u32, kind_id: u32) {
+    pub fn remove_enum_attribute(&self, loc: AttributeLoc, kind_id: u32) {
         use llvm_sys::core::LLVMRemoveCallSiteEnumAttribute;
 
         unsafe {
-            LLVMRemoveCallSiteEnumAttribute(self.as_value_ref(), index, kind_id)
+            LLVMRemoveCallSiteEnumAttribute(self.as_value_ref(), loc.get_index(), kind_id)
         }
     }
 
@@ -334,6 +339,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -350,18 +356,18 @@ impl CallSiteValue {
     ///
     /// let call_site_value = builder.build_call(fn_value, &[], "my_fn");
     ///
-    /// call_site_value.add_attribute(0, string_attribute);
-    /// call_site_value.add_attribute(0, enum_attribute);
-    /// call_site_value.remove_string_attribute(0, "my_key");
+    /// call_site_value.add_attribute(AttributeLoc::Return, string_attribute);
+    /// call_site_value.add_attribute(AttributeLoc::Return, enum_attribute);
+    /// call_site_value.remove_string_attribute(AttributeLoc::Return, "my_key");
     ///
-    /// assert_eq!(call_site_value.get_string_attribute(0, "my_key"), None);
+    /// assert_eq!(call_site_value.get_string_attribute(AttributeLoc::Return, "my_key"), None);
     /// ```
     #[llvm_versions(3.9..=latest)]
-    pub fn remove_string_attribute(&self, index: u32, key: &str) {
+    pub fn remove_string_attribute(&self, loc: AttributeLoc, key: &str) {
         use llvm_sys::core::LLVMRemoveCallSiteStringAttribute;
 
         unsafe {
-            LLVMRemoveCallSiteStringAttribute(self.as_value_ref(), index, key.as_ptr() as *const i8, key.len() as u32)
+            LLVMRemoveCallSiteStringAttribute(self.as_value_ref(), loc.get_index(), key.as_ptr() as *const i8, key.len() as u32)
         }
     }
 
@@ -370,6 +376,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -462,6 +469,7 @@ impl CallSiteValue {
     /// # Example
     ///
     /// ```no_run
+    /// use inkwell::attributes::AttributeLoc;
     /// use inkwell::context::Context;
     ///
     /// let context = Context::create();
@@ -476,13 +484,13 @@ impl CallSiteValue {
     ///
     /// let call_site_value = builder.build_call(fn_value, &[], "my_fn");
     ///
-    /// call_site_value.set_param_alignment_attribute(0, 2);
+    /// call_site_value.set_alignment_attribute(AttributeLoc::Param(0), 2);
     /// ```
-    pub fn set_param_alignment_attribute(&self, index: u32, alignment: u32) {
+    pub fn set_alignment_attribute(&self, loc: AttributeLoc, alignment: u32) {
         assert_eq!(alignment.count_ones(), 1, "Alignment must be a power of two.");
 
         unsafe {
-            LLVMSetInstrParamAlignment(self.as_value_ref(), index, alignment)
+            LLVMSetInstrParamAlignment(self.as_value_ref(), loc.get_index(), alignment)
         }
     }