Added null keyword for creating null pointer values

Author: IsaacShelton

Diff for: src/asg/expr/kind.rs

@@ -19,6 +19,7 @@ pub enum ExprKind {
     FloatingLiteral(FloatSize, Option<NotNan<f64>>),
     String(String),
     NullTerminatedString(CString),
+    Null,
     Call(Box<Call>),
     PolyCall(Box<PolyCall>),
     DeclareAssign(Box<DeclareAssign>),

Diff for: src/ast/expr/kind.rs

@@ -16,6 +16,7 @@ pub enum ExprKind {
     String(String),
     NullTerminatedString(CString),
     CharLiteral(u8),
+    Null,
     Call(Box<Call>),
     DeclareAssign(Box<DeclareAssign>),
     BasicBinaryOperation(Box<BasicBinaryOperation>),

Diff for: src/lexer/identifier_state.rs

@@ -47,6 +47,7 @@ impl IdentifierState {
             "impl" => TokenKind::ImplKeyword,
             "for" => TokenKind::ForKeyword,
             "is" => TokenKind::IsKeyword,
+            "null" => TokenKind::NullKeyword,
             _ => TokenKind::Identifier(identifier),
         }
         .at(self.start_source)

Diff for: src/lower/expr/mod.rs

@@ -133,6 +133,9 @@ pub fn lower_expr(
                 "String literals are not fully implemented yet, still need ability to lower"
             )
         }
+        ExprKind::Null => Ok(ir::Value::Literal(Literal::Zeroed(ir::Type::Ptr(
+            Box::new(ir::Type::Void),
+        )))),
         ExprKind::Call(call) => lower_expr_call(builder, ir_module, expr, function, asg, call),
         ExprKind::Variable(variable) => {
             let pointer_to_variable = lower_variable_to_value(variable.key);

Diff for: src/parser/parse_expr/primary/mod.rs

@@ -35,6 +35,10 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 self.input.advance().kind.unwrap_false_keyword();
                 Ok(Expr::new(ExprKind::Boolean(false), source))
             }
+            TokenKind::NullKeyword => {
+                self.input.advance().kind.unwrap_null_keyword();
+                Ok(Expr::new(ExprKind::Null, source))
+            }
             TokenKind::Integer(..) => Ok(Expr::new(
                 ExprKind::Integer(Integer::Generic(self.input.advance().kind.unwrap_integer())),
                 source,

Diff for: src/resolve/expr/mod.rs

@@ -230,6 +230,10 @@ pub fn resolve_expr(
             ))
             */
         }
+        ast::ExprKind::Null => Ok(TypedExpr::new(
+            asg::TypeKind::Ptr(Box::new(asg::TypeKind::Void.at(source))).at(source),
+            asg::Expr::new(asg::ExprKind::Null, source),
+        )),
         ast::ExprKind::Call(call) => resolve_call_expr(ctx, call, source),
         ast::ExprKind::DeclareAssign(declare_assign) => {
             resolve_declare_assign_expr(ctx, declare_assign, source)

Diff for: src/token.rs

@@ -84,9 +84,9 @@ pub enum TokenKind {
     PubKeyword,
     TraitKeyword,
     ImplKeyword,
-    IsKeyword,
     ForKeyword,
-    GivenKeyword,
+    IsKeyword,
+    NullKeyword,
     Member,
     Add,
     Subtract,
@@ -182,7 +182,7 @@ impl Display for TokenKind {
             TokenKind::ImplKeyword => f.write_str("'impl' keyword"),
             TokenKind::ForKeyword => f.write_str("'for' keyword"),
             TokenKind::IsKeyword => f.write_str("'is' keyword"),
-            TokenKind::GivenKeyword => f.write_str("'given' keyword"),
+            TokenKind::NullKeyword => f.write_str("'null' keyword"),
             TokenKind::Member => f.write_str("'.'"),
             TokenKind::Add => f.write_str("'+'"),
             TokenKind::Subtract => f.write_str("'-'"),
@@ -316,7 +316,7 @@ impl TokenKind {
             | TokenKind::ImplKeyword
             | TokenKind::ForKeyword
             | TokenKind::IsKeyword
-            | TokenKind::GivenKeyword
+            | TokenKind::NullKeyword
             | TokenKind::OpenAngle
             | TokenKind::Comma
             | TokenKind::Colon

Diff for: tests/success/null/main.adept

@@ -0,0 +1,12 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr-char, ...) int
+
+func main {
+    message ptr<char> = null
+    printf(c"message\t= %010p\n", message)
+    printf(c"null\t= %010p\n", null)
+}
+