parser/ast|parser: obj_t -> ast_node_t

Better naming so we don't conflict with stuff from code generation.

src/arl/main.c

@@ -54,7 +54,7 @@ int main(void)
             parse_err_to_string(perr));
     goto fail;
   }
-  printf("=> Parsed %lu objects\n", ast.objects.size / sizeof(obj_t));
+  printf("=> Parsed %lu nodes\n", ast.nodes.size / sizeof(ast_node_t));
   ast_print(stdout, &ast);
   printf("\n");
 
@@ -64,7 +64,7 @@ int main(void)
 fail:
   if (contents.data)
     free(contents.data);
-  if (ast.objects.capacity > 0)
+  if (ast.nodes.capacity > 0)
     ast_free(&ast);
   return 1;
 }

src/arl/parser/ast.c

@@ -8,25 +8,25 @@
 #include <arl/lib/vec.h>
 #include <arl/parser/ast.h>
 
-obj_t obj_string(u64 byte, sv_t string)
+ast_node_t ast_node_string(u64 byte, sv_t string)
 {
-  return (obj_t){
+  return (ast_node_t){
       .byte_location = byte,
-      .type          = OBJ_TYPE_STRING,
+      .type          = AST_NODE_TYPE_STRING,
       .value         = {string},
   };
 }
 
-obj_t obj_symbol(u64 byte, sv_t symbol)
+ast_node_t ast_node_symbol(u64 byte, sv_t symbol)
 {
-  return (obj_t){
+  return (ast_node_t){
       .byte_location = byte,
-      .type          = OBJ_TYPE_SYMBOL,
+      .type          = AST_NODE_TYPE_SYMBOL,
       .value         = {symbol},
   };
 }
 
-void obj_print(FILE *fp, obj_t *obj)
+void ast_node_print(FILE *fp, ast_node_t *obj)
 {
   if (!obj)
   {
@@ -35,10 +35,10 @@ void obj_print(FILE *fp, obj_t *obj)
   }
   switch (obj->type)
   {
-  case OBJ_TYPE_SYMBOL:
+  case AST_NODE_TYPE_SYMBOL:
     fprintf(fp, "SYMBOL(" PR_SV ")", SV_FMT(obj->value.as_symbol));
     break;
-  case OBJ_TYPE_STRING:
+  case AST_NODE_TYPE_STRING:
     fprintf(fp, "STRING(" PR_SV ")", SV_FMT(obj->value.as_string));
     break;
   }
@@ -52,18 +52,18 @@ void ast_print(FILE *fp, ast_t *ast)
     return;
   }
   fprintf(fp, "{");
-  if (ast->objects.size == 0)
+  if (ast->nodes.size == 0)
   {
     fprintf(fp, "}\n");
     return;
   }
 
   fprintf(fp, "\n");
-  for (u64 i = 0; i < ast->objects.size / sizeof(obj_t); ++i)
+  for (u64 i = 0; i < ast->nodes.size / sizeof(ast_node_t); ++i)
   {
-    obj_t item = VEC_GET(&ast->objects, i, obj_t);
+    ast_node_t item = VEC_GET(&ast->nodes, i, ast_node_t);
     fprintf(fp, "\t[%lu]: ", i);
-    obj_print(fp, &item);
+    ast_node_print(fp, &item);
     fprintf(fp, "\n");
   }
   fprintf(fp, "}");
@@ -72,7 +72,7 @@ void ast_print(FILE *fp, ast_t *ast)
 void ast_free(ast_t *ast)
 {
   // we can free the vector itself and we're done
-  vec_free(&ast->objects);
+  vec_free(&ast->nodes);
 }
 
 /* Copyright (C) 2026 Aryadev Chavali

src/arl/parser/ast.h

@@ -1,4 +1,4 @@
-/* ast.h: General definition of the AST and objects within it.
+/* ast.h: General definition of the AST and nodes within it.
  * Created: 2026-01-22
  * Author: Aryadev Chavali
  * License: See end of file
@@ -15,32 +15,30 @@
 /// Types the AST can encode
 typedef enum
 {
-  OBJ_TYPE_SYMBOL,
+  AST_NODE_TYPE_SYMBOL = 0,
-  OBJ_TYPE_STRING,
+  AST_NODE_TYPE_STRING,
-} obj_type_t;
+} ast_node_type_t;
 
 /// Node of the AST as a tagged union
 typedef struct
 {
   u64 byte_location;
-  obj_type_t type;
+  ast_node_type_t type;
   union
   {
     sv_t as_string;
     sv_t as_symbol;
   } value;
-} obj_t;
+} ast_node_t;
 
-// Constructors
+ast_node_t ast_node_string(u64 byte, sv_t string);
-obj_t obj_string(u64 byte, sv_t string);
+ast_node_t ast_node_symbol(u64 byte, sv_t symbol);
-obj_t obj_symbol(u64 byte, sv_t symbol);
+void ast_node_print(FILE *fp, ast_node_t *obj);
-
-void obj_print(FILE *fp, obj_t *obj);
 
 /// The AST as a flat collection of nodes
 typedef struct
 {
-  vec_t objects;
+  vec_t nodes;
 } ast_t;
 
 void ast_free(ast_t *ast);

src/arl/parser/parser.c

@@ -56,8 +56,8 @@ void parse_stream_get_line_col(parse_stream_t *stream, u64 *line, u64 *col)
 }
 
 /// Prototypes for parsing subroutines
-parse_err_t parse_string(parse_stream_t *stream, obj_t *ret);
+parse_err_t parse_string(parse_stream_t *stream, ast_node_t *ret);
-parse_err_t parse_symbol(parse_stream_t *stream, obj_t *ret);
+parse_err_t parse_symbol(parse_stream_t *stream, ast_node_t *ret);
 
 parse_err_t parse(ast_t *out, parse_stream_t *stream)
 {
@@ -76,21 +76,21 @@ parse_err_t parse(ast_t *out, parse_stream_t *stream)
     else if (cur == '"')
     {
       // we make a copy for parse_string to mess with
-      obj_t ret        = {0};
+      ast_node_t ret   = {0};
       parse_err_t perr = parse_string(stream, &ret);
       if (perr)
         return perr;
-      vec_append(&out->objects, &ret, sizeof(ret));
+      vec_append(&out->nodes, &ret, sizeof(ret));
     }
     else if (strchr(SYMBOL_CHARS, cur) && !isdigit(cur))
     {
       // we make a copy for parse_symbol to mess with
-      obj_t ret        = {0};
+      ast_node_t ret   = {0};
       parse_err_t perr = parse_symbol(stream, &ret);
       if (perr)
         return perr;
 
-      vec_append(&out->objects, &ret, sizeof(ret));
+      vec_append(&out->nodes, &ret, sizeof(ret));
     }
     else
     {
@@ -100,7 +100,7 @@ parse_err_t parse(ast_t *out, parse_stream_t *stream)
   return PARSE_ERR_OK;
 }
 
-parse_err_t parse_string(parse_stream_t *stream, obj_t *ret)
+parse_err_t parse_string(parse_stream_t *stream, ast_node_t *ret)
 {
   // Increment the cursor just past the first speechmark
   stream_advance(stream, 1);
@@ -110,17 +110,18 @@ parse_err_t parse_string(parse_stream_t *stream, obj_t *ret)
     return PARSE_ERR_EXPECTED_SPEECH_MARKS;
   // Bounds of string are well defined, generate an object and advance the
   // stream
-  *ret = obj_string(stream->byte - 1, SV(current_contents.data, string_size));
+  *ret =
+      ast_node_string(stream->byte - 1, SV(current_contents.data, string_size));
   stream_advance(stream, string_size + 1);
   return PARSE_ERR_OK;
 }
 
-parse_err_t parse_symbol(parse_stream_t *stream, obj_t *ret)
+parse_err_t parse_symbol(parse_stream_t *stream, ast_node_t *ret)
 {
   sv_t current_contents = sv_chop_left(stream->contents, stream->byte);
   u64 symbol_size       = sv_while(current_contents, SYMBOL_CHARS);
   // Generate symbol
-  *ret = obj_symbol(stream->byte, SV(current_contents.data, symbol_size));
+  *ret = ast_node_symbol(stream->byte, SV(current_contents.data, symbol_size));
   stream_advance(stream, symbol_size);
   return PARSE_ERR_OK;
 }