Started to add in resolution types

Author: TheDevConnor

LPBS/main.lx

@@ -18,9 +18,9 @@ pub const main -> fn () int {
 
   let path: *char = "/home/TheDevConnor/Luma/LPBS/build.lmb";
   let file: *char = io::read_file(path);
-  let lex: *Token = lexer::scan(file);
+  let lex: *lexer::Token = lexer::scan(file);
 
-  let parser: *Stmt = psr::parse(lex, path);
+  let parser: *ast::Stmt = psr::parse(lex, path);
   ast::print_stmt(parser);
 
   clean_up(file, lex);

LPBS/parser.lx

@@ -29,11 +29,11 @@ const BindingPower -> enum {
 };
 
 pub const Parser -> struct {
-  tks: *Token,
+  tks: *lexer::Token,
   path: *char,
   pos: int,
 
-  init_parser -> fn (tks: *Token, path: *char) void {
+  init_parser -> fn (tks: *lexer::Token, path: *char) void {
     self.path = path;
     self.tks = tks;
     self.pos = 0;
@@ -44,10 +44,10 @@ pub const Parser -> struct {
 // TODO: and fix the types for the module system for enums and structs with it.
 
 const at_end  -> fn (psr: *Parser) int { return cast<int>(psr.pos >= psr.tks.size); }
-const peek    -> fn (psr: *Parser) Token {  return psr.tks.list[psr.pos]; }
+const peek    -> fn (psr: *Parser) lexer::Token {  return psr.tks.list[psr.pos]; }
 const advance -> fn (psr: *Parser) void { psr.pos = psr.pos + 1; }
 
-const parse_expr -> fn (psr: *Parser, bp: int) *Expr;
+const parse_expr -> fn (psr: *Parser, bp: int) *ast::Expr;
 
 const get_infix_bp -> fn (token_type: int) int {
   switch (token_type) {
@@ -57,8 +57,8 @@ const get_infix_bp -> fn (token_type: int) int {
   }
 }
 
-const parse_literal -> fn (psr: *Parser) *Expr {
-  let tok: Token = peek(psr);
+const parse_literal -> fn (psr: *Parser) *ast::Expr {
+  let tok: lexer::Token = peek(psr);
 
   switch (tok.type) {
     0 -> { //number
@@ -83,15 +83,15 @@ const parse_literal -> fn (psr: *Parser) *Expr {
   }
 }
 
-const nud -> fn (psr: *Parser) *Expr {
-  let tok: Token = peek(psr);
+const nud -> fn (psr: *Parser) *ast::Expr {
+  let tok: lexer::Token = peek(psr);
 
   switch (tok.type) {
     0, 1, 2 -> { return parse_literal(psr); } //number, ident, string
     6 -> { //(
       advance(psr);
-      let expr: *Expr = parse_expr(psr, BindingPower::BP_NONE);
-      let next_tok: Token = peek(psr);
+      let expr: *ast::Expr = parse_expr(psr, BindingPower::BP_NONE);
+      let next_tok: lexer::Token = peek(psr);
       if (next_tok.type != 7) { //)
         output("Expected closing parenthesis\n");
         return cast<*Expr>(0);
@@ -102,37 +102,37 @@ const nud -> fn (psr: *Parser) *Expr {
     16, 17 -> { //+, -
       let op: *char = tok.value;
       advance(psr);
-      let right: *Expr = parse_expr(psr, BindingPower::BP_UNARY);
+      let right: *ast::Expr = parse_expr(psr, BindingPower::BP_UNARY);
       return ast::create_unary_node(op[0], right);
     }
     _ -> {
       output("Unexpected token in prefix position\n");
-      return cast<*Expr>(0);
+      return cast<*ast::Expr>(0);
     }
   }
 }
 
-const led -> fn (psr: *Parser, left: *Expr, token: Token) *Expr {
+const led -> fn (psr: *Parser, left: *ast::Expr, token: lexer::Token) *ast::Expr {
   switch (token.type) {
     12, 13, 16, 17, 18, 19 -> { //==, !=, +, -, *, / 
       let op: *char = psr.tks.list[psr.pos].value; 
       advance(psr);
-      let right: *Expr = parse_expr(psr, get_infix_bp(token.type));
+      let right: *ast::Expr = parse_expr(psr, get_infix_bp(token.type));
       return ast::create_binary_node(op[0], left, right);
     }
     _ -> {
       output("Unexpected token in infix position\n");
-      return cast<*Expr>(0);
+      return cast<*ast::Expr>(0);
     }
   }
 }
 
-const parse_expr -> fn (psr: *Parser, bp: int) *Expr {
-  let left: *Expr = nud(psr);
+const parse_expr -> fn (psr: *Parser, bp: int) *ast::Expr {
+  let left: *ast::Expr = nud(psr);
 
   // Inline the led logic here
   loop (at_end(psr) == 0 && bp < get_infix_bp(peek(psr).type)) {
-    let tok: Token = peek(psr);
+    let tok: lexer::Token = peek(psr);
     let next_bp: int = get_infix_bp(tok.type);
 
     left = led(psr, left, tok);
@@ -141,11 +141,11 @@ const parse_expr -> fn (psr: *Parser, bp: int) *Expr {
   return left;
 }
 
-pub const parse -> fn (tks: *Token, path: *char) *Stmt {
+pub const parse -> fn (tks: *lexer::Token, path: *char) *ast::Stmt {
   let psr: Parser;
   psr.init_parser(tks, path);
 
-  let node: *Expr = parse_expr(&psr, BindingPower::BP_NONE);
+  let node: *ast::Expr = parse_expr(&psr, BindingPower::BP_NONE);
 
   return ast::create_program_node(node); 
 }

src/ast/ast.h

@@ -63,12 +63,13 @@ typedef enum {
   AST_STMT_DEFAULT,
 
   // Type nodes
-  AST_TYPE_BASIC,    // Basic types (int, float, string, etc.)
-  AST_TYPE_POINTER,  // Pointer types
-  AST_TYPE_ARRAY,    // Array types
-  AST_TYPE_FUNCTION, // Function types
-  AST_TYPE_STRUCT,   // Struct types
-  AST_TYPE_ENUM,     // Enum types
+  AST_TYPE_RESOLUTION, // Namespace::Type resolution
+  AST_TYPE_BASIC,      // Basic types (int, float, string, etc.)
+  AST_TYPE_POINTER,    // Pointer types
+  AST_TYPE_ARRAY,      // Array types
+  AST_TYPE_FUNCTION,   // Function types
+  AST_TYPE_STRUCT,     // Struct types
+  AST_TYPE_ENUM,       // Enum types
 } NodeType;
 
 // Literal types
@@ -478,6 +479,11 @@ struct AstNode {
           AstNode *return_type; // Changed from Type* to AstNode*
         } function;
 
+        struct {
+          char **parts;      // Array of namespace/type parts
+          size_t part_count; // Number of parts
+        } resolution;
+
         // AST_TYPE_STRUCT - ADD THIS STRUCT
         struct {
           const char *name;          // Name of the struct type
@@ -654,3 +660,5 @@ AstNode *create_array_type(ArenaAllocator *arena, AstNode *element_type,
 AstNode *create_function_type(ArenaAllocator *arena, AstNode **param_types,
                               size_t param_count, AstNode *return_type,
                               size_t line, size_t column);
+AstNode *create_resolution_type(ArenaAllocator *arena, char **parts,
+                                size_t part_count, size_t line, size_t column);

src/ast/ast_definistions/type.c

@@ -27,4 +27,11 @@ AstNode *create_function_type(ArenaAllocator *arena, AstNode **param_types, size
   node->type_data.function.param_count = param_count;
   node->type_data.function.return_type = return_type;
   return node;
+}
+
+AstNode *create_resolution_type(ArenaAllocator *arena, char **parts, size_t part_count, size_t line, size_t column) {
+  AstNode *node = create_type_node(arena, AST_TYPE_RESOLUTION, line, column);
+  node->type_data.resolution.parts = parts;
+  node->type_data.resolution.part_count = part_count;
+  return node;
 }

src/helper/run.c

@@ -332,6 +332,8 @@ bool run_build(BuildConfig config, ArenaAllocator *allocator) {
   if (!combined_program)
     goto cleanup;
 
+  // print_ast(combined_program, "", false, false);
+
   // Stage 4: Typechecking
   print_progress_with_time(++step, total_stages, "Typechecking", &timer);
 

src/parser/expr.c

@@ -347,20 +347,43 @@ Expr *struct_expr(Parser *parser) {
 }
 
 // Named struct initialization: Point { x: 20, y: 50 }
-// This is called from led() when we see '{' after an identifier
+// OR namespace::Point { x: 20, y: 50 }
+// This is called from led() when we see '{' after an identifier or member expr
 Expr *named_struct_expr(Parser *parser, Expr *left, BindingPower bp) {
   (void)bp; // Unused parameter
 
-  // left should be an identifier expression containing the struct name
-  if (left->type != AST_EXPR_IDENTIFIER) {
+  char *struct_name = NULL;
+
+  // Handle both identifier and member expressions
+  if (left->type == AST_EXPR_IDENTIFIER) {
+    // Simple case: Point { ... }
+    struct_name = left->expr.identifier.name;
+  } else if (left->type == AST_EXPR_MEMBER) {
+    // Namespace resolution: namespace::Point { ... }
+    // Build the full qualified name from the member expression
+
+    // For now, we'll extract the name from the member expression
+    // This assumes the member expression represents something like
+    // "namespace::Point" You might need to adjust this based on how your AST
+    // represents member expressions
+
+    // Get the member name (the rightmost part, e.g., "Point" in
+    // "namespace::Point")
+    struct_name = left->expr.member.member;
+
+    // Note: If you need the full qualified name, you'll need to traverse
+    // the member expression tree and build the complete path
+    // For example: if left->expr.member.object is also a member expr,
+    // you'd need to recursively build the name
+  } else {
     parser_error(parser, "SyntaxError", parser->file_path,
-                 "Expected identifier before '{' for named struct",
+                 "Expected identifier or namespace resolution before '{' for "
+                 "named struct",
                  p_current(parser).line, p_current(parser).col,
                  p_current(parser).length);
     return NULL;
   }
 
-  char *struct_name = left->expr.identifier.name;
   int line = p_current(parser).line;
   int col = p_current(parser).col;
 
@@ -425,7 +448,8 @@ Expr *named_struct_expr(Parser *parser, Expr *left, BindingPower bp) {
 
   p_consume(parser, TOK_RBRACE, "Expected '}' to close struct expression");
 
-  // Named struct
+  // Store the full expression (identifier or member) for later use
+  // This allows the semantic analyzer to resolve the namespace properly
   return create_struct_expr(
       parser->arena, struct_name, (char **)field_names.data,
       (AstNode **)field_values.data, field_names.count, line, col);
@@ -483,20 +507,26 @@ Expr *free_expr(Parser *parser) {
 
 // cast<TYPE>(value);
 Expr *cast_expr(Parser *parser) {
-  p_advance(parser); // Advance past the cast
   int line = p_current(parser).line;
   int col = p_current(parser).col;
+  
+  p_advance(parser); // Advance past 'cast'
 
   p_consume(parser, TOK_LT,
-            "Expected a '<' before you declare the type you want to cast too.");
+            "Expected a '<' before you declare the type you want to cast to.");
+  
   Type *cast_type = parse_type(parser);
-  p_advance(parser);
+  // parse_type() has already advanced past the type
+  
   p_consume(parser, TOK_GT,
-            "Expected a '>' after defining the type you want to cast too, but "
+            "Expected a '>' after defining the type you want to cast to, but "
             "before defining what you are casting");
+  
   p_consume(parser, TOK_LPAREN,
             "Expected a '(' before defining what you are casting");
+  
   Expr *castee = parse_expr(parser, BP_NONE);
+  
   p_consume(parser, TOK_RPAREN,
             "Expected a ')' after defining what you are casting");
 
@@ -505,22 +535,27 @@ Expr *cast_expr(Parser *parser) {
 
 // input<TYPE>(msg);
 Expr *input_expr(Parser *parser) {
-  p_advance(parser); // Advance past the cast
   int line = p_current(parser).line;
   int col = p_current(parser).col;
+  
+  p_advance(parser); // Advance past 'input'
 
   p_consume(parser, TOK_LT,
-            "Expected a '<' before you declare the type you want to cast too.");
+            "Expected a '<' before you declare the type you want to input.");
+  
   Type *type = parse_type(parser);
-  p_advance(parser);
+  // parse_type() has already advanced past the type
+  
   p_consume(parser, TOK_GT,
-            "Expected a '>' after defining the type you want to cast too, but "
-            "before defining what you are casting");
+            "Expected a '>' after defining the type you want to input");
+  
   p_consume(parser, TOK_LPAREN,
-            "Expected a '(' before defining what you are casting");
+            "Expected a '(' before defining the input message");
+  
   Expr *msg = parse_expr(parser, BP_NONE);
+  
   p_consume(parser, TOK_RPAREN,
-            "Expected a ')' after defining what you are casting");
+            "Expected a ')' after defining the input message");
 
   return create_input_expr(parser->arena, type, msg, line, col);
 }
@@ -585,23 +620,30 @@ Expr *syscall_expr(Parser *parser) {
 // sizeof<[n]int>      Runtime when n is variable
 // sizeof<MyStruct>    Compile-time constant
 Expr *sizeof_expr(Parser *parser) {
-  p_advance(parser); // Advance past the sizeof
   int line = p_current(parser).line;
   int col = p_current(parser).col;
-  AstNode *object = NULL;
-  bool is_type = false;
-
+  
+  p_advance(parser); // Advance past 'sizeof'
+  
   p_consume(parser, TOK_LT,
             "Expected a '<' before defining the var or type you want to get "
             "the size of.");
-  if (parse_type(parser) != NULL) {
-    ;
-    object = parse_type(parser);
-    p_advance(parser);
+  
+  AstNode *object = NULL;
+  bool is_type = false;
+
+  // Try to parse as a type first
+  Type *type_result = parse_type(parser);
+  if (type_result != NULL) {
+    object = (AstNode *)type_result;
     is_type = true;
+    // parse_type() has already advanced past the type
   } else {
-    object = parse_expr(parser, BP_NONE);
+    // Not a type, parse as an expression
+    object = (AstNode *)parse_expr(parser, BP_NONE);
+    is_type = false;
   }
+  
   p_consume(parser, TOK_GT,
             "Expected a '>' after defining the var or type you want to get the "
             "size of.");

src/parser/parser.c

@@ -402,7 +402,8 @@ Expr *parse_expr(Parser *parser, BindingPower bp) {
   Expr *left = nud(parser);
 
   while (p_has_tokens(parser) && get_bp(p_current(parser).type_) > bp) {
-    left = led(parser, left, get_bp(p_current(parser).type_));
+    BindingPower current_bp = get_bp(p_current(parser).type_);
+    left = led(parser, left, current_bp);
   }
 
   return left;
@@ -525,13 +526,9 @@ Type *parse_type(Parser *parser) {
   case TOK_CHAR:
   case TOK_STAR:     // Pointer type
   case TOK_LBRACKET: // Array type
+  case TOK_IDENTIFIER: // Could be simple type or namespace::Type
     return tnud(parser);
 
-  // Optionally: handle identifiers like 'MyStruct' or user-defined types
-  case TOK_IDENTIFIER:
-    return create_basic_type(parser->arena, get_name(parser), parser->tks->line,
-                             parser->tks->col);
-
   default:
     fprintf(stderr, "[parse_type] Unexpected token for type: %d\n", tok);
     return NULL;