Add integration test

- Split ast.h into granular headers in v0/ast/
- Split parser.c into modular implementation files in v0/parser/
- Move and rename parser tests to v0/parser/test_*.c
- Update build system (include.mk) with modular sub-makefiles
- Maintain v0/ast.h and v0/parser.h as umbrella headers

.github/copilot-instructions.md

@@ -26,9 +26,8 @@ There will be no `test_buffer.h`. Instead, `test.c` will directly
 Every syntax error path identified in the parser MUST have a corresponding test.
 
 ## Language Syntax
-Since this is a compiler for a new language, do not assume anything
+Since this is a compiler for a new language, do not assume anything of its syntax.
-of its syntax.
+Always check the `specs` directory to see examples and documentation about the language.
-Always check the `specs` directory.
 
 If there is anything unclear, ask the user for clarification.
 It is certainly possible that there are contradictions in the

Makefile

@@ -1,6 +1,6 @@
 .PHONY: all test clean
 
-all: c2 test
+all: c2 test integration-test
 
 c2: v0/bin/c2
 	cp $< $@
@@ -12,4 +12,10 @@ generate_golden::
 clean::
 	rm -f c2
 
-include v0/include.mk
+include v0/include.mk
+
+integration-test: v0/bin/c2 v0/bin/test_integration
+	./v0/bin/test_integration
+
+v0/bin/test_integration: v0/test_integration.c
+	$(CC) $(CFLAGS) -o $@ $<

README.md

@@ -13,5 +13,21 @@ In order to run the tests, run `make test`.
 ## Versioning
 The current version is v0. Its source code lives in the `v0` directory.
 
+## Testing
+
+### Unit Tests
+Run unit tests with:
+```bash
+make test
+```
+
+### Integration Tests
+Integration tests compare the compiler output with expected C files.
+To add a new integration test, create a new directory under `v0/integration_tests/` with `input.c2` and `expected.c` files.
+Run integration tests with:
+```bash
+make integration-test
+```
+
 ## Languages Specifications
 See the specs directory for information on the actual language syntax.

actual.c

@@ -0,0 +1 @@
+Hello, world

specs/VARIABLES.md

@@ -0,0 +1,24 @@
+# Variables
+Variables can be defined in the global scope, in structs and classes, and in functions.
+
+## Global variables
+Global variables can be defined as such:
+
+```c2
+// Defines a global variable called my_var.
+i32 my_var;
+
+// Defines a const variable.
+const i32 my_var;
+
+// Defines a global variable whose type is determined automatically.
+// The value will be determined at runtime.
+var my_var = 123;
+
+// Defines a const variable whose type is determined automatically.
+const my_var = 123;
+
+// Defines a global variable whose initial value is computed at compile-time.
+// If it cannot be computed at compile-time, an error is thrown.
+static my_var = 123;
+```

v0/ast.h

@@ -4,83 +4,18 @@
 #ifndef AST_H
 #define AST_H
 
-#include "bool.h"
+#include "ast/expression.h"
-#include "token.h"
+#include "ast/declaration.h"
-
+#include "ast/module.h"
-#include <stddef.h>
-
-typedef struct {
-    /** @brief The name of the module being imported. */
-    char* module_name;
-
-    /** @brief Whether the import is public or not. */
-    bool is_public;
-} ImportDeclaration;
-
-typedef enum {
-    TYPE_EXPRESSION_BUILTIN,
-    TYPE_EXPRESSION_ARRAY
-} TypeExpressionTag;
 
 /**
- * An expression that evaluates to a type.
+ * Frees a module and all its children.
  */
-typedef struct TypeExpression TypeExpression;
+void ast_free_module(ModuleTree* module);
-struct TypeExpression{
-    /** @brief defines which entry in the union is valid */
-    TypeExpressionTag tag;
-    union {
-        /** @brief Evaluates to an array of the given type. */
-        struct {
-            /** @brief A pointer to the type of the elements stored in the array. */
-            TypeExpression* array;
-        } array;
-        /** @brief Evaluates to a builtin integer type.*/
-        struct {
-            /**
-             * @brief The number of bits in the integer.
-             * Typical values are 8, 16, 32, and 64.
-             */
-            int bitSize;
-            /** @brief `true` if the type is signed, `false` if it's unsigned. */
-            bool isSigned;
-        } builtin;
-    };
-};
 
 /**
- * A declaration that aliases one type to another.
+ * Frees a type expression.
  */
-typedef struct {
+void ast_free_type(TypeTree* type);
-    /** @brief The name of the alias. */
-    char* name;
-
-    /** @brief The value of the alias. */
-    TypeExpression value;
-
-    /** @brief Whether the import is public or not. */
-    bool is_public;
-} AliasDeclaration;
-
-/**
- * The top-level model.
- * Every file matches an entire Module.
- */
-typedef struct {
-    /** @brief The name of the module. */
-    char* name;
-
-    /** @brief The list of imports in the module. */
-    ImportDeclaration* imports;
-
-    /** @brief The number of imports in the module. */
-    size_t import_count;
-
-    /** @brief The list of aliases in the module. */
-    AliasDeclaration* aliases;
-
-    /** @brief The number of aliases in the module. */
-    size_t alias_count;
-} Module;
 
 #endif

v0/ast/declaration.h

@@ -0,0 +1,49 @@
+#ifndef AST_DECLARATION_H
+#define AST_DECLARATION_H
+
+#include "expression.h"
+#include "../bool.h"
+
+typedef struct {
+    /** @brief The name of the module being imported. */
+    char* module_name;
+
+    /** @brief Whether the import is public or not. */
+    bool is_public;
+} ImportTree;
+
+/**
+ * A declaration that aliases one type to another.
+ */
+typedef struct {
+    /** @brief The name of the alias. */
+    const char* name;
+
+    /** @brief The value of the alias. */
+    TypeTree value;
+} AliasTree;
+
+/**
+ * A declaration of a variable, which may be a constant or not, and may be static or not.
+ */
+typedef struct {
+    /** @brief The name of the variable. */
+    char* name;
+
+    /** @brief The type of the variable. */
+    TypeTree type;
+
+    /** @brief The optional initializer expression. */
+    ExpressionTree* initializer;
+
+    /** @brief Whether the variable is public or not. */
+    bool is_public;
+
+    /** @brief Whether the variable is static or not. */
+    bool is_static;
+
+    /** @brief Whether the variable is a constant or not. */
+    bool is_const;
+} VariableTree;
+
+#endif

v0/ast/expression.c

@@ -0,0 +1,9 @@
+#include "expression.h"
+#include <stdlib.h>
+
+void ast_free_type(TypeTree* expr) {
+    if (expr->tag == TYPE_TREE_ARRAY) {
+        ast_free_type(expr->array.array);
+        free(expr->array.array);
+    }
+}

v0/ast/expression.h

@@ -0,0 +1,52 @@
+#ifndef AST_EXPRESSION_H
+#define AST_EXPRESSION_H
+
+#include "../bool.h"
+
+typedef enum {
+    EXPRESSION_TREE_INTEGER,
+    EXPRESSION_TREE_STRING,
+    EXPRESSION_TREE_BOOLEAN
+} ExpressionTreeTag;
+
+typedef struct {
+    ExpressionTreeTag tag;
+    union {
+        int integer;
+        const char* string;
+        bool boolean;
+    };
+} ExpressionTree;
+
+typedef enum {
+    TYPE_TREE_BUILTIN,
+    TYPE_TREE_ARRAY
+} TypeTreeTag;
+
+/**
+ * An expression that evaluates to a type.
+ */
+typedef struct TypeTree TypeTree;
+struct TypeTree {
+    /** @brief defines which entry in the union is valid */
+    TypeTreeTag tag;
+    union {
+        /** @brief Evaluates to an array of the given type. */
+        struct {
+            /** @brief A pointer to the type of the elements stored in the array. */
+            TypeTree* array;
+        } array;
+        /** @brief Evaluates to a builtin integer type.*/
+        struct {
+            /**
+             * @brief The number of bits in the integer.
+             * Typical values are 8, 16, 32, and 64.
+             */
+            int bitSize;
+            /** @brief `true` if the type is signed, `false` if it's unsigned. */
+            bool isSigned;
+        } builtin;
+    };
+};
+
+#endif

v0/ast/include.mk

@@ -0,0 +1,3 @@
+# There are currently no .c files in the ast directory.
+# This file is provided for future consistency.
+AST_SRC := v0/ast/module.c v0/ast/expression.c

v0/ast/module.c

@@ -0,0 +1,43 @@
+#include "module.h"
+#include "expression.h"
+#include <stdlib.h>
+
+void ast_free_type(TypeTree* type);
+
+void ast_free_module(ModuleTree* module) {
+    if (module == NULL) {
+        return;
+    }
+
+    if (module->imports != NULL) {
+        for(size_t i = 0; i < module->import_count; i++) {
+            free(module->imports[i].module_name);
+        }
+        free(module->imports);
+    }
+    
+    if (module->aliases != NULL) {
+        for(size_t i = 0; i < module->alias_count; i++) {
+            free((void*)module->aliases[i].name);
+            ast_free_type(&module->aliases[i].value);
+        }
+        free(module->aliases);
+    }
+
+    if (module->variables != NULL) {
+        for(size_t i = 0; i < module->variable_count; i++) {
+            free(module->variables[i].name);
+            ast_free_type(&module->variables[i].type);
+            if (module->variables[i].initializer) {
+                if (module->variables[i].initializer->tag == EXPRESSION_TREE_STRING) {
+                    free((void*)module->variables[i].initializer->string);
+                }
+                free(module->variables[i].initializer);
+            }
+        }
+        free(module->variables);
+    }
+
+    free(module->name);
+    free(module);
+}

v0/ast/module.h

@@ -0,0 +1,34 @@
+#ifndef AST_MODULE_H
+#define AST_MODULE_H
+
+#include "declaration.h"
+#include <stddef.h>
+
+/**
+ * The top-level model.
+ * Every file matches an entire Module.
+ */
+typedef struct {
+    /** @brief The name of the module. */
+    char* name;
+
+    /** @brief The list of imports in the module. */
+    ImportTree* imports;
+
+    /** @brief The number of imports in the module. */
+    size_t import_count;
+
+    /** @brief The list of aliases in the module. */
+    AliasTree* aliases;
+
+    /** @brief The number of aliases in the module. */
+    size_t alias_count;
+
+    /** @brief The list of variables in the module. */
+    VariableTree* variables;
+
+    /** @brief The number of variables in the module. */
+    size_t variable_count;
+} ModuleTree;
+
+#endif

v0/include.mk

@@ -1,4 +1,7 @@
-V0_SRC := v0/main.c v0/util.c v0/token.c v0/parser.c v0/log.c v0/str.c
+include v0/ast/include.mk
+include v0/parser/include.mk
+
+V0_SRC := v0/main.c v0/util.c v0/token.c $(AST_SRC) $(PARSER_SRC) v0/log.c v0/str.c
 
 # V0_TEST must only include `v0/test.c` itself, as all other test C–source files are
 # included directly into `v0/test.c` using `#include "test_xyz.c"`.

v0/integration_tests/simple/expected.c

@@ -0,0 +1,4 @@
+#include <stdint.h>
+
+// u32 simple:x
+static uint32_t v_6simple_1x = 123;

v0/integration_tests/simple/input.c2

@@ -0,0 +1,2 @@
+module simple;
+u32 x = 123;

v0/parser.c

@@ -1,338 +0,0 @@
-#include "parser.h"
-#include "log.h"
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-typedef struct {
-    TokenStream* ts;
-    Token token;
-} Parser;
-
-/**
- * Reads a new token into p->token.
- */
-static void parser_next_token(Parser* p) {
-    p->token = tokenstream_next(p->ts);
-}
-
-/**
- * Reads a new token if the current token is equal to the expected token.
- * 
- * If they are equal, it continues to the next token.
- * 
- * @param p
- * @param token The expected token.
- * @returns `true` if the current token matches the expected, `false` if it does not.
- */
-static bool parser_accept(Parser* p, TokenType token) {
-    if (p->token.token == token) {
-        parser_next_token(p);
-        return true;
-    }
-    return false;
-}
-
-/**
- * Consumes the expected token if present, otherwise logs an error.
- * 
- * @param p The parser state.
- * @param token The token type to expect.
- * @param msg The error message if the token is not found.
- * @return true if the token was consumed, false otherwise.
- */
-static bool parser_expect(Parser* p, TokenType token, const char* msg) {
-    if (parser_accept(p, token)) {
-        return true;
-    }
-    log_on_line(&p->token.location, msg);
-    return false;
-}
-
-/**
- * Checks if the current token matches the expected token type without consuming it.
- * 
- * @param p The parser state.
- * @param token The token type to check.
- * @return true if the current token matches, false otherwise.
- */
-static bool parser_peek(Parser* p, TokenType token) {
-    if (p->token.token == token) {
-        return true;
-    }
-    return false;
-}
-
-/**
- * Checks if the current token matches the expected token type without consuming it.
- * 
- * @param p The parser state.
- * @param token The token type to check.
- * @return true if the current token matches, false otherwise.
- */
-static bool parser_require(Parser* p, TokenType token, const char* msg) {
-    if (parser_peek(p, token)) {
-        return true;
-    }
-    log_on_line(&p->token.location, msg);
-    return false;
-}
-
-/**
- * Returns the text of the current token and advances the parser to the next token.
- * 
- * @param p The parser state.
- * @return A newly allocated string containing the current token's text.
- */
-static char* parser_to_text(Parser* p) {
-    char* str = string_copy(p->token.text);
-    parser_next_token(p);
-    return str;
-}
-
-/**
- * Parses the "module" keyword
- */
-static bool parse_module_declaration(Parser* p, Module* module) {
-    if (!parser_expect(p, TOKEN_MODULE, "expected keyword 'module'")) {
-        return false;
-    }
-
-    if (!parser_require(p, TOKEN_IDENTIFIER, "expected module identifier")) {
-        return false;
-    }
-    module->name = parser_to_text(p);
-
-    return parser_expect(p, TOKEN_SEMICOLON, "expected ';' after module name");
-}
-
-/**
- * Parses an import declaration.
- * 
- * @param p The parser state.
- * @param module The module to add the import to.
- * @param is_public Whether the import is public.
- * @return true if successful, false otherwise.
- */
-static bool parse_import_declaration(Parser* p, Module* module, bool is_public) {
-    module->import_count++;
-    module->imports = realloc(module->imports, sizeof(ImportDeclaration) * module->import_count);
-
-    ImportDeclaration* import = &module->imports[module->import_count - 1];
-    memset(import, 0, sizeof(ImportDeclaration));
-    import->is_public = is_public;
-
-    if (!parser_require(p, TOKEN_IDENTIFIER, "expected module identifier")) {
-        return false;
-    }
-
-    import->module_name = parser_to_text(p);
-
-    if (!parser_expect(p, TOKEN_SEMICOLON, "expected ';' after import")) {
-        return false;
-    }
-
-    return true;
-}
-
-/**
- * Parses a primitive type expression.
- * 
- * @param p The parser state.
- * @param expr The type expression to populate.
- * @return true if successful, false otherwise.
- */
-static bool parse_primitive_type_expression(Parser* p, TypeExpression* expr) {
-    if (parser_accept(p, TOKEN_U8)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 8;
-        expr->builtin.isSigned = false;
-        return true;
-    } else if (parser_accept(p, TOKEN_U16)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 16;
-        expr->builtin.isSigned = false;
-        return true;
-    } else if (parser_accept(p, TOKEN_U32)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 32;
-        expr->builtin.isSigned = false;
-        return true;
-    } else if (parser_accept(p, TOKEN_U64)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 64;
-        expr->builtin.isSigned = false;
-        return true;
-    } else if (parser_accept(p, TOKEN_I8)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 8;
-        expr->builtin.isSigned = true;
-        return true;
-    } else if (parser_accept(p, TOKEN_I16)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 16;
-        expr->builtin.isSigned = true;
-        return true;
-    } else if (parser_accept(p, TOKEN_I32)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 32;
-        expr->builtin.isSigned = true;
-        return true;
-    } else if (parser_accept(p, TOKEN_I64)) {
-        expr->tag = TYPE_EXPRESSION_BUILTIN;
-        expr->builtin.bitSize = 64;
-        expr->builtin.isSigned = true;
-        return true;
-    } else {
-        log_on_line(&p->token.location, "expected type expression");
-        return false;
-    }
-}
-
-/**
- * Parses an array type expression.
- * 
- * @param p The parser state.
- * @param expr The type expression to populate.
- * @return true if successful, false otherwise.
- */
-static bool parse_array_type_expression(Parser* p, TypeExpression* expr) {
-    TypeExpression elementType;
-    if (!parse_primitive_type_expression(p, &elementType)) {
-        return false;
-    }
-
-    if (parser_accept(p, TOKEN_BRACKET_OPEN)) {
-        expr->tag = TYPE_EXPRESSION_ARRAY;
-        expr->array.array = malloc(sizeof(TypeExpression));
-        *expr->array.array = elementType;
-
-        if (!parser_expect(p, TOKEN_BRACKET_CLOSE, "expected ']' to end array type")) {
-            return false;
-        }
-    } else {
-         *expr = elementType;
-         return true;
-    }
-    return true;
-}
-
-/**
- * Parses a type expression.
- * 
- * @param p The parser state.
- * @param expr The type expression to populate.
- * @return true if successful, false otherwise.
- */
-static bool parse_type_expression(Parser* p, TypeExpression* expr) {
-    return parse_array_type_expression(p, expr);
-}
-
-/**
- * Parses an alias declaration.
- * 
- * @param p The parser state.
- * @param module The module to add the alias to.
- * @param is_public Whether the alias is public.
- * @return true if successful, false otherwise.
- */
-static bool parse_alias_declaration(Parser* p, Module* module, bool is_public) {
-    module->alias_count++;
-    module->aliases = realloc(module->aliases, sizeof(AliasDeclaration) * module->alias_count);
-
-    AliasDeclaration* alias = &module->aliases[module->alias_count - 1];
-    memset(alias, 0, sizeof(AliasDeclaration));
-    alias->is_public = is_public;
-
-    if (!parser_require(p, TOKEN_IDENTIFIER, "expected alias identifier")) {
-        return false;
-    }
-    alias->name = parser_to_text(p);
-
-    if (!parser_expect(p, TOKEN_ASSIGN, "expected '=' after alias name")) {
-        return false;
-    }
-
-    if (!parse_type_expression(p, &alias->value)) {
-        return false;
-    }
-
-    if (!parser_expect(p, TOKEN_SEMICOLON, "expected ';' after alias declaration")) {
-        return false;
-    }
-
-    return true;
-}
-
-Module* parser_parse(TokenStream* ts) {
-    Parser* p = malloc(sizeof(Parser));
-    p->ts = ts;
-    parser_next_token(p);
-
-    Module* module = malloc(sizeof(Module));
-    memset(module, 0, sizeof(Module));
-    if (!parse_module_declaration(p, module)) {
-        goto fail;
-    }
-
-    while (!parser_peek(p, TOKEN_EOF)) {
-        bool is_public = false;
-        bool terminal = false;
-        do {
-            if (parser_accept(p, TOKEN_IMPORT)) {
-                if (!parse_import_declaration(p, module, is_public)) {
-                    goto fail;
-                }
-                terminal = true;
-            } else if (parser_accept(p, TOKEN_ALIAS)) {
-                if (!parse_alias_declaration(p, module, is_public)) {
-                    goto fail;
-                }
-                terminal = true;
-            } else if (parser_accept(p, TOKEN_PUBLIC)) {
-                is_public = true;
-            } else {
-                log_on_line(&p->token.location, "unexpected token");
-                goto fail;
-            }
-        } while (!terminal);
-    }
-
-    free(p);
-    return module;
-fail:
-    free(p);
-    parser_free(module);
-    return NULL;
-}
-
-void free_type_expression(TypeExpression* expr) {
-    if (expr->tag == TYPE_EXPRESSION_ARRAY) {
-        free_type_expression(expr->array.array);
-        free(expr->array.array);
-    }
-}
-
-void parser_free(Module* module) {
-	if (module == NULL) {
-        return;
-    }
-
-    if (module->imports != NULL) {
-        for(size_t i = 0; i < module->import_count; i++) {
-            free(module->imports[i].module_name);
-        }
-        free(module->imports);
-    }
-    
-    if (module->aliases != NULL) {
-        for(size_t i = 0; i < module->alias_count; i++) {
-            free(module->aliases[i].name);
-            free_type_expression(&module->aliases[i].value);
-        }
-        free(module->aliases);
-    }
-
-    free(module->name);
-	free(module);
-}

v0/parser.h

@@ -10,13 +10,6 @@
  * @param ts The TokenStream to read.
  * @returns The parsed module.
  */
-Module* parser_parse(TokenStream* ts);
+ModuleTree* parser_parse(TokenStream* ts);
-
-/**
- * Frees the parsed AST.
- * 
- * @param module The AST return by parser_parse.
- */
-void parser_free(Module* module);
 
 #endif

v0/parser/core.c

@@ -0,0 +1,52 @@
+#include "internal.h"
+#include "../str.h"
+#include "../log.h"
+#include <stdlib.h>
+
+void parser_next_token(Parser* p) {
+    p->token = tokenstream_next(p->ts);
+}
+
+bool parser_accept(Parser* p, TokenType token) {
+    if (p->token.token == token) {
+        parser_next_token(p);
+        return true;
+    }
+    return false;
+}
+
+bool parser_expect(Parser* p, TokenType token, const char* msg) {
+    if (parser_accept(p, token)) {
+        return true;
+    }
+    log_on_line(&p->token.location, msg);
+    return false;
+}
+
+bool parser_peek(Parser* p, TokenType token) {
+    if (p->token.token == token) {
+        return true;
+    }
+    return false;
+}
+
+bool parser_require(Parser* p, TokenType token, const char* msg) {
+    if (parser_peek(p, token)) {
+        return true;
+    }
+    log_on_line(&p->token.location, msg);
+    return false;
+}
+
+char* parser_to_text(Parser* p) {
+    char* str = string_copy(p->token.text);
+    parser_next_token(p);
+    return str;
+}
+
+bool parser_accept_primitive(Parser* p) {
+    return parser_peek(p, TOKEN_I8) || parser_peek(p, TOKEN_I16) || 
+           parser_peek(p, TOKEN_I32) || parser_peek(p, TOKEN_I64) ||
+           parser_peek(p, TOKEN_U8) || parser_peek(p, TOKEN_U16) || 
+           parser_peek(p, TOKEN_U32) || parser_peek(p, TOKEN_U64);
+}

v0/parser/declaration.c

@@ -0,0 +1,87 @@
+#include "internal.h"
+#include <stdlib.h>
+#include <string.h>
+
+bool parse_import_declaration(Parser* p, ModuleTree* module, bool is_public) {
+    module->import_count++;
+    module->imports = realloc(module->imports, sizeof(ImportTree) * module->import_count);
+
+    ImportTree* import = &module->imports[module->import_count - 1];
+    memset(import, 0, sizeof(ImportTree));
+    import->is_public = is_public;
+
+    if (!parser_require(p, TOKEN_IDENTIFIER, "expected module identifier")) {
+        return false;
+    }
+
+    import->module_name = parser_to_text(p);
+
+    if (!parser_expect(p, TOKEN_SEMICOLON, "expected ';' after import")) {
+        return false;
+    }
+
+    return true;
+}
+
+bool parse_alias_declaration(Parser* p, ModuleTree* module, bool is_public) {
+    (void)is_public;
+    module->alias_count++;
+    module->aliases = realloc(module->aliases, sizeof(AliasTree) * module->alias_count);
+
+    AliasTree* alias = &module->aliases[module->alias_count - 1];
+    memset(alias, 0, sizeof(AliasTree));
+
+    if (!parser_require(p, TOKEN_IDENTIFIER, "expected alias identifier")) {
+        return false;
+    }
+    alias->name = parser_to_text(p);
+
+    if (!parser_expect(p, TOKEN_ASSIGN, "expected '=' after alias name")) {
+        return false;
+    }
+
+    if (!parse_type_expression(p, &alias->value)) {
+        return false;
+    }
+
+    if (!parser_expect(p, TOKEN_SEMICOLON, "expected ';' after alias declaration")) {
+        return false;
+    }
+
+    return true;
+}
+
+bool parse_variable_declaration(Parser* p, ModuleTree* module, bool is_public, bool is_static, bool is_const) {
+    module->variable_count++;
+    module->variables = realloc(module->variables, sizeof(VariableTree) * module->variable_count);
+
+    VariableTree* var = &module->variables[module->variable_count - 1];
+    memset(var, 0, sizeof(VariableTree));
+    var->is_public = is_public;
+    var->is_static = is_static;
+    var->is_const = is_const;
+
+    if (parser_accept_primitive(p)) {
+        if (!parse_type_expression(p, &var->type)) {
+            return false;
+        }
+    }
+
+    if (!parser_require(p, TOKEN_IDENTIFIER, "expected variable identifier")) {
+        return false;
+    }
+    var->name = parser_to_text(p);
+
+    if (parser_accept(p, TOKEN_ASSIGN)) {
+        var->initializer = malloc(sizeof(ExpressionTree));
+        if (!parse_expression(p, var->initializer)) {
+            return false;
+        }
+    }
+
+    if (!parser_expect(p, TOKEN_SEMICOLON, "expected ';' after variable declaration")) {
+        return false;
+    }
+
+    return true;
+}

v0/parser/expression.c

@@ -0,0 +1,98 @@
+#include "internal.h"
+#include "../log.h"
+#include <stdlib.h>
+
+bool parse_primitive_type_expression(Parser* p, TypeTree* expr) {
+    if (parser_accept(p, TOKEN_U8)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 8;
+        expr->builtin.isSigned = false;
+        return true;
+    } else if (parser_accept(p, TOKEN_U16)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 16;
+        expr->builtin.isSigned = false;
+        return true;
+    } else if (parser_accept(p, TOKEN_U32)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 32;
+        expr->builtin.isSigned = false;
+        return true;
+    } else if (parser_accept(p, TOKEN_U64)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 64;
+        expr->builtin.isSigned = false;
+        return true;
+    } else if (parser_accept(p, TOKEN_I8)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 8;
+        expr->builtin.isSigned = true;
+        return true;
+    } else if (parser_accept(p, TOKEN_I16)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 16;
+        expr->builtin.isSigned = true;
+        return true;
+    } else if (parser_accept(p, TOKEN_I32)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 32;
+        expr->builtin.isSigned = true;
+        return true;
+    } else if (parser_accept(p, TOKEN_I64)) {
+        expr->tag = TYPE_TREE_BUILTIN;
+        expr->builtin.bitSize = 64;
+        expr->builtin.isSigned = true;
+        return true;
+    } else {
+        log_on_line(&p->token.location, "expected type expression");
+        return false;
+    }
+}
+
+bool parse_array_type_expression(Parser* p, TypeTree* expr) {
+    TypeTree elementType;
+    if (!parse_primitive_type_expression(p, &elementType)) {
+        return false;
+    }
+
+    if (parser_accept(p, TOKEN_BRACKET_OPEN)) {
+        expr->tag = TYPE_TREE_ARRAY;
+        expr->array.array = malloc(sizeof(TypeTree));
+        *expr->array.array = elementType;
+
+        if (!parser_expect(p, TOKEN_BRACKET_CLOSE, "expected ']' to end array type")) {
+            return false;
+        }
+    } else {
+         *expr = elementType;
+         return true;
+    }
+    return true;
+}
+
+bool parse_type_expression(Parser* p, TypeTree* expr) {
+    return parse_array_type_expression(p, expr);
+}
+
+bool parse_expression(Parser* p, ExpressionTree* expr) {
+    if (parser_peek(p, TOKEN_INTEGER)) {
+        expr->tag = EXPRESSION_TREE_INTEGER;
+        expr->integer = atoi(p->token.text.data);
+        parser_next_token(p);
+        return true;
+    } else if (parser_peek(p, TOKEN_STRING)) {
+        expr->tag = EXPRESSION_TREE_STRING;
+        expr->string = parser_to_text(p);
+        return true;
+    } else if (parser_accept(p, TOKEN_TRUE)) {
+        expr->tag = EXPRESSION_TREE_BOOLEAN;
+        expr->boolean = true;
+        return true;
+    } else if (parser_accept(p, TOKEN_FALSE)) {
+        expr->tag = EXPRESSION_TREE_BOOLEAN;
+        expr->boolean = false;
+        return true;
+    }
+    log_on_line(&p->token.location, "expected expression");
+    return false;
+}

v0/parser/include.mk

@@ -0,0 +1 @@
+PARSER_SRC := v0/parser/core.c v0/parser/expression.c v0/parser/declaration.c v0/parser/module.c

v0/parser/internal.h

@@ -0,0 +1,36 @@
+#ifndef PARSER_INTERNAL_H
+#define PARSER_INTERNAL_H
+
+#include "../parser.h"
+#include "../token.h"
+#include "../ast.h"
+
+typedef struct {
+    TokenStream* ts;
+    Token token;
+} Parser;
+
+// Core functions
+void parser_next_token(Parser* p);
+bool parser_accept(Parser* p, TokenType token);
+bool parser_expect(Parser* p, TokenType token, const char* msg);
+bool parser_peek(Parser* p, TokenType token);
+bool parser_require(Parser* p, TokenType token, const char* msg);
+char* parser_to_text(Parser* p);
+bool parser_accept_primitive(Parser* p);
+
+// Base parsing (expressions, types)
+bool parse_primitive_type_expression(Parser* p, TypeTree* expr);
+bool parse_array_type_expression(Parser* p, TypeTree* expr);
+bool parse_type_expression(Parser* p, TypeTree* expr);
+bool parse_expression(Parser* p, ExpressionTree* expr);
+
+// Declaration parsing
+bool parse_import_declaration(Parser* p, ModuleTree* module, bool is_public);
+bool parse_alias_declaration(Parser* p, ModuleTree* module, bool is_public);
+bool parse_variable_declaration(Parser* p, ModuleTree* module, bool is_public, bool is_static, bool is_const);
+
+// Module parsing
+bool parse_module_declaration(Parser* p, ModuleTree* module);
+
+#endif

v0/parser/module.c

@@ -0,0 +1,87 @@
+#include "internal.h"
+#include "../log.h"
+#include <stdlib.h>
+#include <string.h>
+
+bool parse_module_declaration(Parser* p, ModuleTree* module) {
+    if (!parser_expect(p, TOKEN_MODULE, "expected keyword 'module'")) {
+        return false;
+    }
+
+    if (!parser_require(p, TOKEN_IDENTIFIER, "expected module identifier")) {
+        return false;
+    }
+    module->name = parser_to_text(p);
+
+    return parser_expect(p, TOKEN_SEMICOLON, "expected ';' after module name");
+}
+
+ModuleTree* parser_parse(TokenStream* ts) {
+    Parser* p = malloc(sizeof(Parser));
+    p->ts = ts;
+    parser_next_token(p);
+
+    ModuleTree* module = malloc(sizeof(ModuleTree));
+    memset(module, 0, sizeof(ModuleTree));
+    if (!parse_module_declaration(p, module)) {
+        goto fail;
+    }
+
+    while (!parser_peek(p, TOKEN_EOF)) {
+        bool is_public = false;
+        bool is_static = false;
+        bool is_const = false;
+        bool terminal = false;
+        
+        while (!terminal) {
+            if (parser_accept(p, TOKEN_IMPORT)) {
+                if (is_static) {
+                    log_on_line(&p->token.location, "import declarations cannot be static or const");
+                    goto fail;
+                }
+                if (is_const) {
+                    log_on_line(&p->token.location, "import declarations cannot be static or const");
+                    goto fail;
+                }
+                if (!parse_import_declaration(p, module, is_public)) {
+                    goto fail;
+                }
+                terminal = true;
+            } else if (parser_accept(p, TOKEN_ALIAS)) {
+                if (is_static) {
+                    log_on_line(&p->token.location, "alias declarations cannot be static or const");
+                    goto fail;
+                }
+                if (is_const) {
+                    log_on_line(&p->token.location, "alias declarations cannot be static or const");
+                    goto fail;
+                }
+                if (!parse_alias_declaration(p, module, is_public)) {
+                    goto fail;
+                }
+                terminal = true;
+            } else if (parser_accept(p, TOKEN_PUBLIC)) {
+                is_public = true;
+            } else if (parser_accept(p, TOKEN_STATIC)) {
+                is_static = true;
+            } else if (parser_accept(p, TOKEN_CONST)) {
+                is_const = true;
+            } else if (parser_accept(p, TOKEN_VAR) || parser_accept_primitive(p)) {
+                if (!parse_variable_declaration(p, module, is_public, is_static, is_const)) {
+                    goto fail;
+                }
+                terminal = true;
+            } else {
+                log_on_line(&p->token.location, "unexpected token");
+                goto fail;
+            }
+        }
+    }
+
+    free(p);
+    return module;
+fail:
+    free(p);
+    ast_free_module(module);
+    return NULL;
+}

v0/parser/test_core.c

@@ -0,0 +1,8 @@
+#include "../test.h"
+#include "../parser.h"
+
+// Currently core utilities are tested indirectly through other parser tests.
+// Placeholder for future explicit core utility tests.
+static void test_parser_core_placeholder(void) {
+    // No-op
+}

v0/parser/test_declaration.c

@@ -0,0 +1,89 @@
+#include "../test.h"
+#include "../parser.h"
+#include <string.h>
+#include <stdlib.h>
+
+static void test_parser_missing_semicolon_import(void) {
+	test_get_ast();
+	assert_log_file("expected error for missing semicolon");
+}
+
+static void test_parser_bad_import_name(void) {
+	test_get_ast();
+	assert_log_file("expected error for bad import name");
+}
+
+static void test_parser_imports(void) {
+	ModuleTree* m = test_get_ast();
+	
+	assert_not_null(m, "expected module to be parsed");
+    assert_str("my_module", m->name, "expected name 'my_module'");
+	
+	assert_not_null(m->imports, "expected imports to be parsed");
+	assert_int(1, (int)m->import_count, "expected one import");
+    assert_str("other_module", m->imports[0].module_name, "expected import name 'other_module'");
+	assert_false(m->imports[0].is_public, "expected import to not be public");
+}
+
+static void test_parser_public_imports(void) {
+	ModuleTree* m = test_get_ast();
+	
+	assert_not_null(m, "expected module to be parsed");
+    assert_str("my_module", m->name, "expected name 'my_module'");
+	
+	assert_not_null(m->imports, "expected imports to be parsed");
+	assert_int(1, (int)m->import_count, "expected one import");
+    assert_str("other_module", m->imports[0].module_name, "expected import name 'other_module'");
+	assert_true(m->imports[0].is_public, "expected import to be public");
+}
+
+static void test_parser_alias_simple(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(1, (int)m->alias_count, "expected correct number of aliases");
+	AliasTree alias = m->aliases[0];
+	assert_str("myalias", alias.name, "expected correct alias name");
+}
+
+static void test_parser_variable_simple(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(1, (int)m->variable_count, "expected correct number of variables");
+	VariableTree var = m->variables[0];
+	assert_str("my_var", var.name, "expected correct variable name");
+	assert_false(var.is_const, "expected not const");
+	assert_false(var.is_static, "expected not static");
+}
+
+static void test_parser_variable_const(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(1, (int)m->variable_count, "expected correct number of variables");
+	VariableTree var = m->variables[0];
+	assert_str("my_const", var.name, "expected correct variable name");
+	assert_true(var.is_const, "expected const");
+	assert_false(var.is_static, "expected not static");
+}
+
+static void test_parser_variable_static(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(1, (int)m->variable_count, "expected correct number of variables");
+	VariableTree var = m->variables[0];
+	assert_str("my_static", var.name, "expected correct variable name");
+	assert_false(var.is_const, "expected not const");
+	assert_true(var.is_static, "expected static");
+}
+
+static void test_parser_multiple_vars(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(2, (int)m->variable_count, "expected correct number of variables");
+	assert_str("var1", m->variables[0].name, "expected first variable name 'var1'");
+	assert_str("var2", m->variables[1].name, "expected second variable name 'var2'");
+}

v0/parser/test_expression.c

@@ -0,0 +1,52 @@
+#include "../test.h"
+#include "../parser.h"
+#include <string.h>
+#include <stdlib.h>
+
+static void test_parser_alias_simple_type(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(1, (int)m->alias_count, "expected correct number of aliases");
+	AliasTree alias = m->aliases[0];
+	assert_int(TYPE_TREE_BUILTIN, alias.value.tag, "expected correct alias tag");
+	assert_int(32, alias.value.builtin.bitSize, "expected bitSize 32");
+	assert_true(alias.value.builtin.isSigned, "expected signed");
+}
+
+static void test_parser_alias_array(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(1, (int)m->alias_count, "expected correct number of aliases");
+	AliasTree alias = m->aliases[0];
+	assert_int(TYPE_TREE_ARRAY, alias.value.tag, "expected correct alias tag");
+	TypeTree* valueType = alias.value.array.array;
+	assert_not_null(valueType, "expected pointer to array type");
+	assert_int(TYPE_TREE_BUILTIN, valueType->tag, "expected correct type tag");
+	assert_int(32, valueType->builtin.bitSize, "expected bitSize 32");
+	assert_true(valueType->builtin.isSigned, "expected signed");
+}
+
+static void test_parser_variable_init(void) {
+	ModuleTree* m = test_get_ast();
+    
+	assert_not_null(m, "expected module to be parsed");
+    assert_int(1, (int)m->variable_count, "expected 1 variable");
+    VariableTree* var = &m->variables[0];
+    assert_str("x", var->name, "expected variable name 'x'");
+    assert_not_null(var->initializer, "expected variable to have an initializer");
+    assert_int(EXPRESSION_TREE_INTEGER, var->initializer->tag, "expected integer initializer");
+    assert_int(123, var->initializer->integer, "expected value 123");
+}
+
+static void test_parser_variable_simple_type(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_int(1, (int)m->variable_count, "expected correct number of variables");
+	VariableTree var = m->variables[0];
+	assert_int(TYPE_TREE_BUILTIN, var.type.tag, "expected correct type tag");
+	assert_int(32, var.type.builtin.bitSize, "expected bitSize 32");
+	assert_true(var.type.builtin.isSigned, "expected signed");
+}

v0/parser/test_module.c

@@ -0,0 +1,21 @@
+#include "../test.h"
+#include "../parser.h"
+#include <string.h>
+#include <stdlib.h>
+
+static void test_parser_module_name(void) {
+	ModuleTree* m = test_get_ast();
+
+	assert_not_null(m, "expected module to be parsed");
+	assert_str("my_module", m->name, "expected name 'my_module'");
+}
+
+static void test_parser_bad_module_name(void) {
+	test_get_ast();
+	assert_log_file("expected error to be logged for bad module name");
+}
+
+static void test_parser_missing_semicolon_module(void) {
+	test_get_ast();
+	assert_log_file("expected error for missing semicolon");
+}

v0/test.c

@@ -14,7 +14,7 @@ static char* s_logOutput = NULL;
 static const char* s_currentTestName = NULL;
 static char* s_testSource = NULL;
 
-static Module* s_currentModule = NULL;
+static ModuleTree* s_currentModule = NULL;
 static TokenStream* s_currentTokenStream = NULL;
 
 void fail(const char* msg) {
@@ -90,7 +90,7 @@ TokenStream* test_get_tokenstream(void) {
     return s_currentTokenStream;
 }
 
-Module* test_get_ast(void) {
+ModuleTree* test_get_ast(void) {
     if (s_currentModule == NULL) {
         s_currentModule = parser_parse(test_get_tokenstream());
     }
@@ -189,7 +189,10 @@ typedef struct {
 } TestCase;
 
 #include "test_token.c"
-#include "test_parser.c"
+#include "parser/test_module.c"
+#include "parser/test_declaration.c"
+#include "parser/test_expression.c"
+#include "parser/test_core.c"
 #include "test_log.c"
 
 static int s_totalTests;
@@ -201,16 +204,23 @@ static TestCase s_tests[] = {
     TEST(test_log_error)
     TEST(test_log_on_line_variadic)
     TEST(test_log_on_line)
-    TEST(test_parser_alias_and_import_mix)
-    TEST(test_parser_alias_array)
-    TEST(test_parser_alias_simple)
-    TEST(test_parser_bad_import_name)
-    TEST(test_parser_bad_module_name)
-    TEST(test_parser_imports)
-    TEST(test_parser_missing_semicolon_import)
-    TEST(test_parser_missing_semicolon_module)
     TEST(test_parser_module_name)
+    TEST(test_parser_bad_module_name)
+    TEST(test_parser_missing_semicolon_module)
+    TEST(test_parser_missing_semicolon_import)
+    TEST(test_parser_bad_import_name)
+    TEST(test_parser_imports)
     TEST(test_parser_public_imports)
+    TEST(test_parser_alias_simple)
+    TEST(test_parser_alias_simple_type)
+    TEST(test_parser_alias_array)
+    TEST(test_parser_variable_simple)
+    TEST(test_parser_variable_simple_type)
+    TEST(test_parser_variable_const)
+    TEST(test_parser_variable_init)
+    TEST(test_parser_variable_static)
+    TEST(test_parser_multiple_vars)
+    TEST(test_parser_core_placeholder)
     TEST(test_tokenstream_comma)
     TEST(test_tokenstream_info)
     TEST(test_tokenstream_keywords_and_symbols)
@@ -267,7 +277,7 @@ int main(int argc, char** argv) {
 
         // Free AST and TokenStream after each test
         if (s_currentModule) {
-            parser_free(s_currentModule);
+            ast_free_module(s_currentModule);
             s_currentModule = NULL;
         }
         if (s_currentTokenStream) {

v0/test.h

@@ -89,6 +89,6 @@ TokenStream* test_get_tokenstream(void);
  * 
  * At the end of the test, the AST will be freed automatically by the test harness.
  */
-Module* test_get_ast(void);
+ModuleTree* test_get_ast(void);
 
 #endif

v0/test_integration.c

@@ -0,0 +1,63 @@
+#define _DEFAULT_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+
+int run_test(const char* dir_name) {
+    char cmd[2048];
+    char input_path[1024];
+    char expected_path[1024];
+    
+    snprintf(input_path, sizeof(input_path), "v0/integration_tests/%s/input.c2", dir_name);
+    snprintf(expected_path, sizeof(expected_path), "v0/integration_tests/%s/expected.c", dir_name);
+    
+    if (snprintf(cmd, sizeof(cmd), "./v0/bin/c2 %s > actual.c", input_path) >= sizeof(cmd)) {
+        printf("Command buffer too small for %s\n", dir_name);
+        return 1;
+    }
+    
+    if (system(cmd) != 0) {
+        printf("Failed to run compiler for %s\n", dir_name);
+        return 1;
+    }
+    
+    if (snprintf(cmd, sizeof(cmd), "diff -u %s actual.c", expected_path) >= sizeof(cmd)) {
+        printf("Command buffer too small for %s\n", dir_name);
+        return 1;
+    }
+    
+    if (system(cmd) != 0) {
+        printf("Test %s failed: Output mismatch\n", dir_name);
+        return 1;
+    }
+    
+    printf("Test %s passed\n", dir_name);
+    return 0;
+}
+
+int main() {
+    DIR* d = opendir("v0/integration_tests");
+    if (!d) {
+        perror("opendir");
+        return 1;
+    }
+    
+    struct dirent* dir;
+    int passed = 0;
+    int failed = 0;
+    
+    while ((dir = readdir(d)) != NULL) {
+        if (dir->d_type == DT_DIR && strcmp(dir->d_name, ".") != 0 && strcmp(dir->d_name, "..") != 0) {
+            if (run_test(dir->d_name) == 0) {
+                passed++;
+            } else {
+                failed++;
+            }
+        }
+    }
+    closedir(d);
+    
+    printf("\nTotal tests: %d, Passed: %d, Failed: %d\n", passed + failed, passed, failed);
+    return failed > 0 ? 1 : 0;
+}

v0/test_parser.c

@@ -1,95 +0,0 @@
-#include "test.h"
-#include "parser.h"
-#include <string.h>
-#include <stdlib.h>
-
-static void test_parser_module_name(void) {
-	Module* m = test_get_ast();
-
-	assert_not_null(m, "expected module to be parsed");
-	assert_str("my_module", m->name, "expected name 'my_module'");
-}
-
-static void test_parser_bad_module_name(void) {
-	test_get_ast();
-	assert_log_file("expected error to be logged for bad module name");
-}
-
-static void test_parser_missing_semicolon_module(void) {
-	test_get_ast();
-	assert_log_file("expected error for missing semicolon");
-}
-
-static void test_parser_missing_semicolon_import(void) {
-	test_get_ast();
-	assert_log_file("expected error for missing semicolon");
-}
-
-static void test_parser_bad_import_name(void) {
-	test_get_ast();
-	assert_log_file("expected error for bad import name");
-}
-
-static void test_parser_imports(void) {
-	Module* m = test_get_ast();
-	
-	assert_not_null(m, "expected module to be parsed");
-    assert_str("my_module", m->name, "expected name 'my_module'");
-	
-	assert_not_null(m->imports, "expected imports to be parsed");
-	assert_int(1, (int)m->import_count, "expected one import");
-    assert_str("other_module", m->imports[0].module_name, "expected import name 'other_module'");
-	assert_false(m->imports[0].is_public, "expected import to not be public");
-}
-
-static void test_parser_public_imports(void) {
-	Module* m = test_get_ast();
-	
-	assert_not_null(m, "expected module to be parsed");
-    assert_str("my_module", m->name, "expected name 'my_module'");
-	
-	assert_not_null(m->imports, "expected imports to be parsed");
-	assert_int(1, (int)m->import_count, "expected one import");
-    assert_str("other_module", m->imports[0].module_name, "expected import name 'other_module'");
-	assert_true(m->imports[0].is_public, "expected import to be public");
-}
-
-static void test_parser_alias_simple(void) {
-	Module* m = test_get_ast();
-
-	assert_not_null(m, "expected module to be parsed");
-	assert_int(1, (int)m->alias_count, "expected correct number of aliases");
-	AliasDeclaration alias = m->aliases[0];
-	assert_str("myalias", alias.name, "expected correct alias name");
-	assert_int(TYPE_EXPRESSION_BUILTIN, alias.value.tag, "expected correct alias tag");
-	assert_int(32, alias.value.builtin.bitSize, "expected bitSize 32");
-	assert_true(alias.value.builtin.isSigned, "expected signed");
-}
-
-static void test_parser_alias_array(void) {
-	Module* m = test_get_ast();
-
-	assert_not_null(m, "expected module to be parsed");
-	assert_int(1, (int)m->alias_count, "expected correct number of aliases");
-	AliasDeclaration alias = m->aliases[0];
-	assert_str("myalias", alias.name, "expected correct alias name");
-	assert_int(TYPE_EXPRESSION_ARRAY, alias.value.tag, "expected correct alias tag");
-	TypeExpression* valueType = alias.value.array.array;
-	assert_not_null(valueType, "expected pointer to array type");
-	assert_int(TYPE_EXPRESSION_BUILTIN, valueType->tag, "expected correct type tag");
-	assert_int(32, valueType->builtin.bitSize, "expected bitSize 32");
-	assert_true(valueType->builtin.isSigned, "expected signed");
-}
-
-static void test_parser_alias_and_import_mix(void) {
-	Module* m = test_get_ast();
-    
-	assert_not_null(m, "expected module to be parsed");
-    assert_int(2, (int)m->import_count, "expected 2 imports");
-    assert_int(2, (int)m->alias_count, "expected 2 aliases");
-    
-    assert_str("foo", m->imports[0].module_name, "expected import 1 name 'foo'");
-    assert_str("bar", m->imports[1].module_name, "expected import 2 name 'bar'");
-    assert_str("myalias", m->aliases[0].name, "expected alias 1 name 'myalias'");
-    assert_str("otheralias", m->aliases[1].name, "expected alias 2 name 'otheralias'");
-}

v0/tests/parser_alias_simple_type.c2

@@ -0,0 +1,3 @@
+module mymodule;
+
+alias myalias = i32;

v0/tests/parser_multiple_vars.c2

@@ -0,0 +1,4 @@
+module test_multiple_vars;
+
+i32 var1;
+i32 var2;

v0/tests/parser_variable_const.c2

@@ -0,0 +1,3 @@
+module test_const_var;
+
+const i32 my_const;

v0/tests/parser_variable_init.c2

@@ -0,0 +1,2 @@
+module mymodule;
+var x = 123;

v0/tests/parser_variable_simple.c2

@@ -0,0 +1,4 @@
+module my_module;
+
+// Defines a global variable called my_var.
+i32 my_var;

v0/tests/parser_variable_simple_type.c2

@@ -0,0 +1,4 @@
+module my_module;
+
+// Defines a global variable called my_var.
+i32 my_var;

v0/tests/parser_variable_static.c2

@@ -0,0 +1,3 @@
+module test_static_var;
+
+static i32 my_static;

v0/token.c

@@ -31,6 +31,10 @@ static const KeywordMap keywords[] = {
 	{"import", TOKEN_IMPORT},
     {"alias", TOKEN_ALIAS},
     {"public", TOKEN_PUBLIC},
+	{"var", TOKEN_VAR},
+	{"const", TOKEN_CONST},
+	{"static", TOKEN_STATIC},
+
 	{"void", TOKEN_VOID},
 	{"i8", TOKEN_I8},
 	{"i16", TOKEN_I16},
@@ -40,6 +44,8 @@ static const KeywordMap keywords[] = {
 	{"u16", TOKEN_U16},
 	{"u32", TOKEN_U32},
 	{"u64", TOKEN_U64},
+    {"true", TOKEN_TRUE},
+    {"false", TOKEN_FALSE},
 };
 
 /**
@@ -230,8 +236,27 @@ Token tokenstream_next(TokenStream* ts) {
 	case ',': return create_token(ts, TOKEN_COMMA, start_text, 1, start_line, start_column, line_start);
 	case ';': return create_token(ts, TOKEN_SEMICOLON, start_text, 1, start_line, start_column, line_start);
     case '=': return create_token(ts, TOKEN_ASSIGN, start_text, 1, start_line, start_column, line_start);
+    case '"': {
+        size_t len = 0;
+        const char* start = &ts->code[ts->pos];
+        while (peek_char(ts) != '"' && peek_char(ts) != '\0') {
+            read_char(ts);
+            len++;
+        }
+        if (peek_char(ts) == '"') read_char(ts);
+        return create_token(ts, TOKEN_STRING, start, len, start_line, start_column + 1, line_start);
+    }
 	}
 
+    if (isdigit(c)) {
+        size_t len = 1;
+        while (isdigit(peek_char(ts))) {
+            read_char(ts);
+            len++;
+        }
+        return create_token(ts, TOKEN_INTEGER, start_text, len, start_line, start_column, line_start);
+    }
+
 	/* Keywords and identifiers */
     if (is_identifier_start(c)) {
         /* Declarations first for C89 */

v0/token.h

@@ -16,6 +16,9 @@ typedef enum {
 	TOKEN_SEMICOLON,
     TOKEN_ALIAS,
     TOKEN_PUBLIC,
+    TOKEN_VAR,
+    TOKEN_CONST,
+    TOKEN_STATIC,
 
     /* Symbols */
     TOKEN_PARENT_OPEN,
@@ -35,6 +38,10 @@ typedef enum {
     TOKEN_U16,
     TOKEN_U32,
     TOKEN_U64,
+    TOKEN_STRING,
+    TOKEN_INTEGER,
+    TOKEN_TRUE,
+    TOKEN_FALSE,
 
     /* Variable */
     TOKEN_IDENTIFIER,