reid-llvm-lib/src/builder.rs

@@ -251,10 +251,9 @@ impl Builder {
                     Ok(())
                 }
                 Alloca(_, _) => Ok(()),
-                Load(ptr, load_ty) => {
+                Load(ptr, _) => {
-                    if let Ok(ptr_ty) = ptr.get_type(&self) {
+                    if let Ok(ty) = ptr.get_type(&self) {
-                        if let Type::Ptr(ptr_ty_inner) = ptr_ty {
+                        if let Type::Ptr(_) = ty {
-                            if *ptr_ty_inner == load_ty {
                             Ok(())
                         } else {
                             Err(())
@@ -262,9 +261,6 @@ impl Builder {
                     } else {
                         Err(())
                     }
-                    } else {
-                        Err(())
-                    }
                 }
                 Store(ptr, _) => {
                     if let Ok(ty) = ptr.get_type(&self) {
@@ -336,7 +332,7 @@ impl InstructionValue {
                 FunctionCall(function_value, _) => Ok(builder.function_data(function_value).ret),
                 Phi(values) => values.first().ok_or(()).and_then(|v| v.get_type(&builder)),
                 Alloca(_, ty) => Ok(Type::Ptr(Box::new(ty.clone()))),
-                Load(_, ty) => Ok(ty.clone()),
+                Load(_, ty) => Ok(Type::Ptr(Box::new(ty.clone()))),
                 Store(_, value) => value.get_type(builder),
             }
         }

reid/examples/reid/mutable.reid

@@ -6,11 +6,10 @@ fn indirection() -> bool {
 
 fn main() -> u16 {
     let mut test = 5;
-    let heehoo = 10;
 
     if indirection() {
         test = 11;
     }
 
-    return test + heehoo;
+    return test;
 }

reid/src/mir/scopehints.rs

@@ -40,15 +40,14 @@ type TypeIdRef = Rc<RefCell<usize>>;
 pub struct TypeHints {
     /// Simple list of types that variables can refrence
     hints: RefCell<Vec<TypeKind>>,
-    /// Indirect ID-references, referring to hints-vec
+    types: RefCell<Vec<TypeIdRef>>,
-    type_refs: RefCell<Vec<TypeIdRef>>,
 }
 
 impl TypeHints {
     pub fn new(&self, ty: TypeKind) -> TypeIdRef {
         let idx = self.hints.borrow().len();
         let typecell = Rc::new(RefCell::new(idx));
-        self.type_refs.borrow_mut().push(typecell.clone());
+        self.types.borrow_mut().push(typecell.clone());
         self.hints.borrow_mut().push(ty);
         typecell
     }
@@ -71,13 +70,19 @@ impl<'outer> ScopeHints<'outer> {
         }
     }
 
-    pub fn retrieve_type(&self, idx: usize) -> Option<TypeKind> {
+    pub fn retrieve_type(&self, mut idx: usize) -> Option<TypeKind> {
-        let inner_idx = self
+        // Just make sure we have the correct idx
-            .types
+        let mut inner_idx = self.types.types.borrow().get(idx).map(|i| *i.borrow())?;
-            .type_refs
+        let mut limit = 50;
-            .borrow()
+        while inner_idx != idx {
-            .get(idx)
+            idx = inner_idx;
-            .map(|i| *i.borrow())?;
+            inner_idx = self.types.types.borrow().get(idx).map(|i| *i.borrow())?;
+            limit -= 1;
+            if limit < 0 {
+                // Should never happen, but just to avoid infinite loops
+                panic!("Limit reached!");
+            }
+        }
         self.types.hints.borrow().get(inner_idx).copied()
     }
 
@@ -128,7 +133,7 @@ impl<'outer> ScopeHints<'outer> {
                 .get_unchecked(*hint2.0.borrow())
                 .clone();
             self.narrow_to_type(&hint1, &ty)?;
-            for idx in self.types.type_refs.borrow_mut().iter_mut() {
+            for idx in self.types.types.borrow_mut().iter_mut() {
                 if *idx == hint2.0 {
                     *idx.borrow_mut() = *hint1.0.borrow();
                 }
@@ -193,7 +198,7 @@ impl<'scope> TypeRef<'scope> {
             Ok(ty) => TypeRef::Literal(*ty),
             Err(vague) => match &vague {
                 super::VagueType::Hinted(idx) => TypeRef::Hint(ScopeHint(
-                    unsafe { hints.types.type_refs.borrow().get_unchecked(*idx).clone() },
+                    unsafe { hints.types.types.borrow().get_unchecked(*idx).clone() },
                     hints,
                 )),
                 _ => TypeRef::Hint(hints.new_vague(vague)),

reid/src/mir/typecheck.rs

@@ -38,8 +38,6 @@ pub enum ErrorKind {
     VariableNotMutable(String),
     #[error("Function {0} was given {1} parameters, but {2} were expected")]
     InvalidAmountParameters(String, usize, usize),
-    #[error("Unable to infer type {0}")]
-    TypeNotInferrable(TypeKind),
 }
 
 /// Struct used to implement a type-checking pass that can be performed on the
@@ -196,10 +194,6 @@ impl Block {
                     );
 
                     let res_t = if res_t.known().is_err() {
-                        // state.ok::<_, Infallible>(
-                        //     Err(ErrorKind::TypeNotInferrable(res_t)),
-                        //     variable_reference.2 + expression.1,
-                        // );
                         // Unable to infer variable type even from expression! Default it
                         let res_t =
                             state.or_else(res_t.or_default(), Vague(Unknown), variable_reference.2);
@@ -558,6 +552,8 @@ impl Literal {
                 (L::Vague(VagueL::Number(v)), U32) => L::U32(v as u32),
                 (L::Vague(VagueL::Number(v)), U64) => L::U64(v as u64),
                 (L::Vague(VagueL::Number(v)), U128) => L::U128(v as u128),
+                // Default type for number literal if unable to find true type.
+                (L::Vague(VagueL::Number(v)), Vague(Number)) => L::I32(v as i32),
                 (_, Vague(_)) => self,
                 _ => Err(ErrorKind::LiteralIncompatible(self, hint))?,
             })