feat(hir): copy intrinsics for i8

Author: andogq

src/passes/codegen.rs

@@ -404,16 +404,20 @@ impl<'ctx, 'mir, 'ink> Codegen<'ctx, 'mir, 'ink> {
                             .as_basic_value_enum(),
                         lhs_ty_id,
                     ),
-                    (Type::U8, BinaryOperation::PlusWithOverflow, Type::U8) => {
+                    (
+                        lhs_ty @ (Type::U8 | Type::I8),
+                        BinaryOperation::PlusWithOverflow,
+                        rhs_ty @ (Type::U8 | Type::I8),
+                    ) if lhs_ty == rhs_ty => {
                         let intrinsic = Intrinsic::find("llvm.uadd.with.overflow").unwrap();
                         let intrinsic_function = intrinsic
-                            .get_declaration(&self.module, &[self.ink.i8_type().into()])
+                            .get_declaration(&self.module, &[self.basic_ty(lhs_ty_id)])
                             .unwrap();
                         let call_result = builder
                             .build_call(
                                 intrinsic_function,
                                 &[lhs.into(), rhs.into()],
-                                "u8_add_overflow",
+                                "add_overflow",
                             )
                             .unwrap();
 

src/passes/hir_gen/annotations/intrinsic.rs

@@ -33,13 +33,13 @@ pub fn intrinsic_handler(ctx: &mut Ctx, hir: &mut hir::Hir, hir_node: HirId) {
                 .parameters
                 .iter()
                 .zip(hir_signature.parameters.iter().map(|(_, ty)| *ty))
-                .all(|(intrinsic, signature)| intrinsic.into_type(&mut ctx.types) == signature)
+                .all(|(intrinsic, signature)| intrinsic.as_type(&mut ctx.types) == signature)
             // Return type must match.
             && intrinsic
                 .signature
                 .return_ty
                 .as_ref()
-                .map(|ty| ty.into_type(&mut ctx.types))
+                .map(|ty| ty.as_type(&mut ctx.types))
                 .unwrap_or(ctx.types.unit())
             == hir_signature.return_ty;
     if !signature_valid {
@@ -113,15 +113,15 @@ enum PrimitiveType {
 }
 
 impl PrimitiveType {
-    fn into_type(&self, types: &mut Types) -> TypeId {
+    fn as_type(&self, types: &mut Types) -> TypeId {
         match self {
             PrimitiveType::U8 => types.u8(),
             PrimitiveType::I8 => types.i8(),
             PrimitiveType::Boolean => types.boolean(),
             PrimitiveType::Tuple(primitive_types) => {
                 let inner = primitive_types
                     .iter()
-                    .map(|ty| ty.into_type(types))
+                    .map(|ty| ty.as_type(types))
                     .collect::<Vec<_>>();
                 types.tuple(inner)
             }
@@ -214,4 +214,8 @@ intrinsics! {
     u8_add_wrapping(lhs: u8, rhs: u8) -> u8 { BinaryOperation(Plus) };
     u8_add_overflow(lhs: u8, rhs: u8) -> (u8, bool) { BinaryOperation(PlusWithOverflow) };
     u8_not(n: u8) -> u8 { UnaryOperation(Not) };
+
+    i8_add_wrapping(lhs: i8, rhs: i8) -> i8 { BinaryOperation(Plus) };
+    i8_add_overflow(lhs: i8, rhs: i8) -> (i8, bool) { BinaryOperation(PlusWithOverflow) };
+    i8_not(n: i8) -> i8 { UnaryOperation(Not) };
 }

src/passes/hir_gen/annotations/mod.rs

@@ -16,20 +16,6 @@ pub struct Annotation {
     pub value: Option<StringId>,
 }
 
-impl Annotation {
-    pub fn new(key: StringId, value: Option<StringId>) -> Self {
-        Self { key, value }
-    }
-
-    pub fn key(key: StringId) -> Self {
-        Self::new(key, None)
-    }
-
-    pub fn key_value(key: StringId, value: StringId) -> Self {
-        Self::new(key, Some(value))
-    }
-}
-
 pub fn run_annotation_handlers(ctx: &mut Ctx, hir: &mut hir::Hir) {
     // HACK: Don't clone all annotations.
     for (node, annotations) in hir.annotations.clone() {