Generic Structs (#11)

Reviewed-on: cosmonaut/wraith-lang#11
Co-authored-by: cosmonaut <evan@moonside.games>
Co-committed-by: cosmonaut <evan@moonside.games>

generators/wraith.lex

@@ -12,6 +12,7 @@
 "double"                    return DOUBLE;
 "string"                    return STRING;
 "bool"                      return BOOL;
+"MemoryAddress"             return MEMORYADDRESS;
 "struct"                    return STRUCT;
 "return"                    return RETURN;
 "static"                    return STATIC;
@@ -40,6 +41,7 @@
 ";"                         return SEMICOLON;
 ":"                         return COLON;
 "?"                         return QUESTION;
+"@"                         return AT;
 "("                         return LEFT_PAREN;
 ")"                         return RIGHT_PAREN;
 "["                         return LEFT_BRACKET;

generators/wraith.y

@@ -25,6 +25,7 @@ extern FILE *yyin;
 %token DOUBLE
 %token STRING
 %token BOOL
+%token MEMORYADDRESS
 %token STRUCT
 %token RETURN
 %token STATIC
@@ -54,6 +55,7 @@ extern FILE *yyin;
 %token SEMICOLON
 %token COLON
 %token QUESTION
+%token AT
 %token LEFT_PAREN
 %token RIGHT_PAREN
 %token LEFT_BRACE
@@ -107,9 +109,17 @@ BaseType                : VOID
                         {
                             $$ = MakePrimitiveTypeNode(Bool);
                         }
+                        | MEMORYADDRESS
+                        {
+                            $$ = MakePrimitiveTypeNode(MemoryAddress);
+                        }
+                        | Identifier GenericArgumentClauseNonEmpty
+                        {
+                            $$ = MakeConcreteGenericTypeNode($1, $2);
+                        }
                         | Identifier
                         {
-                            $$ = MakeCustomTypeNode(yytext);
+                            $$ = MakeCustomTypeNode($1);
                         }
                         | REFERENCE LESS_THAN Type GREATER_THAN
                         {
@@ -141,11 +151,40 @@ AccessExpression        : Identifier POINT AccessExpression
                             $$ = $1;
                         }
 
+SystemCallExpression    : AT Identifier
+                        {
+                            $$ = $2;
+                        }
+
 Number                  : NUMBER
                         {
                             $$ = MakeNumberNode(yytext);
                         }
 
+FieldInit               : Identifier COLON Expression
+                        {
+                            $$ = MakeFieldInitNode($1, $3);
+                        }
+
+StructInitFields        : FieldInit
+                        {
+                            $$ = StartStructInitFieldsNode($1);
+                        }
+                        | StructInitFields COMMA FieldInit
+                        {
+                            $$ = AddFieldInitNode($1, $3);
+                        }
+                        |
+                        {
+                            $$ = MakeEmptyFieldInitNode();
+                        }
+                        ;
+
+StructInitExpression    : Type LEFT_BRACE StructInitFields RIGHT_BRACE
+                        {
+                            $$ = MakeStructInitExpressionNode($1, $3);
+                        }
+
 PrimaryExpression       : Number
                         | STRING_LITERAL
                         {
@@ -157,6 +196,7 @@ PrimaryExpression       : Number
                         }
                         | FunctionCallExpression
                         | AccessExpression
+                        | StructInitExpression
                         ;
 
 UnaryExpression         : BANG Expression
@@ -230,9 +270,13 @@ ReturnStatement         : RETURN Expression
                             $$ = MakeReturnVoidStatementNode();
                         }
 
-FunctionCallExpression  : AccessExpression LEFT_PAREN Arguments RIGHT_PAREN
+FunctionCallExpression  : AccessExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
                         {
-                            $$ = MakeFunctionCallExpressionNode($1, $3);
+                            $$ = MakeFunctionCallExpressionNode($1, $4, $2);
+                        }
+                        | SystemCallExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
+                        {
+                            $$ = MakeSystemCallExpressionNode($1, $4, $2);
                         }
 
 PartialStatement        : FunctionCallExpression
@@ -275,11 +319,11 @@ Statements              : Statement
                             $$ = AddStatement($1, $2);
                         }
 
-Arguments               : PrimaryExpression
+Arguments               : Expression
                         {
                             $$ = StartFunctionArgumentSequenceNode($1);
                         }
-                        | Arguments COMMA PrimaryExpression
+                        | Arguments COMMA Expression
                         {
                             $$ = AddFunctionArgumentNode($1, $3);
                         }
@@ -307,9 +351,32 @@ Body                    : LEFT_BRACE Statements RIGHT_BRACE
                             $$ = $2;
                         }
 
-GenericArgument         : Identifier
+GenericDeclaration      : Identifier
                         {
-                            $$ = MakeGenericArgumentNode($1, NULL);
+                            $$ = MakeGenericDeclarationNode($1, NULL);
+                        }
+
+GenericDeclarations     : GenericDeclaration
+                        {
+                            $$ = StartGenericDeclarationsNode($1);
+                        }
+                        | GenericDeclarations COMMA GenericDeclaration
+                        {
+                            $$ = AddGenericDeclaration($1, $3);
+                        }
+
+GenericDeclarationClause    : LESS_THAN GenericDeclarations GREATER_THAN
+                            {
+                                $$ = $2;
+                            }
+                            |
+                            {
+                                $$ = MakeEmptyGenericDeclarationsNode();
+                            }
+
+GenericArgument         : Type
+                        {
+                            $$ = MakeGenericArgumentNode($1);
                         }
 
 GenericArguments        : GenericArgument
@@ -321,21 +388,23 @@ GenericArguments        : GenericArgument
                             $$ = AddGenericArgument($1, $3);
                         }
 
-GenericArgumentsClause  : LESS_THAN GenericArguments GREATER_THAN
-                        {
-                            $$ = $2;
-                        }
+GenericArgumentClauseNonEmpty   : LESS_THAN GenericArguments GREATER_THAN
+                                {
+                                    $$ = $2;
+                                }
+                                ;
+
+GenericArgumentClause   : GenericArgumentClauseNonEmpty
                         |
                         {
                             $$ = MakeEmptyGenericArgumentsNode();
                         }
 
-
-FunctionSignature       : Identifier GenericArgumentsClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+FunctionSignature       : Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
                         {
                             $$ = MakeFunctionSignatureNode($1, $7, $4, MakeFunctionModifiersNode(NULL, 0), $2);
                         }
-                        | STATIC Identifier GenericArgumentsClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+                        | STATIC Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
                         {
                             Node *modifier = MakeStaticNode();
                             $$ = MakeFunctionSignatureNode($2, $8, $5, MakeFunctionModifiersNode(&modifier, 1), $3);
@@ -346,9 +415,9 @@ FunctionDeclaration     : FunctionSignature Body
                             $$ = MakeFunctionDeclarationNode($1, $2);
                         }
 
-StructDeclaration       : STRUCT Identifier LEFT_BRACE Declarations RIGHT_BRACE
+StructDeclaration       : STRUCT Identifier GenericDeclarationClause LEFT_BRACE Declarations RIGHT_BRACE
                         {
-                            $$ = MakeStructDeclarationNode($2, $4);
+                            $$ = MakeStructDeclarationNode($2, $5, $3);
                         }
 
 Declaration             : FunctionDeclaration

generic.w

@@ -5,14 +5,55 @@ struct Foo {
 
     static Func<T>(t: T): T {
         foo: T = t;
-        return Func2(foo);
+        return Foo.Func2(foo);
+    }
+}
+
+struct MemoryBlock<T>
+{
+	start: MemoryAddress;
+	capacity: uint;
+
+	AddressOf(index: uint): MemoryAddress
+    {
+        return start + (index * @sizeof<T>());
+    }
+
+    Get(index: uint): T
+    {
+        return @dereference<T>(AddressOf(index));
+    }
+
+    Set(index: uint, value: T): void
+    {
+        @memcpy(AddressOf(index), @addr(value), @sizeof<T>());
+    }
+
+    Free(): void
+    {
+        @free(start);
     }
 }
 
 struct Program {
-    static main(): int {
+    static Main(): int {
         x: int = 4;
         y: int = Foo.Func(x);
-        return x;
+        block: MemoryBlock<int> = MemoryBlock<int>
+        {
+            capacity: y,
+            start: @malloc(y * @sizeof<int>())
+        };
+        block.Set(0, 5);
+        block.Set(1, 3);
+        block.Set(2, 9);
+        block.Set(3, 100);
+        Console.PrintLine("%p", block.start);
+        Console.PrintLine("%i", block.Get(0));
+        Console.PrintLine("%i", block.Get(1));
+        Console.PrintLine("%i", block.Get(2));
+        Console.PrintLine("%i", block.Get(3));
+        block.Free();
+        return 0;
     }
 }

src/ast.c

@@ -19,6 +19,8 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "BinaryExpression";
     case Comment:
         return "Comment";
+    case ConcreteGenericTypeNode:
+        return "ConcreteGenericTypeNode";
     case CustomTypeNode:
         return "CustomTypeNode";
     case Declaration:
@@ -27,6 +29,8 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "ForLoop";
     case DeclarationSequence:
         return "DeclarationSequence";
+    case FieldInit:
+        return "FieldInit";
     case FunctionArgumentSequence:
         return "FunctionArgumentSequence";
     case FunctionCallExpression:
@@ -43,6 +47,10 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "GenericArgument";
     case GenericArguments:
         return "GenericArguments";
+    case GenericDeclaration:
+        return "GenericDeclaration";
+    case GenericDeclarations:
+        return "GenericDeclarations";
     case GenericTypeNode:
         return "GenericTypeNode";
     case Identifier:
@@ -67,6 +75,12 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "StringLiteral";
     case StructDeclaration:
         return "StructDeclaration";
+    case StructInit:
+        return "StructInit";
+    case StructInitFields:
+        return "StructInitFields";
+    case SystemCall:
+        return "SystemCall";
     case Type:
         return "Type";
     case UnaryExpression:
@@ -89,11 +103,12 @@ Node *MakePrimitiveTypeNode(PrimitiveType type)
     return node;
 }
 
-Node *MakeCustomTypeNode(char *name)
+Node *MakeCustomTypeNode(Node *identifierNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = CustomTypeNode;
-    node->customType.name = strdup(name);
+    node->customType.name = strdup(identifierNode->identifier.name);
+    free(identifierNode);
     return node;
 }
 
@@ -105,6 +120,18 @@ Node *MakeReferenceTypeNode(Node *typeNode)
     return node;
 }
 
+Node *MakeConcreteGenericTypeNode(
+    Node *identifierNode,
+    Node *genericArgumentsNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = ConcreteGenericTypeNode;
+    node->concreteGenericType.name = strdup(identifierNode->identifier.name);
+    node->concreteGenericType.genericArguments = genericArgumentsNode;
+    free(identifierNode);
+    return node;
+}
+
 Node *MakeTypeNode(Node *typeNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
@@ -286,7 +313,7 @@ Node *MakeFunctionSignatureNode(
     node->functionSignature.type = typeNode;
     node->functionSignature.arguments = arguments;
     node->functionSignature.modifiers = modifiersNode;
-    node->functionSignature.genericArguments = genericArgumentsNode;
+    node->functionSignature.genericDeclarations = genericArgumentsNode;
     return node;
 }
 
@@ -303,12 +330,14 @@ Node *MakeFunctionDeclarationNode(
 
 Node *MakeStructDeclarationNode(
     Node *identifierNode,
-    Node *declarationSequenceNode)
+    Node *declarationSequenceNode,
+    Node *genericArgumentsNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = StructDeclaration;
     node->structDeclaration.identifier = identifierNode;
     node->structDeclaration.declarationSequence = declarationSequenceNode;
+    node->structDeclaration.genericDeclarations = genericArgumentsNode;
     return node;
 }
 
@@ -367,12 +396,55 @@ Node *MakeEmptyFunctionArgumentSequenceNode()
     return node;
 }
 
-Node *MakeGenericArgumentNode(Node *identifierNode, Node *constraintNode)
+Node *MakeGenericDeclarationNode(Node *identifierNode, Node *constraintNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = GenericDeclaration;
+    node->genericDeclaration.identifier = identifierNode;
+    node->genericDeclaration.constraint = constraintNode;
+    return node;
+}
+
+Node *StartGenericDeclarationsNode(Node *genericArgumentNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = GenericDeclarations;
+    node->genericDeclarations.declarations = (Node **)malloc(sizeof(Node *));
+    node->genericDeclarations.declarations[0] = genericArgumentNode;
+    node->genericDeclarations.count = 1;
+    return node;
+}
+
+Node *AddGenericDeclaration(
+    Node *genericDeclarationsNode,
+    Node *genericDeclarationNode)
+{
+    genericDeclarationsNode->genericDeclarations.declarations =
+        (Node **)realloc(
+            genericDeclarationsNode->genericDeclarations.declarations,
+            sizeof(Node *) *
+                (genericDeclarationsNode->genericDeclarations.count + 1));
+    genericDeclarationsNode->genericDeclarations
+        .declarations[genericDeclarationsNode->genericDeclarations.count] =
+        genericDeclarationNode;
+    genericDeclarationsNode->genericDeclarations.count += 1;
+    return genericDeclarationsNode;
+}
+
+Node *MakeEmptyGenericDeclarationsNode()
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = GenericDeclarations;
+    node->genericDeclarations.declarations = NULL;
+    node->genericDeclarations.count = 0;
+    return node;
+}
+
+Node *MakeGenericArgumentNode(Node *typeNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = GenericArgument;
-    node->genericArgument.identifier = identifierNode;
-    node->genericArgument.constraint = constraintNode;
+    node->genericArgument.type = typeNode;
     return node;
 }
 
@@ -388,13 +460,13 @@ Node *StartGenericArgumentsNode(Node *genericArgumentNode)
 
 Node *AddGenericArgument(Node *genericArgumentsNode, Node *genericArgumentNode)
 {
-    genericArgumentsNode->genericArguments.arguments = (Node **)realloc(
+    genericArgumentsNode->genericArguments.arguments = realloc(
         genericArgumentsNode->genericArguments.arguments,
         sizeof(Node *) * (genericArgumentsNode->genericArguments.count + 1));
     genericArgumentsNode->genericArguments
         .arguments[genericArgumentsNode->genericArguments.count] =
         genericArgumentNode;
-    genericArgumentsNode->genericArguments.count += 1;
+    genericArgumentNode->genericArguments.count += 1;
     return genericArgumentsNode;
 }
 
@@ -417,12 +489,27 @@ Node *MakeGenericTypeNode(char *name)
 
 Node *MakeFunctionCallExpressionNode(
     Node *identifierNode,
-    Node *argumentSequenceNode)
+    Node *argumentSequenceNode,
+    Node *genericArgumentsNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = FunctionCallExpression;
     node->functionCallExpression.identifier = identifierNode;
     node->functionCallExpression.argumentSequence = argumentSequenceNode;
+    node->functionCallExpression.genericArguments = genericArgumentsNode;
+    return node;
+}
+
+Node *MakeSystemCallExpressionNode(
+    Node *identifierNode,
+    Node *argumentSequenceNode,
+    Node *genericArgumentsNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = SystemCall;
+    node->systemCall.identifier = identifierNode;
+    node->systemCall.argumentSequence = argumentSequenceNode;
+    node->systemCall.genericArguments = genericArgumentsNode;
     return node;
 }
 
@@ -476,6 +563,55 @@ Node *MakeForLoopNode(
     return node;
 }
 
+Node *MakeFieldInitNode(Node *identifierNode, Node *expressionNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = FieldInit;
+    node->fieldInit.identifier = identifierNode;
+    node->fieldInit.expression = expressionNode;
+    return node;
+}
+
+Node *StartStructInitFieldsNode(Node *fieldInitNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = StructInitFields;
+    node->structInitFields.fieldInits = (Node **)malloc(sizeof(Node *));
+    node->structInitFields.fieldInits[0] = fieldInitNode;
+    node->structInitFields.count = 1;
+    return node;
+}
+
+Node *AddFieldInitNode(Node *structInitFieldsNode, Node *fieldInitNode)
+{
+    structInitFieldsNode->structInitFields.fieldInits = realloc(
+        structInitFieldsNode->structInitFields.fieldInits,
+        sizeof(Node *) * (structInitFieldsNode->structInitFields.count + 1));
+    structInitFieldsNode->structInitFields
+        .fieldInits[structInitFieldsNode->structInitFields.count] =
+        fieldInitNode;
+    structInitFieldsNode->structInitFields.count += 1;
+    return structInitFieldsNode;
+}
+
+Node *MakeEmptyFieldInitNode()
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = StructInitFields;
+    node->structInitFields.fieldInits = NULL;
+    node->structInitFields.count = 0;
+    return node;
+}
+
+Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = StructInit;
+    node->structInit.type = typeNode;
+    node->structInit.initFields = structInitFieldsNode;
+    return node;
+}
+
 static const char *PrimitiveTypeToString(PrimitiveType type)
 {
     switch (type)
@@ -486,6 +622,8 @@ static const char *PrimitiveTypeToString(PrimitiveType type)
         return "UInt";
     case Bool:
         return "Bool";
+    case MemoryAddress:
+        return "MemoryAddress";
     case Void:
         return "Void";
     }
@@ -556,6 +694,11 @@ void PrintNode(Node *node, uint32_t tabCount)
         PrintNode(node->binaryExpression.right, tabCount + 1);
         return;
 
+    case ConcreteGenericTypeNode:
+        printf("%s\n", node->concreteGenericType.name);
+        PrintNode(node->concreteGenericType.genericArguments, tabCount + 1);
+        return;
+
     case CustomTypeNode:
         printf("%s\n", node->customType.name);
         return;
@@ -574,6 +717,12 @@ void PrintNode(Node *node, uint32_t tabCount)
         }
         return;
 
+    case FieldInit:
+        printf("\n");
+        PrintNode(node->fieldInit.identifier, tabCount + 1);
+        PrintNode(node->fieldInit.expression, tabCount + 1);
+        return;
+
     case ForLoop:
         printf("\n");
         PrintNode(node->forLoop.declaration, tabCount + 1);
@@ -594,6 +743,7 @@ void PrintNode(Node *node, uint32_t tabCount)
         printf("\n");
         PrintNode(node->functionCallExpression.identifier, tabCount + 1);
         PrintNode(node->functionCallExpression.argumentSequence, tabCount + 1);
+        PrintNode(node->functionCallExpression.genericArguments, tabCount + 1);
         return;
 
     case FunctionDeclaration:
@@ -613,7 +763,7 @@ void PrintNode(Node *node, uint32_t tabCount)
     case FunctionSignature:
         printf("\n");
         PrintNode(node->functionSignature.identifier, tabCount + 1);
-        PrintNode(node->functionSignature.genericArguments, tabCount + 1);
+        PrintNode(node->functionSignature.genericDeclarations, tabCount + 1);
         PrintNode(node->functionSignature.arguments, tabCount + 1);
         PrintNode(node->functionSignature.type, tabCount + 1);
         PrintNode(node->functionSignature.modifiers, tabCount + 1);
@@ -631,9 +781,7 @@ void PrintNode(Node *node, uint32_t tabCount)
 
     case GenericArgument:
         printf("\n");
-        PrintNode(node->genericArgument.identifier, tabCount + 1);
-        /* Constraint nodes are not implemented. */
-        /* PrintNode(node->genericArgument.constraint, tabCount + 1); */
+        PrintNode(node->genericArgument.type, tabCount + 1);
         return;
 
     case GenericArguments:
@@ -644,6 +792,21 @@ void PrintNode(Node *node, uint32_t tabCount)
         }
         return;
 
+    case GenericDeclaration:
+        printf("\n");
+        PrintNode(node->genericDeclaration.identifier, tabCount + 1);
+        /* Constraint nodes are not implemented. */
+        /* PrintNode(node->genericDeclaration.constraint, tabCount + 1); */
+        return;
+
+    case GenericDeclarations:
+        printf("\n");
+        for (i = 0; i < node->genericDeclarations.count; i += 1)
+        {
+            PrintNode(node->genericDeclarations.declarations[i], tabCount + 1);
+        }
+        return;
+
     case GenericTypeNode:
         printf("%s\n", node->genericType.name);
         return;
@@ -715,6 +878,27 @@ void PrintNode(Node *node, uint32_t tabCount)
         PrintNode(node->structDeclaration.declarationSequence, tabCount + 1);
         return;
 
+    case StructInit:
+        printf("\n");
+        PrintNode(node->structInit.type, tabCount + 1);
+        PrintNode(node->structInit.initFields, tabCount + 1);
+        return;
+
+    case StructInitFields:
+        printf("\n");
+        for (i = 0; i < node->structInitFields.count; i += 1)
+        {
+            PrintNode(node->structInitFields.fieldInits[i], tabCount + 1);
+        }
+        return;
+
+    case SystemCall:
+        printf("\n");
+        PrintNode(node->systemCall.identifier, tabCount + 1);
+        PrintNode(node->systemCall.argumentSequence, tabCount + 1);
+        PrintNode(node->systemCall.genericArguments, tabCount + 1);
+        return;
+
     case Type:
         printf("\n");
         PrintNode(node->type.typeNode, tabCount + 1);
@@ -754,6 +938,10 @@ void Recurse(Node *node, void (*func)(Node *))
     case Comment:
         return;
 
+    case ConcreteGenericTypeNode:
+        func(node->concreteGenericType.genericArguments);
+        return;
+
     case CustomTypeNode:
         return;
 
@@ -769,6 +957,11 @@ void Recurse(Node *node, void (*func)(Node *))
         }
         return;
 
+    case FieldInit:
+        func(node->fieldInit.identifier);
+        func(node->fieldInit.expression);
+        return;
+
     case ForLoop:
         func(node->forLoop.declaration);
         func(node->forLoop.startNumber);
@@ -786,6 +979,7 @@ void Recurse(Node *node, void (*func)(Node *))
     case FunctionCallExpression:
         func(node->functionCallExpression.identifier);
         func(node->functionCallExpression.argumentSequence);
+        func(node->functionCallExpression.genericArguments);
         return;
 
     case FunctionDeclaration:
@@ -805,7 +999,7 @@ void Recurse(Node *node, void (*func)(Node *))
         func(node->functionSignature.type);
         func(node->functionSignature.arguments);
         func(node->functionSignature.modifiers);
-        func(node->functionSignature.genericArguments);
+        func(node->functionSignature.genericDeclarations);
         return;
 
     case FunctionSignatureArguments:
@@ -816,9 +1010,8 @@ void Recurse(Node *node, void (*func)(Node *))
         return;
 
     case GenericArgument:
-        func(node->genericArgument.identifier);
-        func(node->genericArgument.constraint);
-        return;
+        func(node->genericArgument.type);
+        break;
 
     case GenericArguments:
         for (i = 0; i < node->genericArguments.count; i += 1)
@@ -827,6 +1020,18 @@ void Recurse(Node *node, void (*func)(Node *))
         }
         return;
 
+    case GenericDeclaration:
+        func(node->genericDeclaration.identifier);
+        func(node->genericDeclaration.constraint);
+        return;
+
+    case GenericDeclarations:
+        for (i = 0; i < node->genericDeclarations.count; i += 1)
+        {
+            func(node->genericDeclarations.declarations[i]);
+        }
+        return;
+
     case GenericTypeNode:
         return;
 
@@ -878,7 +1083,26 @@ void Recurse(Node *node, void (*func)(Node *))
         func(node->structDeclaration.declarationSequence);
         return;
 
+    case StructInit:
+        func(node->structInit.type);
+        func(node->structInit.initFields);
+        return;
+
+    case StructInitFields:
+        for (i = 0; i < node->structInitFields.count; i += 1)
+        {
+            func(node->structInitFields.fieldInits[i]);
+        }
+        return;
+
+    case SystemCall:
+        func(node->systemCall.identifier);
+        func(node->systemCall.argumentSequence);
+        func(node->systemCall.genericArguments);
+        return;
+
     case Type:
+        func(node->type.typeNode);
         return;
 
     case UnaryExpression:
@@ -896,6 +1120,8 @@ void Recurse(Node *node, void (*func)(Node *))
 
 TypeTag *MakeTypeTag(Node *node)
 {
+    uint32_t i;
+
     if (node == NULL)
     {
         fprintf(
@@ -926,6 +1152,28 @@ TypeTag *MakeTypeTag(Node *node)
         tag->value.customType = strdup(node->customType.name);
         break;
 
+    case ConcreteGenericTypeNode:
+        tag->type = ConcreteGeneric;
+        tag->value.concreteGenericType.name =
+            strdup(node->concreteGenericType.name);
+        tag->value.concreteGenericType.genericArgumentCount =
+            node->concreteGenericType.genericArguments->genericArguments.count;
+        tag->value.concreteGenericType.genericArguments = malloc(
+            sizeof(TypeTag *) *
+            tag->value.concreteGenericType.genericArgumentCount);
+
+        for (i = 0;
+             i <
+             node->concreteGenericType.genericArguments->genericArguments.count;
+             i += 1)
+        {
+            tag->value.concreteGenericType.genericArguments[i] = MakeTypeTag(
+                node->concreteGenericType.genericArguments->genericArguments
+                    .arguments[i]
+                    ->genericArgument.type);
+        }
+        break;
+
     case Declaration:
         tag = MakeTypeTag(node->declaration.type);
         break;
@@ -945,10 +1193,10 @@ TypeTag *MakeTypeTag(Node *node)
         tag = MakeTypeTag(node->allocExpression.type);
         break;
 
-    case GenericArgument:
+    case GenericDeclaration:
         tag->type = Generic;
         tag->value.genericType =
-            strdup(node->genericArgument.identifier->identifier.name);
+            strdup(node->genericDeclaration.identifier->identifier.name);
         break;
 
     case GenericTypeNode:
@@ -970,6 +1218,8 @@ TypeTag *MakeTypeTag(Node *node)
 
 char *TypeTagToString(TypeTag *tag)
 {
+    uint32_t i;
+
     if (tag == NULL)
     {
         fprintf(
@@ -988,24 +1238,82 @@ char *TypeTagToString(TypeTag *tag)
     {
         char *inner = TypeTagToString(tag->value.referenceType);
         size_t innerStrLen = strlen(inner);
-        char *result = malloc(sizeof(char) * (innerStrLen + 5));
+        char *result = malloc(sizeof(char) * (innerStrLen + 6));
         sprintf(result, "Ref<%s>", inner);
         return result;
     }
     case Custom:
     {
         char *result =
-            malloc(sizeof(char) * (strlen(tag->value.customType) + 8));
+            malloc(sizeof(char) * (strlen(tag->value.customType) + 9));
         sprintf(result, "Custom<%s>", tag->value.customType);
         return result;
     }
     case Generic:
     {
         char *result =
-            malloc(sizeof(char) * (strlen(tag->value.customType) + 9));
-        sprintf(result, "Generic<%s>", tag->value.customType);
+            malloc(sizeof(char) * (strlen(tag->value.genericType) + 10));
+        sprintf(result, "Generic<%s>", tag->value.genericType);
         return result;
     }
+
+    case ConcreteGeneric:
+    {
+        char *result = strdup(tag->value.concreteGenericType.name);
+        uint32_t len = strlen(result);
+        len += 2;
+        result = realloc(result, sizeof(char) * len);
+        strcat(result, "<");
+
+        for (i = 0; i < tag->value.concreteGenericType.genericArgumentCount;
+             i += 1)
+        {
+            char *inner = TypeTagToString(
+                tag->value.concreteGenericType.genericArguments[i]);
+            len += strlen(inner);
+            result = realloc(result, sizeof(char) * (len + 3));
+            if (i != tag->value.concreteGenericType.genericArgumentCount - 1)
+            {
+                strcat(result, ", ");
+            }
+            strcat(result, inner);
+        }
+        result = realloc(result, sizeof(char) * (len + 1));
+        strcat(result, ">");
+        return result;
+    }
+    }
+}
+
+uint8_t TypeTagEqual(TypeTag *typeTagA, TypeTag *typeTagB)
+{
+    if (typeTagA->type != typeTagB->type)
+    {
+        return 0;
+    }
+
+    switch (typeTagA->type)
+    {
+    case Primitive:
+        return typeTagA->value.primitiveType == typeTagB->value.primitiveType;
+
+    case Reference:
+        return TypeTagEqual(
+            typeTagA->value.referenceType,
+            typeTagB->value.referenceType);
+
+    case Custom:
+        return strcmp(typeTagA->value.customType, typeTagB->value.customType) ==
+               0;
+
+    case Generic:
+        return strcmp(
+                   typeTagA->value.genericType,
+                   typeTagB->value.genericType) == 0;
+
+    default:
+        fprintf(stderr, "Invalid type comparison!");
+        return 0;
     }
 }
 
@@ -1056,6 +1364,11 @@ void LinkParentPointers(Node *node, Node *prev)
         }
         return;
 
+    case FieldInit:
+        LinkParentPointers(node->fieldInit.identifier, node);
+        LinkParentPointers(node->fieldInit.expression, node);
+        return;
+
     case ForLoop:
         LinkParentPointers(node->forLoop.declaration, node);
         LinkParentPointers(node->forLoop.startNumber, node);
@@ -1094,7 +1407,7 @@ void LinkParentPointers(Node *node, Node *prev)
         LinkParentPointers(node->functionSignature.type, node);
         LinkParentPointers(node->functionSignature.arguments, node);
         LinkParentPointers(node->functionSignature.modifiers, node);
-        LinkParentPointers(node->functionSignature.genericArguments, node);
+        LinkParentPointers(node->functionSignature.genericDeclarations, node);
         return;
 
     case FunctionSignatureArguments:
@@ -1107,8 +1420,7 @@ void LinkParentPointers(Node *node, Node *prev)
         return;
 
     case GenericArgument:
-        LinkParentPointers(node->genericArgument.identifier, node);
-        LinkParentPointers(node->genericArgument.constraint, node);
+        LinkParentPointers(node->genericArgument.type, node);
         return;
 
     case GenericArguments:
@@ -1118,6 +1430,18 @@ void LinkParentPointers(Node *node, Node *prev)
         }
         return;
 
+    case GenericDeclaration:
+        LinkParentPointers(node->genericDeclaration.identifier, node);
+        LinkParentPointers(node->genericDeclaration.constraint, node);
+        return;
+
+    case GenericDeclarations:
+        for (i = 0; i < node->genericDeclarations.count; i += 1)
+        {
+            LinkParentPointers(node->genericDeclarations.declarations[i], node);
+        }
+        return;
+
     case GenericTypeNode:
         return;
 
@@ -1169,6 +1493,24 @@ void LinkParentPointers(Node *node, Node *prev)
         LinkParentPointers(node->structDeclaration.declarationSequence, node);
         return;
 
+    case StructInit:
+        LinkParentPointers(node->structInit.type, node);
+        LinkParentPointers(node->structInit.initFields, node);
+        return;
+
+    case StructInitFields:
+        for (i = 0; i < node->structInitFields.count; i += 1)
+        {
+            LinkParentPointers(node->structInitFields.fieldInits[i], node);
+        }
+        return;
+
+    case SystemCall:
+        LinkParentPointers(node->systemCall.identifier, node);
+        LinkParentPointers(node->systemCall.argumentSequence, node);
+        LinkParentPointers(node->systemCall.genericArguments, node);
+        return;
+
     case Type:
         return;
 

src/ast.h

@@ -19,9 +19,11 @@ typedef enum
     Assignment,
     BinaryExpression,
     Comment,
+    ConcreteGenericTypeNode,
     CustomTypeNode,
     Declaration,
     DeclarationSequence,
+    FieldInit,
     ForLoop,
     FunctionArgumentSequence,
     FunctionCallExpression,
@@ -31,6 +33,8 @@ typedef enum
     FunctionSignatureArguments,
     GenericArgument,
     GenericArguments,
+    GenericDeclaration,
+    GenericDeclarations,
     GenericTypeNode,
     Identifier,
     IfStatement,
@@ -44,6 +48,9 @@ typedef enum
     StaticModifier,
     StringLiteral,
     StructDeclaration,
+    StructInit,
+    StructInitFields,
+    SystemCall,
     Type,
     UnaryExpression
 } SyntaxKind;
@@ -73,7 +80,8 @@ typedef enum
     UInt,
     Float,
     Double,
-    String
+    String,
+    MemoryAddress
 } PrimitiveType;
 
 typedef union
@@ -82,7 +90,16 @@ typedef union
     BinaryOperator binaryOperator;
 } Operator;
 
-typedef struct TypeTag
+typedef struct TypeTag TypeTag;
+
+typedef struct ConcreteGenericTypeTag
+{
+    char *name;
+    TypeTag **genericArguments;
+    uint32_t genericArgumentCount;
+} ConcreteGenericTypeTag;
+
+struct TypeTag
 {
     enum Type
     {
@@ -90,7 +107,8 @@ typedef struct TypeTag
         Primitive,
         Reference,
         Custom,
-        Generic
+        Generic,
+        ConcreteGeneric
     } type;
     union
     {
@@ -102,8 +120,10 @@ typedef struct TypeTag
         char *customType;
         /* Valid when type = Generic. */
         char *genericType;
+        /* Valid when type = ConcreteGeneric */
+        ConcreteGenericTypeTag concreteGenericType;
     } value;
-} TypeTag;
+};
 
 typedef struct Node Node;
 
@@ -142,6 +162,12 @@ struct Node
 
         } comment;
 
+        struct
+        {
+            char *name;
+            Node *genericArguments;
+        } concreteGenericType;
+
         struct
         {
             char *name;
@@ -159,6 +185,12 @@ struct Node
             uint32_t count;
         } declarationSequence;
 
+        struct
+        {
+            Node *identifier;
+            Node *expression;
+        } fieldInit;
+
         struct
         {
             Node *declaration;
@@ -177,6 +209,7 @@ struct Node
         {
             Node *identifier; /* FIXME: need better name */
             Node *argumentSequence;
+            Node *genericArguments;
         } functionCallExpression;
 
         struct
@@ -197,7 +230,7 @@ struct Node
             Node *type;
             Node *arguments;
             Node *modifiers;
-            Node *genericArguments;
+            Node *genericDeclarations;
         } functionSignature;
 
         struct
@@ -208,8 +241,7 @@ struct Node
 
         struct
         {
-            Node *identifier;
-            Node *constraint;
+            Node *type;
         } genericArgument;
 
         struct
@@ -218,6 +250,18 @@ struct Node
             uint32_t count;
         } genericArguments;
 
+        struct
+        {
+            Node *identifier;
+            Node *constraint;
+        } genericDeclaration;
+
+        struct
+        {
+            Node **declarations;
+            uint32_t count;
+        } genericDeclarations;
+
         struct
         {
             char *name;
@@ -285,8 +329,28 @@ struct Node
         {
             Node *identifier;
             Node *declarationSequence;
+            Node *genericDeclarations;
         } structDeclaration;
 
+        struct
+        {
+            Node *type;
+            Node *initFields;
+        } structInit;
+
+        struct
+        {
+            Node **fieldInits;
+            uint32_t count;
+        } structInitFields;
+
+        struct
+        {
+            Node *identifier;
+            Node *argumentSequence;
+            Node *genericArguments;
+        } systemCall;
+
         struct
         {
             Node *typeNode;
@@ -305,8 +369,11 @@ const char *SyntaxKindString(SyntaxKind syntaxKind);
 
 uint8_t IsPrimitiveType(Node *typeNode);
 Node *MakePrimitiveTypeNode(PrimitiveType type);
-Node *MakeCustomTypeNode(char *string);
+Node *MakeCustomTypeNode(Node *identifierNode);
 Node *MakeReferenceTypeNode(Node *typeNode);
+Node *MakeConcreteGenericTypeNode(
+    Node *identifierNode,
+    Node *genericArgumentsNode);
 Node *MakeTypeNode(Node *typeNode);
 Node *MakeIdentifierNode(const char *id);
 Node *MakeNumberNode(const char *numberString);
@@ -333,14 +400,21 @@ Node *MakeFunctionSignatureNode(
 Node *MakeFunctionDeclarationNode(
     Node *functionSignatureNode,
     Node *functionBodyNode);
-Node *MakeGenericArgumentNode(Node *identifierNode, Node *constraintNode);
+Node *MakeGenericDeclarationNode(Node *identifierNode, Node *constraintNode);
+Node *MakeEmptyGenericDeclarationsNode();
+Node *StartGenericDeclarationsNode(Node *genericDeclarationNode);
+Node *AddGenericDeclaration(
+    Node *genericDeclarationsNode,
+    Node *genericDeclarationNode);
+Node *MakeGenericArgumentNode(Node *typeNode);
 Node *MakeEmptyGenericArgumentsNode();
 Node *StartGenericArgumentsNode(Node *genericArgumentNode);
 Node *AddGenericArgument(Node *genericArgumentsNode, Node *genericArgumentNode);
 Node *MakeGenericTypeNode(char *name);
 Node *MakeStructDeclarationNode(
     Node *identifierNode,
-    Node *declarationSequenceNode);
+    Node *declarationSequenceNode,
+    Node *genericArgumentsNode);
 Node *StartDeclarationSequenceNode(Node *declarationNode);
 Node *AddDeclarationNode(Node *declarationSequenceNode, Node *declarationNode);
 Node *StartFunctionArgumentSequenceNode(Node *argumentNode);
@@ -348,7 +422,12 @@ Node *AddFunctionArgumentNode(Node *argumentSequenceNode, Node *argumentNode);
 Node *MakeEmptyFunctionArgumentSequenceNode();
 Node *MakeFunctionCallExpressionNode(
     Node *identifierNode,
-    Node *argumentSequenceNode);
+    Node *argumentSequenceNode,
+    Node *genericArgumentsNode);
+Node *MakeSystemCallExpressionNode(
+    Node *identifierNode,
+    Node *argumentSequenceNode,
+    Node *genericArgumentsNode);
 Node *MakeAccessExpressionNode(Node *accessee, Node *accessor);
 Node *MakeAllocNode(Node *typeNode);
 Node *MakeIfNode(Node *expressionNode, Node *statementSequenceNode);
@@ -361,6 +440,11 @@ Node *MakeForLoopNode(
     Node *startNumberNode,
     Node *endNumberNode,
     Node *statementSequenceNode);
+Node *MakeFieldInitNode(Node *identifierNode, Node *expressionNode);
+Node *StartStructInitFieldsNode(Node *fieldInitNode);
+Node *AddFieldInitNode(Node *structInitFieldsNode, Node *fieldInitNode);
+Node *MakeEmptyFieldInitNode();
+Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode);
 
 void PrintNode(Node *node, uint32_t tabCount);
 const char *SyntaxKindString(SyntaxKind syntaxKind);
@@ -376,6 +460,7 @@ void LinkParentPointers(Node *node, Node *prev);
 
 TypeTag *MakeTypeTag(Node *node);
 char *TypeTagToString(TypeTag *tag);
+uint8_t TypeTagEqual(TypeTag *typeTagA, TypeTag *typeTagB);
 
 Node *LookupIdNode(Node *current, Node *prev, char *target);
 

src/util.c

@@ -5,7 +5,7 @@
 char *strdup(const char *s)
 {
     size_t slen = strlen(s);
-    char *result = (char *)malloc(slen + 1);
+    char *result = (char *)malloc(sizeof(char) * (slen + 1));
     if (result == NULL)
     {
         return NULL;
@@ -15,6 +15,15 @@ char *strdup(const char *s)
     return result;
 }
 
+char *w_strcat(char *s, char *s2)
+{
+    size_t slen = strlen(s);
+    size_t slen2 = strlen(s2);
+    s = realloc(s, sizeof(char) * (slen + slen2 + 1));
+    strcat(s, s2);
+    return s;
+}
+
 uint64_t str_hash(char *str)
 {
     uint64_t hash = 5381;

src/util.h

@@ -5,6 +5,7 @@
 #include <string.h>
 
 char *strdup(const char *s);
+char *w_strcat(char *s, char *s2);
 uint64_t str_hash(char *str);
 
 #endif /* WRAITH_UTIL_H */

src/validation.c

@@ -261,7 +261,7 @@ void ValidateIdentifiers(Node *node)
 
     /* Skip over generic arguments. They contain Identifiers but are not
      * actually identifiers, they declare types. */
-    if (node->syntaxKind == GenericArguments)
+    if (node->syntaxKind == GenericDeclarations)
         return;
 
     if (node->syntaxKind != Identifier)
@@ -309,8 +309,12 @@ void TagIdentifierTypes(Node *node)
         node->structDeclaration.identifier->typeTag = MakeTypeTag(node);
         break;
 
-    case GenericArgument:
-        node->genericArgument.identifier->typeTag = MakeTypeTag(node);
+    case GenericDeclaration:
+        node->genericDeclaration.identifier->typeTag = MakeTypeTag(node);
+        break;
+
+    case Type:
+        node->typeTag = MakeTypeTag(node);
         break;
 
     case Identifier:
@@ -351,17 +355,19 @@ Node *LookupType(Node *current, char *target)
     case FunctionDeclaration:
     {
         Node *typeArgs = current->functionDeclaration.functionSignature
-                             ->functionSignature.genericArguments;
+                             ->functionSignature.genericDeclarations;
         uint32_t i;
-        for (i = 0; i < typeArgs->genericArguments.count; i += 1)
+        for (i = 0; i < typeArgs->genericDeclarations.count; i += 1)
         {
-            Node *arg = typeArgs->genericArguments.arguments[i];
-            Node *argId = arg->genericArgument.identifier;
+            Node *arg = typeArgs->genericDeclarations.declarations[i];
+            Node *argId = arg->genericDeclaration.identifier;
             char *argName = argId->identifier.name;
-            /* note: return the GenericArgument, not the Identifier, so that
+            /* note: return the GenericDeclaration, not the Identifier, so that
              * the caller can differentiate between generics and customs. */
             if (strcmp(target, argName) == 0)
+            {
                 return arg;
+            }
         }
 
         return LookupType(current->parent, target);
@@ -369,9 +375,26 @@ Node *LookupType(Node *current, char *target)
 
     case StructDeclaration:
     {
+        uint32_t i;
+        Node *typeArgs = current->structDeclaration.genericDeclarations;
+        for (i = 0; i < typeArgs->genericDeclarations.count; i += 1)
+        {
+            Node *arg = typeArgs->genericDeclarations.declarations[i];
+            Node *argId = arg->genericDeclaration.identifier;
+            char *argName = argId->identifier.name;
+            /* note: return the GenericDeclaration, not the Identifier, so that
+             * the caller can differentiate between generics and customs. */
+            if (strcmp(target, argName) == 0)
+            {
+                return arg;
+            }
+        }
+
         Node *structId = GetIdFromStruct(current);
         if (strcmp(target, structId->identifier.name) == 0)
+        {
             return structId;
+        }
 
         return LookupType(current->parent, target);
     }
@@ -417,7 +440,8 @@ void ConvertCustomsToGenerics(Node *node)
         {
             char *target = id->typeTag->value.customType;
             Node *typeLookup = LookupType(node, target);
-            if (typeLookup != NULL && typeLookup->syntaxKind == GenericArgument)
+            if (typeLookup != NULL &&
+                typeLookup->syntaxKind == GenericDeclaration)
             {
                 id->typeTag->type = Generic;
                 free(node->declaration.type);
@@ -436,7 +460,8 @@ void ConvertCustomsToGenerics(Node *node)
         {
             char *target = id->typeTag->value.customType;
             Node *typeLookup = LookupType(node, target);
-            if (typeLookup != NULL && typeLookup->syntaxKind == GenericArgument)
+            if (typeLookup != NULL &&
+                typeLookup->syntaxKind == GenericDeclaration)
             {
                 id->typeTag->type = Generic;
                 free(node->functionSignature.type);
@@ -446,6 +471,22 @@ void ConvertCustomsToGenerics(Node *node)
         }
         break;
     }
+
+    case GenericArgument:
+    {
+        Node *typeNode = node->genericArgument.type;
+        if (typeNode->typeTag->type == Custom)
+        {
+            char *target = typeNode->typeTag->value.customType;
+            Node *typeLookup = LookupType(node, target);
+            if (typeLookup != NULL &&
+                typeLookup->syntaxKind == GenericDeclaration)
+            {
+                typeNode->typeTag->type = Generic;
+            }
+        }
+        break;
+    }
     }
 
     Recurse(node, *ConvertCustomsToGenerics);