Added basic casting for usize/isize types

Author: IsaacShelton

src/asg/datatype/kind/mod.rs

@@ -442,7 +442,10 @@ impl TypeKind {
     pub fn is_integer_like(&self) -> bool {
         matches!(
             self,
-            Self::Integer(..) | Self::IntegerLiteral(..) | Self::CInteger(..)
+            Self::Integer(..)
+                | Self::IntegerLiteral(..)
+                | Self::CInteger(..)
+                | Self::SizeInteger(..)
         )
     }
 

src/lower/cast.rs

@@ -11,6 +11,7 @@ pub fn integer_like_type_size(target: &Target, ty: &asg::Type) -> Option<ByteUni
         asg::TypeKind::Boolean => Some(target.bool_layout().width),
         asg::TypeKind::Integer(bits, _) => Some(bits.bytes()),
         asg::TypeKind::CInteger(c_integer, _) => Some(c_integer.bytes(target)),
+        asg::TypeKind::SizeInteger(_) => Some(target.size_layout().width),
         _ => None,
     }
 }

src/resolve/conform/from_size_integer.rs

@@ -0,0 +1,113 @@
+use super::{ConformMode, Objective, ObjectiveResult};
+use crate::{
+    asg::{
+        Cast, CastFrom, Expr, ExprKind, IntegerBits, Type, TypeKind, TypedExpr, UnaryMathOperation,
+        UnaryMathOperator,
+    },
+    ast::{CInteger, ConformBehavior},
+    ir::IntegerSign,
+    source_files::Source,
+};
+
+pub fn from_size_integer<O: Objective>(
+    expr: &Expr,
+    from_type: &Type,
+    mode: ConformMode,
+    behavior: ConformBehavior,
+    from_sign: IntegerSign,
+    to_type: &Type,
+    source: Source,
+) -> ObjectiveResult<O> {
+    match &to_type.kind {
+        TypeKind::Boolean => {
+            from_size_integer_to_bool::<O>(expr, from_type, mode, behavior, source)
+        }
+        TypeKind::Integer(to_bits, to_sign) => {
+            from_size_integer_to_integer::<O>(expr, mode, from_sign, *to_bits, *to_sign, source)
+        }
+        TypeKind::CInteger(to_c_integer, to_sign) => from_size_integer_to_c_integer::<O>(
+            expr,
+            mode,
+            from_sign,
+            *to_c_integer,
+            *to_sign,
+            source,
+        ),
+        _ => O::fail(),
+    }
+}
+
+fn from_size_integer_to_bool<O: Objective>(
+    expr: &Expr,
+    from_type: &Type,
+    mode: ConformMode,
+    behavior: ConformBehavior,
+    source: Source,
+) -> ObjectiveResult<O> {
+    if !behavior.auto_c_integer_to_bool_conversion() && !mode.allow_lossy_integer() {
+        return O::fail();
+    }
+
+    O::success(|| {
+        TypedExpr::new(
+            TypeKind::Boolean.at(source),
+            ExprKind::UnaryMathOperation(Box::new(UnaryMathOperation {
+                operator: UnaryMathOperator::IsNonZero,
+                inner: TypedExpr::new(from_type.clone(), expr.clone()),
+            }))
+            .at(source),
+        )
+    })
+}
+
+pub fn from_size_integer_to_c_integer<O: Objective>(
+    expr: &Expr,
+    mode: ConformMode,
+    from_sign: IntegerSign,
+    to_c_integer: CInteger,
+    to_sign: Option<IntegerSign>,
+    source: Source,
+) -> ObjectiveResult<O> {
+    if !(mode.allow_lossless_integer() && mode.allow_lossy_integer()) {
+        return O::fail();
+    }
+
+    let target_type = TypeKind::CInteger(to_c_integer, to_sign).at(source);
+
+    return O::success(|| {
+        TypedExpr::new(
+            target_type.clone(),
+            ExprKind::IntegerCast(Box::new(CastFrom {
+                cast: Cast::new(target_type, expr.clone()),
+                from_type: TypeKind::SizeInteger(from_sign).at(source),
+            }))
+            .at(source),
+        )
+    });
+}
+
+fn from_size_integer_to_integer<O: Objective>(
+    expr: &Expr,
+    mode: ConformMode,
+    from_sign: IntegerSign,
+    to_bits: IntegerBits,
+    to_sign: IntegerSign,
+    source: Source,
+) -> ObjectiveResult<O> {
+    if !mode.allow_lossy_integer() {
+        return O::fail();
+    }
+
+    let target_type = TypeKind::Integer(to_bits, to_sign).at(source);
+
+    O::success(|| {
+        TypedExpr::new(
+            target_type.clone(),
+            ExprKind::IntegerCast(Box::new(CastFrom {
+                cast: Cast::new(target_type, expr.clone()),
+                from_type: TypeKind::SizeInteger(from_sign).at(source),
+            }))
+            .at(source),
+        )
+    })
+}

src/resolve/conform/mod.rs

@@ -5,13 +5,15 @@ mod from_float_literal;
 mod from_integer;
 mod from_integer_literal;
 mod from_pointer;
+mod from_size_integer;
 mod mode;
 pub mod to_default;
 
 use self::{
     from_anonymous_enum::from_anonymous_enum, from_c_integer::from_c_integer,
     from_float::from_float, from_float_literal::from_float_literal, from_integer::from_integer,
     from_integer_literal::from_integer_literal, from_pointer::from_pointer,
+    from_size_integer::from_size_integer,
 };
 use super::{
     error::{ResolveError, ResolveErrorKind},
@@ -117,6 +119,15 @@ pub fn conform_expr<O: Objective>(
             &to_type,
             conform_source,
         ),
+        TypeKind::SizeInteger(from_sign) => from_size_integer::<O>(
+            &expr.expr,
+            &from_type,
+            mode,
+            behavior,
+            *from_sign,
+            &to_type,
+            conform_source,
+        ),
         TypeKind::AnonymousEnum(enumeration) => from_anonymous_enum::<O>(
             &expr.expr,
             &from_type,

src/resolve/expr/call/cast.rs

@@ -14,7 +14,7 @@ use itertools::Itertools;
 use num::BigInt;
 use ordered_float::NotNan;
 
-pub fn cast(
+pub fn find_builtin_cast_func(
     ctx: &mut ResolveExprCtx,
     call: &ast::Call,
     args: Vec<TypedExpr>,

src/resolve/expr/call/mod.rs

@@ -15,7 +15,7 @@ use crate::{
     },
     source_files::Source,
 };
-use cast::cast;
+use cast::find_builtin_cast_func;
 use infer_impl::infer_callee_missing_impl_args;
 use itertools::Itertools;
 use specified_impl::resolve_impl_arg;
@@ -39,7 +39,7 @@ pub fn resolve_call_expr(
 
     let generics = resolve_type_args_to_poly_args(ctx, &call.generics)?;
 
-    let args = match cast(ctx, call, args, source)? {
+    let args = match find_builtin_cast_func(ctx, call, args, source)? {
         Ok(cast) => return Ok(cast),
         Err(args) => args,
     };