Unsafe pointer

crates/codegen/src/fmt/mod.rs

@@ -176,7 +176,7 @@ impl GetMist for TypeExpr {
             }
             Self::UnsafePtr { mutable, ty } => {
                 let mutable = if *mutable { "mut " } else { "const " };
-                format!("*{mutable}{}", ty.get_mist())
+                format!("{} {mutable} unsafe&", ty.get_mist())
             }
             Self::Ref {
                 lifetime,
@@ -185,19 +185,12 @@ impl GetMist for TypeExpr {
             } => {
                 let base = ty.get_mist();
                 if let Some(lifetime) = lifetime {
-                    match lifetime {
-                        Lifetime::Lifetime(v) => {
                     format!(
                         "{} {} '{}&",
                         base,
                         if *mutable { "mut" } else { "" },
-                                v.get_mist()
+                        lifetime.get_mist()
                     )
-                        }
-                        Lifetime::Unsafe => {
-                            format!("{} {} unsafe&", base, if *mutable { "mut" } else { "const" })
-                        }
-                    }
                 } else if *mutable {
                     format!("{} mut&", base)
                 } else {

crates/codegen/src/lib.rs

@@ -239,6 +239,7 @@ impl GetRust for TypeExpr {
             Self::UnsafePtr { mutable, ty } => {
                 let mutable = if *mutable { "mut " } else { "const " };
                 format!("*{mutable}{}", ty.get_rust())
+                
             }
 
             Self::Ref {
@@ -247,23 +248,12 @@ impl GetRust for TypeExpr {
                 ty,
             } => {
                 if let Some(lifetime) = lifetime {
-                    match lifetime {
-                        Lifetime::Lifetime(v) => {
                     format!(
                         "&'{} {}{}",
-                                v.get_rust(),
+                        lifetime.get_rust(),
                         if *mutable { "mut " } else { "" },
                         ty.get_rust()
                     )
-                        }
-                        Lifetime::Unsafe => {
-                            format!(
-                                "*{} {}",
-                                if *mutable { "mut" } else { "const" },
-                                ty.get_rust()
-                            )
-                        }
-                    }
                 } else {
                     format!("&{}{}", if *mutable { "mut " } else { "" }, ty.get_rust())
                 }

crates/parser/src/ast/mod.rs

@@ -17,16 +17,10 @@ pub struct Identifier(pub String);
 #[derive(Debug, Clone, Serialize, Default)]
 pub struct ParamList(pub Vec<VarDecl>);
 
-#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
-pub enum Lifetime {
-    Lifetime(Identifier),
-    Unsafe,
-}
-
 #[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
 pub enum TypeExpr {
     Ref {
-        lifetime: Option<Lifetime>,
+        lifetime: Option<Identifier>,
         mutable: bool,
         ty: Box<TypeExpr>,
     },

crates/parser/src/grammar.pest

@@ -81,7 +81,6 @@ module_program = {
 
 visibility = { "pub" ~ ("(" ~ static_path ~ ")")? }
 mutable    = { "mut" }
-unsafe_kw  = { "unsafe" }
 
 // ======================================================
 // GENERICS
@@ -104,10 +103,12 @@ path_type = {
     static_path ~ generics?
 }
 
-ref_lifetime = { lifetime | unsafe_kw }
+unsafe_ref_type = {
+    mutable? ~ "unsafe" ~ "*"
+}
 
 ref_type = {
-    mutable? ~ ref_lifetime? ~ "&"
+    mutable? ~ lifetime? ~ "&"
 }
 
 dyn_type = {
@@ -115,7 +116,7 @@ dyn_type = {
 }
 
 type_expr = {
-    (path_type | tuple_type | dyn_type) ~ ref_type*
+    (path_type | tuple_type | dyn_type) ~ (unsafe_ref_type | ref_type)*
 }
 
 lifetime = {

crates/parser/src/parser/common/types.rs

@@ -21,18 +21,31 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypeExpr {
                 let mut ty = TypeExpr::try_from(inner.next().unwrap())?;
 
                 for ref_pair in inner {
-                    let mut ref_inner = ref_pair.into_inner();
+                    let mut ref_inner = ref_pair.clone().into_inner();
 
+                    match ref_pair.as_rule() {
+                        Rule::ref_type => {
                             ty = TypeExpr::Ref {
-                        lifetime: consume_rule(&mut ref_inner, Rule::ref_lifetime)
+                                mutable: listen_rule(&mut ref_inner, Rule::mutable),
-                            .map(|v| v.into_inner().next().map(Lifetime::try_from))
+                                lifetime: consume_rule(&mut ref_inner, Rule::lifetime)
+                                    .map(|v| v.into_inner().next().map(Identifier::try_from))
                                     .unwrap_or_default()
                                     .transpose()?,
+                                ty: Box::new(ty),
+                            };
+                        }
+
+                        Rule::unsafe_ref_type => {
+                            ty = TypeExpr::UnsafePtr {
                                 mutable: listen_rule(&mut ref_inner, Rule::mutable),
                                 ty: Box::new(ty),
                             };
                         }
 
+                        _ => AstError::bug_unimplemented(ref_pair)?,
+                    }
+                }
+
                 Ok(ty)
             }
             Rule::lifetime => Ok(TypeExpr::Lifetime(inner.next().unwrap().try_into()?)),

crates/parser/src/parser/items/function.rs

@@ -2,7 +2,7 @@ use crate::{
     Rule,
     ast::*,
     ast_ensure,
-    error::{self, AstError, AstResult},
+    error::{AstError, AstResult},
     parser::{consume_rule, consume_rule_map, listen_rule},
 };
 
@@ -66,18 +66,3 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Override {
         })
     }
 }
-
-impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Lifetime {
-    type Error = AstError<'a>;
-
-    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        let mut inner = pair.clone().into_inner();
-
-        match pair.as_rule() {
-            Rule::ref_lifetime => inner.next().unwrap().try_into(),
-            Rule::lifetime => Ok(Lifetime::Lifetime(inner.next().unwrap().try_into()?)),
-            Rule::unsafe_kw => Ok(Lifetime::Unsafe),
-            _ => error::AstError::bug_unimplemented(pair),
-        }
-    }
-}