Basic arc classes (breaks Array, MemoryAddress, References)

Cargo.toml

@@ -27,7 +27,7 @@ indexmap = "2.2.6"
 gimli = { version = "0.29.0", default-features = false }
 insta = "1.38.0"
 cmd_lib = "1.9.3"
-derive-visitor = "0.3.0"
+derive-visitor = { version = "0.3.0", git = "https://github.com/andylokandy/derive-visitor", branch = "fix" }
 
 [build-dependencies]
 clap = { version = "4.5.4", features = ["derive"] }

ppl/src/array.ppl

@@ -11,6 +11,12 @@ type Array<T>:
 	capacity: Integer
 	data: MemoryAddress
 
+fn<T> default <:Type<Array<T>>> -> Array<T>:
+	let size = 0
+	let capacity = 0
+	let data = default MemoryAddress
+	return Array<T> { size, capacity, data }
+
 /// Create an empty array
 fn<T> <:Type<T>>[] -> Array<T>:
 	let capacity = 8

ppl/src/core.ppl

@@ -29,6 +29,8 @@ type None
 
 /// Convert `None` to `String`
 fn String from <:None> => "none"
+
+fn default <:Type<None>> => none
 //---------------------------------
 
 
@@ -38,6 +40,8 @@ fn String from <:None> => "none"
 @builtin
 type Bool
 
+fn default <:Type<Bool>> => false
+
 /// Negate boolean value
 fn not <x:Bool> -> Bool:
 	if x:
@@ -67,11 +71,10 @@ fn String from <x: Bool> -> String:
 //=================================
 //            Integer
 //=================================
-type IntegerImpl
-
 @builtin
-type Integer:
-	impl: Reference<IntegerImpl>
+type Integer
+
+fn default <:Type<Integer>> => 0
 
 @mangle_as("integer_eq_integer")
 fn <:Integer> == <:Integer> -> Bool
@@ -122,11 +125,10 @@ fn destroy <:&mut Integer>
 //=================================
 //            Rational
 //=================================
-type RationalImpl
-
 @builtin
-type Rational:
-	impl: Reference<RationalImpl>
+type Rational
+
+fn default <:Type<Rational>> => 0.0
 
 @mangle_as("rational_eq_rational")
 fn <:Rational> == <:Rational> -> Bool
@@ -165,11 +167,10 @@ fn clone <:&Rational> -> Rational
 //=================================
 //            String
 //=================================
-type StringImpl
-
 @builtin
-type String:
-	impl: Reference<StringImpl>
+type String
+
+fn default <:Type<String>> => ""
 
 /// Concatenate 2 strings
 @mangle_as("string_plus_string")
@@ -241,3 +242,11 @@ trait Clonnable:
 	fn clone <:&Self> -> Self
 //=================================
 
+//=================================
+//             Default
+//=================================
+/// Trait for things that have default value
+trait Default:
+	fn default <:Type<Self>> -> Self
+//=================================
+

ppl/src/f64.ppl

@@ -3,6 +3,8 @@ use core.*
 @builtin
 type F64
 
+fn default <:Type<F64>> => F64 from 0.0
+
 fn + <x: F64> => x
 
 @mangle_as("minus_f64")

ppl/src/i32.ppl

@@ -3,6 +3,8 @@ use core.*
 @builtin
 type I32
 
+fn default <:Type<I32>> => 0 as I32
+
 fn + <x: I32> => x
 
 @mangle_as("minus_i32")

ppl/src/memory.ppl

@@ -6,6 +6,8 @@ use math.*
 type MemoryAddress:
 	value: Integer
 
+fn default <:Type<MemoryAddress>> => MemoryAddress { value: 0 }
+
 /// Interpret and integer as memory address
 fn <value: Integer> as MemoryAddress => MemoryAddress { value }
 

src/hir/declarations/trait.rs

@@ -6,7 +6,7 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use derive_visitor::DriveMut;
+use derive_visitor::{DriveMut, VisitorMut};
 use indexmap::IndexMap;
 
 use crate::{
@@ -99,12 +99,17 @@ pub struct TraitData {
     #[drive(skip)]
     pub supertraits: Vec<Trait>,
     /// Associated functions
+    #[drive(with = "drive_functions")]
     pub functions: IndexMap<String, Function>,
     /// Module this trait is located in
     #[drive(skip)]
     pub module: Module,
 }
 
+fn drive_functions<V: VisitorMut>(funcs: &mut IndexMap<String, Function>, visitor: &mut V) {
+    funcs.values_mut().for_each(|f| f.drive_mut(visitor));
+}
+
 impl TraitData {
     /// Iterate over all functions
     pub fn all_functions(&self) -> impl Iterator<Item = Function> + '_ {

src/hir/declarations/types.rs

@@ -402,15 +402,7 @@ impl ClassData {
         if let Some(builtin) = &self.builtin {
             return builtin.size_in_bytes();
         }
-
-        if self.is_opaque() {
-            return POINTER_SIZE;
-        }
-
-        self.members
-            .iter()
-            .map(|m| m.ty().size_in_bytes())
-            .sum::<usize>()
+        return POINTER_SIZE;
     }
 }
 

src/ir/to_ir.rs

@@ -247,24 +247,16 @@ impl<'llvm, C: Context<'llvm>> ToIR<'llvm, C> for ClassData {
             return context.types().f64().into();
         }
 
-        if self.members.is_empty() {
+        if self.is_any_reference() {
             return context.types().opaque(&self.basename).into();
         }
 
-        if let Some(ty) = context.llvm().get_struct_type(&self.name()) {
-            return ty.into();
-        }
-
-        let ty = context.llvm().opaque_struct_type(&self.name());
-        ty.set_body(
-            self.members
-                .iter()
-                .filter_map(|m| m.ty().to_ir(context).try_into_basic_type().ok())
-                .collect::<Vec<_>>()
-                .as_slice(),
-            false,
-        );
-        ty.into()
+        let field_types = self
+            .members
+            .iter()
+            .filter_map(|m| m.ty().to_ir(context).try_into_basic_type().ok())
+            .collect::<Vec<_>>();
+        context.types().arc(&self.name(), &field_types).into()
     }
 }
 
@@ -568,12 +560,25 @@ impl<'llvm, 'm> ToIR<'llvm, FunctionContext<'llvm, 'm, '_>> for Constructor {
             .expect("non-basic type constructor");
         let alloca = context.builder.build_alloca(ty, "").unwrap();
 
+        let ptr = context
+            .builder
+            .build_struct_gep(
+                ty,
+                alloca,
+                0,
+                format!("{}.data", self.ty.referenced_type.name()).as_str(),
+            )
+            .unwrap();
+        let data_ty = context
+            .types()
+            .arc_data(&self.ty.referenced_type.name())
+            .unwrap();
         for init in self.initializers.iter().filter(|i| !i.value.ty().is_none()) {
             let field = context
                 .builder
                 .build_struct_gep(
-                    ty,
-                    alloca,
+                    data_ty,
+                    ptr,
                     init.index as u32,
                     format!("{}.{}", self.ty.referenced_type.name(), init.member.name()).as_str(),
                 )
@@ -609,10 +614,16 @@ impl<'llvm, 'm> HIRExpressionLoweringWithoutLoad<'llvm, 'm> for MemberReference
 
         let base = base.unwrap().into_pointer_value();
         let ty = self.base.ty().to_ir(context).try_into_basic_type().unwrap();
+        let ptr = context
+            .builder
+            .build_struct_gep(ty, base, 0, "")
+            .unwrap()
+            .into();
+        let data_ty = context.types().arc_data(&self.base.ty().name()).unwrap();
         Some(
             context
                 .builder
-                .build_struct_gep(ty, base, self.index as u32, &self.member.name())
+                .build_struct_gep(data_ty, ptr, self.index as u32, &self.member.name())
                 .unwrap()
                 .into(),
         )

src/ir/types.rs

@@ -1,6 +1,6 @@
 use inkwell::{
     context::ContextRef,
-    types::{FloatType, IntType, PointerType, StructType, VoidType},
+    types::{BasicTypeEnum, FloatType, IntType, PointerType, StructType, VoidType},
     AddressSpace,
 };
 
@@ -71,20 +71,30 @@ impl<'llvm> Types<'llvm> {
     }
 
     /// Get wrapper around pointer to opaque impl
-    fn with_impl(&self, name: &str) -> StructType<'llvm> {
+    pub fn arc(&self, name: &str, field_types: &[BasicTypeEnum<'llvm>]) -> StructType<'llvm> {
         if let Some(ty) = self.llvm.get_struct_type(name) {
             return ty;
         }
 
+        let data_ty = self.llvm.opaque_struct_type(&format!("{name}Impl"));
+        if !field_types.is_empty() {
+            data_ty.set_body(field_types, false);
+        }
+
         let ty = self.llvm.opaque_struct_type(name);
-        ty.set_body(&[self.opaque(&format!("{name}Impl")).into()], false);
+        ty.set_body(&[self.pointer().into()], false);
         ty
     }
 
+    /// Get LLVM struct type for data of ARC type
+    pub fn arc_data(&self, name: &str) -> Option<StructType<'llvm>> {
+        self.llvm.get_struct_type(&format!("{name}Impl"))
+    }
+
     /// LLVM IR for [`Class`](Type::Class) type
     pub fn opaque(&self, name: &str) -> PointerType<'llvm> {
         self.get_or_add_opaque_struct(name);
-        self.llvm.ptr_type(AddressSpace::default())
+        self.pointer()
     }
 
     /// LLVM IR for [`None`](Type::None) type
@@ -94,21 +104,26 @@ impl<'llvm> Types<'llvm> {
 
     /// LLVM IR for [`Integer`](Type::Integer) type
     pub fn integer(&self) -> StructType<'llvm> {
-        self.with_impl("Integer")
+        self.arc("Integer", &[])
     }
 
     /// LLVM IR for `Rational` type
     pub fn rational(&self) -> StructType<'llvm> {
-        self.with_impl("Rational")
+        self.arc("Rational", &[])
     }
 
     /// LLVM IR for [`String`](Type::String) type
     pub fn string(&self) -> StructType<'llvm> {
-        self.with_impl("String")
+        self.arc("String", &[])
     }
 
     /// LLVM IR for C string type
     pub fn c_string(&self) -> PointerType<'llvm> {
+        self.pointer()
+    }
+
+    /// LLVM IR for pointer type
+    pub fn pointer(&self) -> PointerType<'llvm> {
         self.llvm.ptr_type(AddressSpace::default())
     }
 }

src/semantics/link_impls.rs

@@ -22,7 +22,7 @@ impl<'ctx, C: Context> TraitFunctionsLinker<'ctx, C> {
 
     fn enter_module_data(&mut self, module: &mut ModuleData) {
         module.monomorphized_functions.drive_mut(self);
-        module.functions.drive_mut(self);
+        module.iter_functions_mut().for_each(|f| f.drive_mut(self));
     }
 
     fn enter_function_data(&mut self, f: &mut FunctionData) {