Continued working on support for size_t/ssize_t/usize/isize types

Author: IsaacShelton

src/ast/expr/integer.rs

@@ -23,6 +23,7 @@ impl IntegerKnown {
         match self.rigidity {
             IntegerRigidity::Fixed(bits, sign) => TypeKind::Integer(bits, sign),
             IntegerRigidity::Loose(c_integer, sign) => TypeKind::CInteger(c_integer, sign),
+            IntegerRigidity::Size(sign) => TypeKind::SizeInteger(sign),
         }
         .at(source)
     }
@@ -32,6 +33,7 @@ impl IntegerKnown {
 pub enum IntegerRigidity {
     Fixed(IntegerBits, IntegerSign),
     Loose(CInteger, Option<IntegerSign>),
+    Size(IntegerSign),
 }
 
 impl Integer {

src/lower/datatype.rs

@@ -2,9 +2,10 @@ use super::error::LowerError;
 use crate::{
     asg::{self, Asg},
     ast::{CInteger, FloatSize},
+    data_units::ByteUnits,
     ir::{self, IntegerSign},
     lower::{error::LowerErrorKind, structure::monomorphize_structure},
-    target::{Target, TargetOsExt},
+    target::{type_layout::TypeLayout, Target, TargetOsExt},
 };
 use std::borrow::{Borrow, Cow};
 
@@ -43,10 +44,15 @@ pub fn lower_type(
             (Bits::Bits64, Sign::Unsigned) => ir::Type::U64,
         }),
         asg::TypeKind::CInteger(integer, sign) => Ok(lower_c_integer(target, *integer, *sign)),
-        asg::TypeKind::SizeInteger(sign) => Ok(match sign {
-            Sign::Signed => ir::Type::S64,
-            Sign::Unsigned => ir::Type::U64,
-        }),
+        asg::TypeKind::SizeInteger(sign) => {
+            let layout = ir_module.target.size_layout();
+            assert_eq!(layout, TypeLayout::basic(ByteUnits::of(8)));
+
+            Ok(match sign {
+                Sign::Signed => ir::Type::S64,
+                Sign::Unsigned => ir::Type::U64,
+            })
+        }
         asg::TypeKind::IntegerLiteral(value) => {
             Err(LowerErrorKind::CannotLowerUnspecializedIntegerLiteral {
                 value: value.to_string(),

src/lower/expr/mod.rs

@@ -49,6 +49,11 @@ pub fn lower_expr(
 
                     (bits, sign)
                 }
+                IntegerRigidity::Size(sign) => {
+                    let bits = IntegerBits::try_from(ir_module.target.size_layout().width)
+                        .expect("supported integer size");
+                    (bits, *sign)
+                }
             };
 
             match (bits, sign) {

src/resolve/conform/from_integer_literal.rs

@@ -1,9 +1,9 @@
 use super::{Objective, ObjectiveResult};
 use crate::{
+    asg::{Expr, ExprKind, Type, TypeKind, TypedExpr},
     ast::{CInteger, CIntegerAssumptions, FloatSize, IntegerBits, IntegerKnown, IntegerRigidity},
     data_units::BitUnits,
     ir::IntegerSign,
-    asg::{Expr, ExprKind, Type, TypeKind, TypedExpr},
     source_files::Source,
 };
 use num::{BigInt, Zero};
@@ -28,6 +28,9 @@ pub fn from_integer_literal<O: Objective>(
         TypeKind::Integer(to_bits, to_sign) => {
             from_integer_literal_to_integer::<O>(value, *to_bits, *to_sign, source)
         }
+        TypeKind::SizeInteger(to_sign) => {
+            from_integer_literal_to_size_integer::<O>(value, *to_sign, source)
+        }
         _ => O::fail(),
     }
 }
@@ -91,6 +94,34 @@ fn from_integer_literal_to_c_integer<O: Objective>(
     O::fail()
 }
 
+fn from_integer_literal_to_size_integer<O: Objective>(
+    value: &BigInt,
+    to_sign: IntegerSign,
+    source: Source,
+) -> ObjectiveResult<O> {
+    // Size types (i.e. size_t, ssize_t, usize, isize) are guananteed to be at least 16 bits
+    // Anything more than that will require explicit casts
+    let does_fit = match to_sign {
+        IntegerSign::Signed => i16::try_from(value).is_ok(),
+        IntegerSign::Unsigned => u16::try_from(value).is_ok(),
+    };
+
+    if does_fit {
+        return O::success(|| {
+            TypedExpr::new(
+                TypeKind::SizeInteger(to_sign).at(source),
+                ExprKind::IntegerKnown(Box::new(IntegerKnown {
+                    rigidity: IntegerRigidity::Size(to_sign),
+                    value: value.clone(),
+                }))
+                .at(source),
+            )
+        });
+    }
+
+    O::fail()
+}
+
 fn from_integer_literal_to_float<O: Objective>(
     value: &BigInt,
     to_size: FloatSize,

src/resolve/expr/call/cast.rs

@@ -109,6 +109,8 @@ pub fn cast(
             CInteger::LongLong,
             Some(IntegerSign::Unsigned),
         )),
+        "isize" => Some(asg::TypeKind::SizeInteger(IntegerSign::Signed)),
+        "usize" => Some(asg::TypeKind::SizeInteger(IntegerSign::Unsigned)),
         _ => None,
     };
 

src/resolve/expr/mod.rs

@@ -378,7 +378,7 @@ pub fn resolve_expr(
                 .resolve(ast_type, ResolveTypeOptions::Unalias)?;
 
             Ok(TypedExpr::new(
-                // NOTE: This will used the unsigned size integer type in the future
+                // NOTE: This will be the unsigned size integer type in the future
                 // asg::TypeKind::SizeInteger(IntegerSign::Unsigned).at(source),
                 asg::TypeKind::Integer(asg::IntegerBits::Bits64, IntegerSign::Unsigned).at(source),
                 asg::ExprKind::SizeOf(Box::new(ty)).at(source),
@@ -395,7 +395,7 @@ pub fn resolve_expr(
             .ty;
 
             Ok(TypedExpr::new(
-                // NOTE: This will used the unsigned size integer type in the future
+                // NOTE: This will used be unsigned size integer type in the future
                 // asg::TypeKind::SizeInteger(IntegerSign::Unsigned).at(source),
                 asg::TypeKind::Integer(asg::IntegerBits::Bits64, IntegerSign::Unsigned).at(source),
                 asg::ExprKind::SizeOf(Box::new(ty)).at(source),

src/target/mod.rs

@@ -140,6 +140,10 @@ impl Target {
     pub fn double_layout(&self) -> TypeLayout {
         TypeLayout::basic(ByteUnits::of(8))
     }
+
+    pub fn size_layout(&self) -> TypeLayout {
+        TypeLayout::basic(ByteUnits::of(8))
+    }
 }
 
 impl Display for Target {

src/target/type_layout.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 use once_map::unsync::OnceMap;
 
-#[derive(Copy, Clone, Debug, Default)]
+#[derive(Copy, Clone, Debug, Default, PartialEq)]
 pub enum AlignmentRequirement {
     #[default]
     None,
@@ -27,7 +27,7 @@ pub struct ASTRecordLayout {
     pub field_offsets: Vec<BitUnits>,
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub struct TypeLayout {
     pub width: ByteUnits,
     pub alignment: ByteUnits,

tests/success/size_integers/main.adept

@@ -0,0 +1,10 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+func main {
+    x usize = 1234
+    printf(c"%zu\n", x)
+}