Addes support for all ints and unints and the boolean type.

Author: FractalFir

src/lib.rs

@@ -12,7 +12,7 @@ use rustc_codegen_ssa::{traits::CodegenBackend, CodegenResults};
 use rustc_metadata::EncodedMetadata;
 use rustc_middle::{
     dep_graph::{WorkProduct, WorkProductId},
-    ty::{Ty,TyCtxt,TyKind,IntTy},
+    ty::{Ty,TyCtxt,TyKind,IntTy,UintTy},
 };
 use rustc_span::ErrorGuaranteed;
 use std::any::Any;
@@ -31,7 +31,9 @@ pub type IString = Box<str>;
 struct MyBackend;
 #[derive(Clone,Debug)]
 enum VariableType{
-    I32,
+    I8,I16,I32,I64,I128,ISize,
+    U8,U16,U32,U64,U128,USize,
+    Bool,
 }
 #[derive(Debug)]
 struct FunctionSignature{
@@ -54,13 +56,37 @@ impl FunctionSignature{
 impl VariableType{
     fn from_ty(ty:Ty)->Self{
         match ty.kind() {
+            TyKind::Int(IntTy::I8) => VariableType::I8,
+            TyKind::Int(IntTy::I16) => VariableType::I16,
             TyKind::Int(IntTy::I32) => VariableType::I32,
+            TyKind::Int(IntTy::I64) => VariableType::I64,
+            TyKind::Int(IntTy::I128) => VariableType::I128,
+            TyKind::Int(IntTy::Isize) => VariableType::ISize,
+            TyKind::Uint(UintTy::U8) => VariableType::U8,
+            TyKind::Uint(UintTy::U16) => VariableType::U16,
+            TyKind::Uint(UintTy::U32) => VariableType::U32,
+            TyKind::Uint(UintTy::U64) => VariableType::U64,
+            TyKind::Uint(UintTy::U128) => VariableType::U128,
+            TyKind::Uint(UintTy::Usize) => VariableType::USize,
+            TyKind::Bool=>VariableType::Bool,
             _ => todo!("Unhandled type kind {:?}", ty.kind()),
         }
     }
     pub(crate) fn il_name(&self)->IString{
         match self{
-            Self::I32=>"int32"
+            Self::I8=>"int8",
+            Self::I16=>"int16",
+            Self::I32=>"int32",
+            Self::I64=>"int64",
+            Self::I128=>"[System.Runtime]System.Int128",
+            Self::ISize => "native int",
+            Self::U8=>"uint8",
+            Self::U16=>"uint16",
+            Self::U32=>"uint32",
+            Self::U64=>"uint64",
+            Self::U128=>"[System.Runtime]System.UInt128",
+            Self::USize =>"native uint",
+            Self::Bool=>"bool",
         }.into()
     }
 }

test/identity.rs

@@ -1,8 +1,39 @@
+#[no_mangle]
 pub extern fn identity(a:i32)->i32{a}
-pub extern fn add(a:i32)->i32{a+a}
-pub extern fn add2(a:i32,b:i32)->i32{a + b}
+
+#[no_mangle]
 pub extern fn sqr_mag(ax:i32,ay:i32)->i32{ax*ax + ay*ay}
+#[no_mangle]
 pub extern fn pow2(power:i32)->i32{1<<power}
+
+#[no_mangle]
+pub extern fn addisize(a:isize,b:isize)->isize{a+b}
+#[no_mangle]
+pub extern fn addi128(a:i128,b:i128)->i128{a+b}
+#[no_mangle]
+pub extern fn addi64(a:i64,b:i64)->i64{a+b}
+#[no_mangle]
+pub extern fn addi32(a:i32,b:i32)->i32{a+b}
+#[no_mangle]
+pub extern fn addi16(a:i16,b:i16)->i16{a+b}
+#[no_mangle]
+pub extern fn addi8(a:i8,b:i8)->i8{a+b}
+
+#[no_mangle]
+pub extern fn addusize(a:usize,b:usize)->usize{a+b}
+#[no_mangle]
+pub extern fn addu128(a:u128,b:u128)->u128{a+b}
+#[no_mangle]
+pub extern fn addu64(a:u64,b:u64)->u64{a+b}
+#[no_mangle]
+pub extern fn addu32(a:u32,b:u32)->u32{a+b}
+#[no_mangle]
+pub extern fn addu16(a:u16,b:u16)->u16{a+b}
+#[no_mangle]
+pub extern fn addu8(a:u8,b:u8)->u8{a+b}
+
+#[no_mangle]
+pub extern fn boolident(a:bool)->bool{a}
 /*
 pub extern fn factorial(mut n:i32)->i32{
     let mut factorial = 1;