add more detailed error messages for type enum conversion

djtech-dev · May 31, 2021 · 7df64d4 · 7df64d4
1 parent 662d841
commit 7df64d4
Showing 1 changed file with 14 additions and 14 deletions.
diff --git a/src/types/enums.rs b/src/types/enums.rs
@@ -128,63 +128,63 @@ impl<'ctx> AnyTypeEnum<'ctx> {
         if let AnyTypeEnum::ArrayType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the ArrayType variant", self);
         }
     }
 
     pub fn into_float_type(self) -> FloatType<'ctx> {
         if let AnyTypeEnum::FloatType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the FloatType variant", self);
         }
     }
 
     pub fn into_function_type(self) -> FunctionType<'ctx> {
         if let AnyTypeEnum::FunctionType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the FunctionType variant", self);
         }
     }
 
     pub fn into_int_type(self) -> IntType<'ctx> {
         if let AnyTypeEnum::IntType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the IntType variant", self);
         }
     }
 
     pub fn into_pointer_type(self) -> PointerType<'ctx> {
         if let AnyTypeEnum::PointerType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the PointerType variant", self);
         }
     }
 
     pub fn into_struct_type(self) -> StructType<'ctx> {
         if let AnyTypeEnum::StructType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the StructType variant", self);
         }
     }
 
     pub fn into_vector_type(self) -> VectorType<'ctx> {
         if let AnyTypeEnum::VectorType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the VectorType variant", self);
         }
     }
 
     pub fn into_void_type(self) -> VoidType<'ctx> {
         if let AnyTypeEnum::VoidType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the VoidType variant", self);
         }
     }
 
@@ -266,47 +266,47 @@ impl<'ctx> BasicTypeEnum<'ctx> {
         if let BasicTypeEnum::ArrayType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the ArrayType variant", self);
         }
     }
 
     pub fn into_float_type(self) -> FloatType<'ctx> {
         if let BasicTypeEnum::FloatType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the FloatType variant", self);
         }
     }
 
     pub fn into_int_type(self) -> IntType<'ctx> {
         if let BasicTypeEnum::IntType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the IntType variant", self);
         }
     }
 
     pub fn into_pointer_type(self) -> PointerType<'ctx> {
         if let BasicTypeEnum::PointerType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the PointerType variant", self);
         }
     }
 
     pub fn into_struct_type(self) -> StructType<'ctx> {
         if let BasicTypeEnum::StructType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the StructType variant", self);
         }
     }
 
     pub fn into_vector_type(self) -> VectorType<'ctx> {
         if let BasicTypeEnum::VectorType(t) = self {
             t
         } else {
-            panic!("Found {:?} but expected another variant", self);
+            panic!("Found {:?} but expected the VectorType variant", self);
         }
     }