clean syntax to not allowing variable definition else where

7 files changed, 179 insertions, 82 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 96f439d..b03754d 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -11,6 +11,7 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
 
     "AST_TREE_TOKEN_KEYWORD_PRINT_U64",
 
+    "AST_TREE_TOKEN_TYPE_TYPE",
     "AST_TREE_TOKEN_TYPE_FUNCTION",
     "AST_TREE_TOKEN_TYPE_VOID",
     "AST_TREE_TOKEN_TYPE_U64",
@@ -19,8 +20,6 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
     "AST_TREE_TOKEN_VARIABLE",
     "AST_TREE_TOKEN_VALUE_U64",
 
-    "AST_TREE_TOKEN_VARIABLE_DEFINE",
-
     "AST_TREE_TOKEN_NONE",
 };
 
@@ -66,6 +65,7 @@ void astTreePrint(const AstTree *tree, int indent) {
     printf("]");
   }
     goto RETURN_SUCCESS;
+  case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
     goto RETURN_SUCCESS;
@@ -118,7 +118,6 @@ void astTreePrint(const AstTree *tree, int indent) {
     printf("]");
   }
     goto RETURN_SUCCESS;
-  case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *metadata = tree->metadata;
     printf(",variable.name=%.*s",
@@ -167,6 +166,7 @@ void astTreeDestroy(AstTree tree) {
     free(metadata);
   }
     return;
+  case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
   case AST_TREE_TOKEN_VALUE_U64:
@@ -196,7 +196,6 @@ void astTreeDestroy(AstTree tree) {
     free(metadata);
   }
     return;
-  case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_VARIABLE: {
     // AstTreeIdentifier *metadata = tree.metadata; // not needed
   }
@@ -242,6 +241,27 @@ AstTree *newAstTree(AstTreeToken token, void *metadata) {
   return result;
 }
 
+AstTree *copyAstTree(AstTree *tree) {
+  switch (tree->token) {
+  case AST_TREE_TOKEN_TYPE_TYPE:
+  case AST_TREE_TOKEN_TYPE_VOID:
+  case AST_TREE_TOKEN_TYPE_U64:
+    return newAstTree(tree->token, NULL);
+  case AST_TREE_TOKEN_VALUE_U64:
+    return newAstTree(AST_TREE_TOKEN_VALUE_U64,
+                      (void *)(AstTreeU64)tree->metadata);
+  case AST_TREE_TOKEN_VARIABLE:
+    return newAstTree(AST_TREE_TOKEN_VARIABLE, tree->metadata);
+  case AST_TREE_TOKEN_FUNCTION:
+  case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
+  case AST_TREE_TOKEN_TYPE_FUNCTION:
+  case AST_TREE_TOKEN_FUNCTION_CALL:
+  case AST_TREE_TOKEN_NONE:
+  }
+  printLog("Bad token '%d'", tree->token);
+  exit(1);
+}
+
 AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
   if (parsedRoot->token != PARSER_TOKEN_ROOT) {
     return NULL;
@@ -278,20 +298,22 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
     }
   }
 
+  AstTreeVariables *variables = &root->variables;
+  constexpr size_t variables_size = 1;
+
   for (size_t i = 0; i < nodes->size; ++i) {
     ParserNode *node =
         (ParserNodeSingleChildMetadata *)nodes->data[i]->metadata;
     ParserNodeVariableMetadata *node_metadata = node->metadata;
 
-    AstTree *type;
-    if (node_metadata->type != NULL) {
-      AstTreeVariables *variables = &root->variables;
-      type = astTreeParse(node_metadata->type, &variables, 1);
-      if (type == NULL) {
-        goto RETURN_ERROR;
-      }
-    } else {
-      type = NULL; // TODO: change this to find type
+    if (node->token != PARSER_TOKEN_CONSTANT) {
+      printLog("Only variables are allowed here");
+      goto RETURN_ERROR;
+    }
+
+    if (node_metadata->value == NULL) {
+      printLog("Variables must be initialized");
+      goto RETURN_ERROR;
     }
 
     switch (node_metadata->value->token) {
@@ -300,6 +322,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
       goto AFTER_SWITCH;
     case PARSER_TOKEN_ROOT:
     case PARSER_TOKEN_IDENTIFIER:
+    case PARSER_TOKEN_TYPE_TYPE:
     case PARSER_TOKEN_TYPE_FUNCTION:
     case PARSER_TOKEN_TYPE_VOID:
     case PARSER_TOKEN_TYPE_U64:
@@ -318,16 +341,27 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
     goto RETURN_ERROR;
 
   AFTER_SWITCH:
-    AstTreeVariables *variables = &root->variables;
-    AstTree *value = astTreeParse(node_metadata->value, &variables, 1);
+
+    AstTree *value =
+        astTreeParse(node_metadata->value, &variables, variables_size);
     if (value == NULL) {
       goto RETURN_ERROR;
     }
 
-    // TODO: then delete type != NULL
-    if (type != NULL && !hasTypeOf(value, type)) {
-      printLog("Type mismatch");
-      goto RETURN_ERROR;
+    AstTree *type;
+    if (node_metadata->type != NULL) {
+      AstTreeVariables *variables = &root->variables;
+      type = astTreeParse(node_metadata->type, &variables, 1);
+      if (type == NULL) {
+        goto RETURN_ERROR;
+      }
+
+      if (!hasTypeOf(value, type)) {
+        printLog("Type mismatch");
+        goto RETURN_ERROR;
+      }
+    } else {
+      type = makeTypeOf(value);
     }
 
     root->variables.data[i]->type = type;
@@ -391,6 +425,8 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables,
   switch (parserNode->token) {
   case PARSER_TOKEN_FUNCTION_DEFINITION:
     return astTreeParseFunction(parserNode, variables, variables_size);
+  case PARSER_TOKEN_TYPE_TYPE:
+    return newAstTree(AST_TREE_TOKEN_TYPE_TYPE, NULL);
   case PARSER_TOKEN_TYPE_FUNCTION:
     return astTreeParseTypeFunction(parserNode, variables, variables_size);
   case PARSER_TOKEN_TYPE_VOID:
@@ -408,7 +444,6 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables,
   case PARSER_TOKEN_KEYWORD_PRINT_U64:
     return astTreeParsePrintU64(parserNode, variables, variables_size);
   case PARSER_TOKEN_CONSTANT:
-    return astTreeParseConstant(parserNode, variables, variables_size);
   case PARSER_TOKEN_SYMBOL_EOL:
   case PARSER_TOKEN_SYMBOL_PARENTHESIS:
   case PARSER_TOKEN_SYMBOL_CURLY_BRACKET:
@@ -486,24 +521,29 @@ AstTree *astTreeParseFunction(ParserNode *parserNode,
       goto RETURN_ERROR;
     }
     ParserNode *node = (ParserNodeSingleChildMetadata *)eol->metadata;
-    AstTree *tree = astTreeParse(node, variables, variables_size);
 
-    if (tree == NULL) {
-      goto RETURN_ERROR;
-    } else if (tree->token == AST_TREE_TOKEN_VARIABLE_DEFINE) {
-      astTreeDelete(tree);
-      continue;
-    }
+    if (node->token == PARSER_TOKEN_CONSTANT) {
+      if (!astTreeParseConstant(node, variables, variables_size)) {
+        goto RETURN_ERROR;
+      }
+    } else {
+      AstTree *tree;
+      tree = astTreeParse(node, variables, variables_size);
 
-    if (expressions_size == scope.expressions_size) {
-      expressions_size += expressions_size / 2 + 1;
-      scope.expressions = a404m_realloc(
-          scope.expressions, expressions_size * sizeof(*scope.expressions));
-    }
-    scope.expressions[scope.expressions_size] = *tree;
-    scope.expressions_size += 1;
+      if (tree == NULL) {
+        goto RETURN_ERROR;
+      }
 
-    free(tree);
+      if (expressions_size == scope.expressions_size) {
+        expressions_size += expressions_size / 2 + 1;
+        scope.expressions = a404m_realloc(
+            scope.expressions, expressions_size * sizeof(*scope.expressions));
+      }
+      scope.expressions[scope.expressions_size] = *tree;
+      scope.expressions_size += 1;
+
+      free(tree);
+    }
   }
 
   scope.expressions = a404m_realloc(
@@ -639,9 +679,8 @@ AstTree *astTreeParsePrintU64(ParserNode *parserNode,
                     (AstTreeSingleChild *)operand);
 }
 
-AstTree *astTreeParseConstant(ParserNode *parserNode,
-                              AstTreeVariables **variables,
-                              size_t variables_size) {
+bool astTreeParseConstant(ParserNode *parserNode, AstTreeVariables **variables,
+                          size_t variables_size) {
   ParserNodeVariableMetadata *node_metadata = parserNode->metadata;
 
   if (node_metadata->value == NULL || node_metadata->type == NULL ||
@@ -672,13 +711,29 @@ AstTree *astTreeParseConstant(ParserNode *parserNode,
     goto RETURN_ERROR;
   }
 
-  return newAstTree(AST_TREE_TOKEN_VARIABLE_DEFINE, variable);
+  return true;
 RETURN_ERROR:
-  return NULL;
+  return false;
 }
 
 bool hasTypeOf(AstTree *value, AstTree *type) {
   switch (type->token) {
+  case AST_TREE_TOKEN_TYPE_TYPE:
+    switch (value->token) {
+    case AST_TREE_TOKEN_TYPE_TYPE:
+    case AST_TREE_TOKEN_TYPE_FUNCTION:
+    case AST_TREE_TOKEN_TYPE_VOID:
+    case AST_TREE_TOKEN_TYPE_U64:
+      return true;
+    case AST_TREE_TOKEN_FUNCTION:
+    case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
+    case AST_TREE_TOKEN_FUNCTION_CALL:
+    case AST_TREE_TOKEN_VARIABLE:
+    case AST_TREE_TOKEN_VALUE_U64:
+    case AST_TREE_TOKEN_NONE:
+      return false;
+    }
+    goto ERROR;
   case AST_TREE_TOKEN_TYPE_FUNCTION:
     AstTreeTypeFunction *typeMetadata = type->metadata;
     switch (value->token) {
@@ -697,12 +752,12 @@ bool hasTypeOf(AstTree *value, AstTree *type) {
     }
     case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
     case AST_TREE_TOKEN_VALUE_U64:
+    case AST_TREE_TOKEN_TYPE_TYPE:
     case AST_TREE_TOKEN_TYPE_FUNCTION:
     case AST_TREE_TOKEN_TYPE_VOID:
     case AST_TREE_TOKEN_TYPE_U64:
     case AST_TREE_TOKEN_FUNCTION_CALL:
     case AST_TREE_TOKEN_VARIABLE:
-    case AST_TREE_TOKEN_VARIABLE_DEFINE:
       return false;
     case AST_TREE_TOKEN_NONE:
     }
@@ -715,7 +770,6 @@ bool hasTypeOf(AstTree *value, AstTree *type) {
   case AST_TREE_TOKEN_VARIABLE:
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_VALUE_U64:
-  case AST_TREE_TOKEN_VARIABLE_DEFINE:
     return false;
   case AST_TREE_TOKEN_NONE:
   }
@@ -724,13 +778,51 @@ ERROR:
   exit(1);
 }
 
+AstTree *makeTypeOf(AstTree *value) {
+  switch (value->token) {
+  case AST_TREE_TOKEN_TYPE_TYPE:
+  case AST_TREE_TOKEN_TYPE_FUNCTION:
+  case AST_TREE_TOKEN_TYPE_VOID:
+  case AST_TREE_TOKEN_TYPE_U64:
+    return newAstTree(AST_TREE_TOKEN_TYPE_TYPE, NULL);
+  case AST_TREE_TOKEN_FUNCTION_CALL: {
+    AstTreeFunctionCall *metadata = value->metadata;
+    AstTreeFunction *function = metadata->function->metadata;
+    return copyAstTree(function->returnType);
+  }
+  case AST_TREE_TOKEN_FUNCTION: {
+    AstTreeFunction *function = value->metadata;
+
+    AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata));
+    type_metadata->arguments_size = function->arguments.size;
+    type_metadata->arguments = a404m_malloc(function->arguments.size *
+                                            sizeof(*type_metadata->arguments));
+    type_metadata->returnType = copyAstTree(function->returnType);
+
+    for (size_t i = 0; i < function->arguments.size; ++i) {
+      type_metadata->arguments[i] =
+          copyAstTree(function->arguments.data[i]->type);
+    }
+
+    return newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata);
+  }
+  case AST_TREE_TOKEN_VALUE_U64:
+    return newAstTree(AST_TREE_TOKEN_TYPE_U64, NULL);
+  case AST_TREE_TOKEN_VARIABLE:
+  case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
+  case AST_TREE_TOKEN_NONE:
+  }
+  printLog("Bad token '%d'", value->token);
+  exit(1);
+}
+
 bool typeIsEqual(AstTree *type0, AstTree *type1) {
   switch (type0->token) {
   case AST_TREE_TOKEN_FUNCTION:
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_VALUE_U64:
-  case AST_TREE_TOKEN_VARIABLE_DEFINE:
     return false;
+  case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
     return type1->token == type0->token;
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 8dba559..7f3e3dc 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -9,6 +9,7 @@ typedef enum AstTreeToken {
 
   AST_TREE_TOKEN_KEYWORD_PRINT_U64,
 
+  AST_TREE_TOKEN_TYPE_TYPE,
   AST_TREE_TOKEN_TYPE_FUNCTION,
   AST_TREE_TOKEN_TYPE_VOID,
   AST_TREE_TOKEN_TYPE_U64,
@@ -17,8 +18,6 @@ typedef enum AstTreeToken {
   AST_TREE_TOKEN_VARIABLE,
   AST_TREE_TOKEN_VALUE_U64,
 
-  AST_TREE_TOKEN_VARIABLE_DEFINE,
-
   AST_TREE_TOKEN_NONE,
 } AstTreeToken;
 
@@ -83,6 +82,7 @@ void astTreeDelete(AstTree *tree);
 void astTreeRootDelete(AstTreeRoot *root);
 
 AstTree *newAstTree(AstTreeToken token, void *metadata);
+AstTree *copyAstTree(AstTree *tree);
 
 AstTreeRoot *makeAstTree(ParserNode *parsedRoot);
 
@@ -114,9 +114,10 @@ AstTree *astTreeParsePrintU64(ParserNode *parserNode,
                               AstTreeVariables **variables,
                               size_t variables_size);
 
-AstTree *astTreeParseConstant(ParserNode *parserNode,
+bool astTreeParseConstant(ParserNode *parserNode,
                               AstTreeVariables **variables,
                               size_t variables_size);
 
 bool hasTypeOf(AstTree *value, AstTree *type);
+AstTree *makeTypeOf(AstTree *value);
 bool typeIsEqual(AstTree *type0, AstTree *type1);
diff --git a/src/compiler/code-generator.c b/src/compiler/code-generator.c
index 61d0092..342c790 100644
--- a/src/compiler/code-generator.c
+++ b/src/compiler/code-generator.c
@@ -77,6 +77,7 @@ CodeGeneratorCodes *codeGenerator(AstTreeRoot *astTreeRoot) {
         return NULL;
       }
       continue;
+    case AST_TREE_TOKEN_TYPE_TYPE:
     case AST_TREE_TOKEN_TYPE_FUNCTION:
     case AST_TREE_TOKEN_TYPE_VOID:
     case AST_TREE_TOKEN_VALUE_U64:
@@ -84,7 +85,6 @@ CodeGeneratorCodes *codeGenerator(AstTreeRoot *astTreeRoot) {
     case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
     case AST_TREE_TOKEN_FUNCTION_CALL:
     case AST_TREE_TOKEN_TYPE_U64:
-    case AST_TREE_TOKEN_VARIABLE_DEFINE:
     case AST_TREE_TOKEN_NONE:
       break;
     }
@@ -148,10 +148,10 @@ bool codeGeneratorAstTreeFunction(char *label_begin, char *label_end,
     case AST_TREE_TOKEN_VALUE_U64:
     case AST_TREE_TOKEN_VARIABLE:
     case AST_TREE_TOKEN_FUNCTION:
+    case AST_TREE_TOKEN_TYPE_TYPE:
     case AST_TREE_TOKEN_TYPE_FUNCTION:
     case AST_TREE_TOKEN_TYPE_VOID:
     case AST_TREE_TOKEN_TYPE_U64:
-    case AST_TREE_TOKEN_VARIABLE_DEFINE:
     case AST_TREE_TOKEN_NONE:
     }
     printLog("Bad token %d", tree.token);
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index 2c0774e..464ec7e 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -11,6 +11,7 @@
 const char *LEXER_TOKEN_STRINGS[] = {
     "LEXER_TOKEN_IDENTIFIER",
 
+    "LEXER_TOKEN_KEYWORD_TYPE",
     "LEXER_TOKEN_KEYWORD_VOID",
     "LEXER_TOKEN_KEYWORD_U64",
     "LEXER_TOKEN_KEYWORD_PRINT_U64",
@@ -47,11 +48,13 @@ const size_t LEXER_SYMBOL_SIZE =
     sizeof(LEXER_SYMBOL_TOKENS) / sizeof(*LEXER_SYMBOL_TOKENS);
 
 const char *LEXER_KEYWORD_STRINGS[] = {
+    "type",
     "void",
     "u64",
     "print_u64",
 };
 const LexerToken LEXER_KEYWORD_TOKENS[] = {
+    LEXER_TOKEN_KEYWORD_TYPE,
     LEXER_TOKEN_KEYWORD_VOID,
     LEXER_TOKEN_KEYWORD_U64,
     LEXER_TOKEN_KEYWORD_PRINT_U64,
@@ -171,6 +174,7 @@ void lexerPushClear(LexerNodeArray *array, size_t *array_size, char *iter,
   }
     // goto PUSH;
   PUSH:
+  case LEXER_TOKEN_KEYWORD_TYPE:
   case LEXER_TOKEN_KEYWORD_VOID:
   case LEXER_TOKEN_KEYWORD_U64:
   case LEXER_TOKEN_KEYWORD_PRINT_U64:
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index da3aa0f..6efeac8 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -5,6 +5,7 @@
 typedef enum LexerToken {
   LEXER_TOKEN_IDENTIFIER,
 
+  LEXER_TOKEN_KEYWORD_TYPE,
   LEXER_TOKEN_KEYWORD_VOID,
   LEXER_TOKEN_KEYWORD_U64,
   LEXER_TOKEN_KEYWORD_PRINT_U64,
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index bac809f..50b8aae 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -15,8 +15,10 @@ const char *PARSER_TOKEN_STRINGS[] = {
 
     "PARSER_TOKEN_VALUE_U64",
 
+    "PARSER_TOKEN_TYPE_TYPE",
     "PARSER_TOKEN_TYPE_FUNCTION",
     "PARSER_TOKEN_TYPE_VOID",
+    "PARSER_TOKEN_TYPE_U64",
 
     "PARSER_TOKEN_KEYWORD_PRINT_U64",
 
@@ -34,52 +36,33 @@ const char *PARSER_TOKEN_STRINGS[] = {
     "PARSER_TOKEN_NONE",
 };
 
+#define ORDER_ARRAY(...)                                                       \
+  .size = sizeof((LexerToken[]){__VA_ARGS__}) / sizeof(LexerToken),            \
+  .data = {__VA_ARGS__}
+
 static constexpr ParserOrder PARSER_ORDER[] = {
     {
         .ltr = true,
-        .size = 1,
-        .data =
-            {
-                LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET,
-            },
+        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET, ),
     },
     {
         .ltr = true,
-        .size = 5,
-        .data =
-            {
-                LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
-                LEXER_TOKEN_IDENTIFIER,
-                LEXER_TOKEN_KEYWORD_VOID,
-                LEXER_TOKEN_KEYWORD_U64,
-                LEXER_TOKEN_NUMBER,
-            },
+        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
+                    LEXER_TOKEN_IDENTIFIER, LEXER_TOKEN_KEYWORD_TYPE,
+                    LEXER_TOKEN_KEYWORD_VOID, LEXER_TOKEN_KEYWORD_U64,
+                    LEXER_TOKEN_NUMBER, ),
     },
     {
         .ltr = false,
-        .size = 1,
-        .data =
-            {
-                LEXER_TOKEN_SYMBOL_FUNCTION_ARROW,
-            },
+        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_FUNCTION_ARROW, ),
     },
     {
         .ltr = true,
-        .size = 3,
-        .data =
-            {
-                LEXER_TOKEN_SYMBOL_COLON,
-                LEXER_TOKEN_KEYWORD_PRINT_U64,
-            },
+        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_COLON, LEXER_TOKEN_KEYWORD_PRINT_U64, ),
     },
     {
         .ltr = true,
-        .size = 2,
-        .data =
-            {
-                LEXER_TOKEN_SYMBOL_EOL,
-                LEXER_TOKEN_SYMBOL_COMMA,
-            },
+        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_EOL, LEXER_TOKEN_SYMBOL_COMMA, ),
     },
 };
 
@@ -113,6 +96,7 @@ void parserNodePrint(const ParserNode *node, int indent) {
   }
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_IDENTIFIER:
+  case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
     goto RETURN_SUCCESS;
@@ -242,6 +226,7 @@ void parserNodeDelete(ParserNode *node) {
   }
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_IDENTIFIER:
+  case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
   case PARSER_TOKEN_VALUE_U64:
@@ -393,6 +378,8 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end,
   switch (node->token) {
   case LEXER_TOKEN_IDENTIFIER:
     return parserIdentifier(node, parent);
+  case LEXER_TOKEN_KEYWORD_TYPE:
+    return parserType(node, parent);
   case LEXER_TOKEN_KEYWORD_VOID:
     return parserVoid(node, parent);
   case LEXER_TOKEN_KEYWORD_U64:
@@ -435,6 +422,12 @@ ParserNode *parserIdentifier(LexerNode *node, ParserNode *parent) {
                            node->str_end, NULL, parent);
 }
 
+ParserNode *parserType(LexerNode *node, ParserNode *parent) {
+  return node->parserNode =
+             newParserNode(PARSER_TOKEN_TYPE_TYPE, node->str_begin,
+                           node->str_end, NULL, parent);
+}
+
 ParserNode *parserVoid(LexerNode *node, ParserNode *parent) {
   return node->parserNode =
              newParserNode(PARSER_TOKEN_TYPE_VOID, node->str_begin,
@@ -751,7 +744,8 @@ ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end,
   if (node1 != NULL) {
     LexerNode *valueNode = node1 + 1;
     if (valueNode >= end || valueNode->parserNode == NULL) {
-      printLog("No value");
+      printLog("No value for '%.*s'", (int)(name->str_end - name->str_begin),
+               name->str_begin);
       return NULL;
     } else {
       value = getUntilCommonParent(valueNode->parserNode, parent);
@@ -803,6 +797,7 @@ bool isExpression(ParserNode *node) {
   case PARSER_TOKEN_KEYWORD_PRINT_U64:
     return true;
   case PARSER_TOKEN_ROOT:
+  case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_FUNCTION:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
@@ -819,9 +814,10 @@ bool isExpression(ParserNode *node) {
 
 bool isType(ParserNode *node) {
   switch (node->token) {
+  case PARSER_TOKEN_TYPE_TYPE:
+  case PARSER_TOKEN_TYPE_FUNCTION:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
-  case PARSER_TOKEN_TYPE_FUNCTION:
     return true;
   case PARSER_TOKEN_IDENTIFIER:
   case PARSER_TOKEN_CONSTANT:
@@ -847,13 +843,14 @@ bool isValue(ParserNode *node) {
   case PARSER_TOKEN_FUNCTION_CALL:
   case PARSER_TOKEN_VALUE_U64:
     return true;
+  case PARSER_TOKEN_TYPE_FUNCTION:
+  case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
   case PARSER_TOKEN_IDENTIFIER:
   case PARSER_TOKEN_CONSTANT:
   case PARSER_TOKEN_SYMBOL_PARENTHESIS:
   case PARSER_TOKEN_ROOT:
-  case PARSER_TOKEN_TYPE_FUNCTION:
   case PARSER_TOKEN_SYMBOL_EOL:
   case PARSER_TOKEN_SYMBOL_CURLY_BRACKET:
   case PARSER_TOKEN_SYMBOL_COMMA:
diff --git a/src/compiler/parser.h b/src/compiler/parser.h
index 55354fa..71aa9d8 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -11,6 +11,7 @@ typedef enum ParserToken {
 
   PARSER_TOKEN_VALUE_U64,
 
+  PARSER_TOKEN_TYPE_TYPE,
   PARSER_TOKEN_TYPE_FUNCTION,
   PARSER_TOKEN_TYPE_VOID,
   PARSER_TOKEN_TYPE_U64,
@@ -93,6 +94,7 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end,
 ParserNode *getUntilCommonParent(ParserNode *node, ParserNode *parent);
 
 ParserNode *parserIdentifier(LexerNode *node, ParserNode *parent);
+ParserNode *parserType(LexerNode *node, ParserNode *parent);
 ParserNode *parserVoid(LexerNode *node, ParserNode *parent);
 ParserNode *parserU64(LexerNode *node, ParserNode *parent);
 ParserNode *parserPrintU64(LexerNode *node, LexerNode *end, ParserNode *parent);