parse constructor def

src/ast.c

@@ -34,6 +34,8 @@ char* ASTNodeTypeToCStr(CometASTNodeType nodeType) {
             return "AST_WHILE_STATEMENT";
         case AST_FOR_STATEMENT:
             return "AST_FOR_STATEMENT";
+        case AST_CONSTRUCTOR_DEF:
+            return "AST_CONSTRUCTOR_DEF";
 
         case AST_INFIX_EXPRESSION:
             return "AST_INFIX_EXPRESSION";

src/ast.h

@@ -39,6 +39,8 @@ typedef enum {
     AST_FUNC_DEF_STATEMENT,
     AST_RETURN_STATEMENT,
     AST_STRUCT_DEF_STATEMENT,
+    AST_CONSTRUCTOR_DEF,
+    AST_AS_FUNC_DEV,
 
     // expressions
     AST_INFIX_EXPRESSION
@@ -100,6 +102,14 @@ struct CometASTNode {
             CometASTNode* constructor;
             CometASTNode* destructor;
         } AST_STRUCT_DEF_STATEMENT;
+        struct AST_CONSTRUCTOR_DEF {
+            CometASTNode* program;
+            List(astNodePtr) args;
+        } AST_CONSTRUCTOR_DEF;
+        struct AST_AS_FUNC_DEV {
+            CometASTNode* program;
+            CometASTNode* castType;
+        } AST_AS_FUNC_DEV;
 
     } data;  
 };

src/parser.c

@@ -902,7 +902,32 @@ ResultType(astNodePtr, charptr) parseReturnStatement(CometParser* parser) {
     return Success(astNodePtr, charptr, AST_NODE(AST_RETURN_STATEMENT, expr.as.success));
 }
 
+ResultType(astNodePtr, charptr) parseConstructorDef(CometParser* parser) {
+    parserNextToken(parser);
+
+    ResultType(argList, charptr) constructorArgs = parseFunctionDefArgs(parser);
+    if (constructorArgs.error)
+        return Error(astNodePtr, charptr, constructorArgs.as.error);
+
+    ResultType(astNodePtr, charptr) body = parseBlockStatement(parser);
+    if (body.error)
+        return body;
+
+    CometASTNode* stmt = AST_NODE(AST_CONSTRUCTOR_DEF, body.as.success, constructorArgs.as.success);
+
+    return Success(astNodePtr, charptr, stmt);
+}
+
 ResultType(astNodePtr, charptr) parseStructDefStatement(CometParser* parser) {
+    // basic format:
+    // struct StructName {
+    //     int fieldName
+    //
+    //     init(int fieldName) {
+    //         self.fieldName = fieldName
+    //     }
+    // }
+
     ResultType(int, charptr) expectName = expectPeek(parser, CT_IDENT);
     if (expectName.error) {
         return Error(astNodePtr, charptr, expectName.as.error);
@@ -968,6 +993,8 @@ ResultType(astNodePtr, charptr) parseKeyword(CometParser* parser) {
         return parseReturnStatement(parser);
     } else if (strcmp(keyword, "struct") == 0) {
         return parseStructDefStatement(parser);
+    } else if (strcmp(keyword, "init") == 0) {
+        return parseConstructorDef(parser);
     } else {
         char* buffer = malloc(128);
         sprintf(buffer, "No parse method for keyword \"%s\"", keyword);

test.comet

@@ -1,6 +1,10 @@
 struct MyStruct {
     int myField = 0
     big blah = 123
+
+    init() {
+        
+    }
 }
 
 func main() -> int {