Generic Structs (#11)

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

CMakeLists.txt

@@ -41,12 +41,14 @@ add_executable(
 	# Source
 	src/ast.h
 	src/codegen.h
-	src/identcheck.h
 	src/parser.h
+	src/validation.h
+	src/util.h
     src/ast.c
 	src/codegen.c
-	src/identcheck.c
 	src/parser.c
+	src/validation.c
+	src/util.c
 	src/main.c
 	# Generated code
     ${BISON_Parser_OUTPUTS}

access.w

@@ -0,0 +1,13 @@
+struct G {
+    Foo(t: bool): bool {
+        return t;
+    }
+}
+
+struct Program {
+    static main(): int {
+        g: G = alloc G;
+        g.Foo(true);
+        return 0;
+    }
+}

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,14 +351,63 @@ Body                    : LEFT_BRACE Statements RIGHT_BRACE
                             $$ = $2;
                         }
 
-FunctionSignature       : Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+GenericDeclaration      : Identifier
                         {
-                            $$ = MakeFunctionSignatureNode($1, $6, $3, MakeFunctionModifiersNode(NULL, 0));
+                            $$ = MakeGenericDeclarationNode($1, NULL);
                         }
-                        | STATIC Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+
+GenericDeclarations     : GenericDeclaration
+                        {
+                            $$ = StartGenericDeclarationsNode($1);
+                        }
+                        | GenericDeclarations COMMA GenericDeclaration
+                        {
+                            $$ = AddGenericDeclaration($1, $3);
+                        }
+
+GenericDeclarationClause    : LESS_THAN GenericDeclarations GREATER_THAN
+                            {
+                                $$ = $2;
+                            }
+                            |
+                            {
+                                $$ = MakeEmptyGenericDeclarationsNode();
+                            }
+
+GenericArgument         : Type
+                        {
+                            $$ = MakeGenericArgumentNode($1);
+                        }
+
+GenericArguments        : GenericArgument
+                        {
+                            $$ = StartGenericArgumentsNode($1);
+                        }
+                        | GenericArguments COMMA GenericArgument
+                        {
+                            $$ = AddGenericArgument($1, $3);
+                        }
+
+GenericArgumentClauseNonEmpty   : LESS_THAN GenericArguments GREATER_THAN
+                                {
+                                    $$ = $2;
+                                }
+                                ;
+
+GenericArgumentClause   : GenericArgumentClauseNonEmpty
+                        |
+                        {
+                            $$ = MakeEmptyGenericArgumentsNode();
+                        }
+
+FunctionSignature       : Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+                        {
+                            $$ = MakeFunctionSignatureNode($1, $7, $4, MakeFunctionModifiersNode(NULL, 0), $2);
+                        }
+                        | STATIC Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
                         {
                             Node *modifier = MakeStaticNode();
-                            $$ = MakeFunctionSignatureNode($2, $7, $4, MakeFunctionModifiersNode(&modifier, 1));
+                            $$ = MakeFunctionSignatureNode($2, $8, $5, MakeFunctionModifiersNode(&modifier, 1), $3);
                         }
 
 FunctionDeclaration     : FunctionSignature Body
@@ -322,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

@@ -0,0 +1,59 @@
+struct Foo {
+    static Func2<U>(u: U) : U {
+        return u;
+    }
+
+    static Func<T>(t: T): T {
+        foo: T = t;
+        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 {
+        x: int = 4;
+        y: int = Foo.Func(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;
+    }
+}

ordering.w

@@ -0,0 +1,15 @@
+struct Foo {
+    static Func(): void {
+        Func2();
+    }
+
+    static Func2(): void {
+        Func();
+    }
+}
+
+struct Program {
+    static main(): int {
+        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:
@@ -39,6 +43,16 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "FunctionSignature";
     case FunctionSignatureArguments:
         return "FunctionSignatureArguments";
+    case GenericArgument:
+        return "GenericArgument";
+    case GenericArguments:
+        return "GenericArguments";
+    case GenericDeclaration:
+        return "GenericDeclaration";
+    case GenericDeclarations:
+        return "GenericDeclarations";
+    case GenericTypeNode:
+        return "GenericTypeNode";
     case Identifier:
         return "Identifier";
     case IfStatement:
@@ -61,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:
@@ -83,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;
 }
 
@@ -99,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));
@@ -271,7 +304,8 @@ Node *MakeFunctionSignatureNode(
     Node *identifierNode,
     Node *typeNode,
     Node *arguments,
-    Node *modifiersNode)
+    Node *modifiersNode,
+    Node *genericArgumentsNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = FunctionSignature;
@@ -279,6 +313,7 @@ Node *MakeFunctionSignatureNode(
     node->functionSignature.type = typeNode;
     node->functionSignature.arguments = arguments;
     node->functionSignature.modifiers = modifiersNode;
+    node->functionSignature.genericDeclarations = genericArgumentsNode;
     return node;
 }
 
@@ -295,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;
 }
 
@@ -359,14 +396,120 @@ Node *MakeEmptyFunctionArgumentSequenceNode()
     return node;
 }
 
+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.type = typeNode;
+    return node;
+}
+
+Node *StartGenericArgumentsNode(Node *genericArgumentNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = GenericArguments;
+    node->genericArguments.arguments = (Node **)malloc(sizeof(Node *));
+    node->genericArguments.arguments[0] = genericArgumentNode;
+    node->genericArguments.count = 1;
+    return node;
+}
+
+Node *AddGenericArgument(Node *genericArgumentsNode, Node *genericArgumentNode)
+{
+    genericArgumentsNode->genericArguments.arguments = realloc(
+        genericArgumentsNode->genericArguments.arguments,
+        sizeof(Node *) * (genericArgumentsNode->genericArguments.count + 1));
+    genericArgumentsNode->genericArguments
+        .arguments[genericArgumentsNode->genericArguments.count] =
+        genericArgumentNode;
+    genericArgumentNode->genericArguments.count += 1;
+    return genericArgumentsNode;
+}
+
+Node *MakeEmptyGenericArgumentsNode()
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = GenericArguments;
+    node->genericArguments.arguments = NULL;
+    node->genericArguments.count = 0;
+    return node;
+}
+
+Node *MakeGenericTypeNode(char *name)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = GenericTypeNode;
+    node->genericType.name = strdup(name);
+    return node;
+}
+
 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;
 }
 
@@ -420,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)
@@ -430,6 +622,8 @@ static const char *PrimitiveTypeToString(PrimitiveType type)
         return "UInt";
     case Bool:
         return "Bool";
+    case MemoryAddress:
+        return "MemoryAddress";
     case Void:
         return "Void";
     }
@@ -500,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;
@@ -518,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);
@@ -538,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:
@@ -557,6 +763,7 @@ void PrintNode(Node *node, uint32_t tabCount)
     case FunctionSignature:
         printf("\n");
         PrintNode(node->functionSignature.identifier, 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);
@@ -572,6 +779,38 @@ void PrintNode(Node *node, uint32_t tabCount)
         }
         return;
 
+    case GenericArgument:
+        printf("\n");
+        PrintNode(node->genericArgument.type, tabCount + 1);
+        return;
+
+    case GenericArguments:
+        printf("\n");
+        for (i = 0; i < node->genericArguments.count; i += 1)
+        {
+            PrintNode(node->genericArguments.arguments[i], tabCount + 1);
+        }
+        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;
+
     case Identifier:
         if (node->typeTag == NULL)
         {
@@ -630,7 +869,7 @@ void PrintNode(Node *node, uint32_t tabCount)
         return;
 
     case StringLiteral:
-        printf("%s", node->stringLiteral.string);
+        printf("%s\n", node->stringLiteral.string);
         return;
 
     case StructDeclaration:
@@ -639,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);
@@ -651,8 +911,217 @@ void PrintNode(Node *node, uint32_t tabCount)
     }
 }
 
+void Recurse(Node *node, void (*func)(Node *))
+{
+    uint32_t i;
+    switch (node->syntaxKind)
+    {
+    case AccessExpression:
+        func(node->accessExpression.accessee);
+        func(node->accessExpression.accessor);
+        return;
+
+    case AllocExpression:
+        func(node->allocExpression.type);
+        return;
+
+    case Assignment:
+        func(node->assignmentStatement.left);
+        func(node->assignmentStatement.right);
+        return;
+
+    case BinaryExpression:
+        func(node->binaryExpression.left);
+        func(node->binaryExpression.right);
+        return;
+
+    case Comment:
+        return;
+
+    case ConcreteGenericTypeNode:
+        func(node->concreteGenericType.genericArguments);
+        return;
+
+    case CustomTypeNode:
+        return;
+
+    case Declaration:
+        func(node->declaration.type);
+        func(node->declaration.identifier);
+        return;
+
+    case DeclarationSequence:
+        for (i = 0; i < node->declarationSequence.count; i += 1)
+        {
+            func(node->declarationSequence.sequence[i]);
+        }
+        return;
+
+    case FieldInit:
+        func(node->fieldInit.identifier);
+        func(node->fieldInit.expression);
+        return;
+
+    case ForLoop:
+        func(node->forLoop.declaration);
+        func(node->forLoop.startNumber);
+        func(node->forLoop.endNumber);
+        func(node->forLoop.statementSequence);
+        return;
+
+    case FunctionArgumentSequence:
+        for (i = 0; i < node->functionArgumentSequence.count; i += 1)
+        {
+            func(node->functionArgumentSequence.sequence[i]);
+        }
+        return;
+
+    case FunctionCallExpression:
+        func(node->functionCallExpression.identifier);
+        func(node->functionCallExpression.argumentSequence);
+        func(node->functionCallExpression.genericArguments);
+        return;
+
+    case FunctionDeclaration:
+        func(node->functionDeclaration.functionSignature);
+        func(node->functionDeclaration.functionBody);
+        return;
+
+    case FunctionModifiers:
+        for (i = 0; i < node->functionModifiers.count; i += 1)
+        {
+            func(node->functionModifiers.sequence[i]);
+        }
+        return;
+
+    case FunctionSignature:
+        func(node->functionSignature.identifier);
+        func(node->functionSignature.type);
+        func(node->functionSignature.arguments);
+        func(node->functionSignature.modifiers);
+        func(node->functionSignature.genericDeclarations);
+        return;
+
+    case FunctionSignatureArguments:
+        for (i = 0; i < node->functionSignatureArguments.count; i += 1)
+        {
+            func(node->functionSignatureArguments.sequence[i]);
+        }
+        return;
+
+    case GenericArgument:
+        func(node->genericArgument.type);
+        break;
+
+    case GenericArguments:
+        for (i = 0; i < node->genericArguments.count; i += 1)
+        {
+            func(node->genericArguments.arguments[i]);
+        }
+        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;
+
+    case Identifier:
+        return;
+
+    case IfStatement:
+        func(node->ifStatement.expression);
+        func(node->ifStatement.statementSequence);
+        return;
+
+    case IfElseStatement:
+        func(node->ifElseStatement.ifStatement);
+        func(node->ifElseStatement.elseStatement);
+        return;
+
+    case Number:
+        return;
+
+    case PrimitiveTypeNode:
+        return;
+
+    case ReferenceTypeNode:
+        func(node->referenceType.type);
+        return;
+
+    case Return:
+        func(node->returnStatement.expression);
+        return;
+
+    case ReturnVoid:
+        return;
+
+    case StatementSequence:
+        for (i = 0; i < node->statementSequence.count; i += 1)
+        {
+            func(node->statementSequence.sequence[i]);
+        }
+        return;
+
+    case StaticModifier:
+        return;
+
+    case StringLiteral:
+        return;
+
+    case StructDeclaration:
+        func(node->structDeclaration.identifier);
+        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:
+        func(node->unaryExpression.child);
+        return;
+
+    default:
+        fprintf(
+            stderr,
+            "wraith: Unhandled SyntaxKind %s in recurse function.\n",
+            SyntaxKindString(node->syntaxKind));
+        return;
+    }
+}
+
 TypeTag *MakeTypeTag(Node *node)
 {
+    uint32_t i;
+
     if (node == NULL)
     {
         fprintf(
@@ -683,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;
@@ -698,6 +1189,21 @@ TypeTag *MakeTypeTag(Node *node)
                               ->functionSignature.type);
         break;
 
+    case AllocExpression:
+        tag = MakeTypeTag(node->allocExpression.type);
+        break;
+
+    case GenericDeclaration:
+        tag->type = Generic;
+        tag->value.genericType =
+            strdup(node->genericDeclaration.identifier->identifier.name);
+        break;
+
+    case GenericTypeNode:
+        tag->type = Generic;
+        tag->value.genericType = strdup(node->genericType.name);
+        break;
+
     default:
         fprintf(
             stderr,
@@ -706,11 +1212,14 @@ TypeTag *MakeTypeTag(Node *node)
             SyntaxKindString(node->syntaxKind));
         return NULL;
     }
+
     return tag;
 }
 
 char *TypeTagToString(TypeTag *tag)
 {
+    uint32_t i;
+
     if (tag == NULL)
     {
         fprintf(
@@ -729,11 +1238,291 @@ 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:
-        return tag->value.customType;
+    {
+        char *result =
+            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.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;
+    }
+}
+
+void LinkParentPointers(Node *node, Node *prev)
+{
+    if (node == NULL)
+        return;
+
+    node->parent = prev;
+
+    uint32_t i;
+    switch (node->syntaxKind)
+    {
+    case AccessExpression:
+        LinkParentPointers(node->accessExpression.accessee, node);
+        LinkParentPointers(node->accessExpression.accessor, node);
+        return;
+
+    case AllocExpression:
+        LinkParentPointers(node->allocExpression.type, node);
+        return;
+
+    case Assignment:
+        LinkParentPointers(node->assignmentStatement.left, node);
+        LinkParentPointers(node->assignmentStatement.right, node);
+        return;
+
+    case BinaryExpression:
+        LinkParentPointers(node->binaryExpression.left, node);
+        LinkParentPointers(node->binaryExpression.right, node);
+        return;
+
+    case Comment:
+        return;
+
+    case CustomTypeNode:
+        return;
+
+    case Declaration:
+        LinkParentPointers(node->declaration.type, node);
+        LinkParentPointers(node->declaration.identifier, node);
+        return;
+
+    case DeclarationSequence:
+        for (i = 0; i < node->declarationSequence.count; i += 1)
+        {
+            LinkParentPointers(node->declarationSequence.sequence[i], node);
+        }
+        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);
+        LinkParentPointers(node->forLoop.endNumber, node);
+        LinkParentPointers(node->forLoop.statementSequence, node);
+        return;
+
+    case FunctionArgumentSequence:
+        for (i = 0; i < node->functionArgumentSequence.count; i += 1)
+        {
+            LinkParentPointers(
+                node->functionArgumentSequence.sequence[i],
+                node);
+        }
+        return;
+
+    case FunctionCallExpression:
+        LinkParentPointers(node->functionCallExpression.identifier, node);
+        LinkParentPointers(node->functionCallExpression.argumentSequence, node);
+        return;
+
+    case FunctionDeclaration:
+        LinkParentPointers(node->functionDeclaration.functionSignature, node);
+        LinkParentPointers(node->functionDeclaration.functionBody, node);
+        return;
+
+    case FunctionModifiers:
+        for (i = 0; i < node->functionModifiers.count; i += 1)
+        {
+            LinkParentPointers(node->functionModifiers.sequence[i], node);
+        }
+        return;
+
+    case FunctionSignature:
+        LinkParentPointers(node->functionSignature.identifier, node);
+        LinkParentPointers(node->functionSignature.type, node);
+        LinkParentPointers(node->functionSignature.arguments, node);
+        LinkParentPointers(node->functionSignature.modifiers, node);
+        LinkParentPointers(node->functionSignature.genericDeclarations, node);
+        return;
+
+    case FunctionSignatureArguments:
+        for (i = 0; i < node->functionSignatureArguments.count; i += 1)
+        {
+            LinkParentPointers(
+                node->functionSignatureArguments.sequence[i],
+                node);
+        }
+        return;
+
+    case GenericArgument:
+        LinkParentPointers(node->genericArgument.type, node);
+        return;
+
+    case GenericArguments:
+        for (i = 0; i < node->genericArguments.count; i += 1)
+        {
+            LinkParentPointers(node->genericArguments.arguments[i], node);
+        }
+        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;
+
+    case Identifier:
+        return;
+
+    case IfStatement:
+        LinkParentPointers(node->ifStatement.expression, node);
+        LinkParentPointers(node->ifStatement.statementSequence, node);
+        return;
+
+    case IfElseStatement:
+        LinkParentPointers(node->ifElseStatement.ifStatement, node);
+        LinkParentPointers(node->ifElseStatement.elseStatement, node);
+        return;
+
+    case Number:
+        return;
+
+    case PrimitiveTypeNode:
+        return;
+
+    case ReferenceTypeNode:
+        LinkParentPointers(node->referenceType.type, node);
+        return;
+
+    case Return:
+        LinkParentPointers(node->returnStatement.expression, node);
+        return;
+
+    case ReturnVoid:
+        return;
+
+    case StatementSequence:
+        for (i = 0; i < node->statementSequence.count; i += 1)
+        {
+            LinkParentPointers(node->statementSequence.sequence[i], node);
+        }
+        return;
+
+    case StaticModifier:
+        return;
+
+    case StringLiteral:
+        return;
+
+    case StructDeclaration:
+        LinkParentPointers(node->structDeclaration.identifier, node);
+        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;
+
+    case UnaryExpression:
+        LinkParentPointers(node->unaryExpression.child, node);
+        return;
+
+    default:
+        fprintf(
+            stderr,
+            "wraith: Unhandled SyntaxKind %s in recurse function.\n",
+            SyntaxKindString(node->syntaxKind));
+        return;
     }
 }

src/ast.h

@@ -1,7 +1,6 @@
 #ifndef WRAITH_AST_H
 #define WRAITH_AST_H
 
-#include "identcheck.h"
 #include <stdint.h>
 
 /* -Wpedantic nameless union/struct silencing */
@@ -20,9 +19,11 @@ typedef enum
     Assignment,
     BinaryExpression,
     Comment,
+    ConcreteGenericTypeNode,
     CustomTypeNode,
     Declaration,
     DeclarationSequence,
+    FieldInit,
     ForLoop,
     FunctionArgumentSequence,
     FunctionCallExpression,
@@ -30,6 +31,11 @@ typedef enum
     FunctionModifiers,
     FunctionSignature,
     FunctionSignatureArguments,
+    GenericArgument,
+    GenericArguments,
+    GenericDeclaration,
+    GenericDeclarations,
+    GenericTypeNode,
     Identifier,
     IfStatement,
     IfElseStatement,
@@ -42,6 +48,9 @@ typedef enum
     StaticModifier,
     StringLiteral,
     StructDeclaration,
+    StructInit,
+    StructInitFields,
+    SystemCall,
     Type,
     UnaryExpression
 } SyntaxKind;
@@ -71,7 +80,8 @@ typedef enum
     UInt,
     Float,
     Double,
-    String
+    String,
+    MemoryAddress
 } PrimitiveType;
 
 typedef union
@@ -80,14 +90,25 @@ 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
     {
         Unknown,
         Primitive,
         Reference,
-        Custom
+        Custom,
+        Generic,
+        ConcreteGeneric
     } type;
     union
     {
@@ -97,8 +118,12 @@ typedef struct TypeTag
         struct TypeTag *referenceType;
         /* Valid when type = Custom. */
         char *customType;
+        /* Valid when type = Generic. */
+        char *genericType;
+        /* Valid when type = ConcreteGeneric */
+        ConcreteGenericTypeTag concreteGenericType;
     } value;
-} TypeTag;
+};
 
 typedef struct Node Node;
 
@@ -137,6 +162,12 @@ struct Node
 
         } comment;
 
+        struct
+        {
+            char *name;
+            Node *genericArguments;
+        } concreteGenericType;
+
         struct
         {
             char *name;
@@ -154,6 +185,12 @@ struct Node
             uint32_t count;
         } declarationSequence;
 
+        struct
+        {
+            Node *identifier;
+            Node *expression;
+        } fieldInit;
+
         struct
         {
             Node *declaration;
@@ -172,6 +209,7 @@ struct Node
         {
             Node *identifier; /* FIXME: need better name */
             Node *argumentSequence;
+            Node *genericArguments;
         } functionCallExpression;
 
         struct
@@ -192,6 +230,7 @@ struct Node
             Node *type;
             Node *arguments;
             Node *modifiers;
+            Node *genericDeclarations;
         } functionSignature;
 
         struct
@@ -200,6 +239,34 @@ struct Node
             uint32_t count;
         } functionSignatureArguments;
 
+        struct
+        {
+            Node *type;
+        } genericArgument;
+
+        struct
+        {
+            Node **arguments;
+            uint32_t count;
+        } genericArguments;
+
+        struct
+        {
+            Node *identifier;
+            Node *constraint;
+        } genericDeclaration;
+
+        struct
+        {
+            Node **declarations;
+            uint32_t count;
+        } genericDeclarations;
+
+        struct
+        {
+            char *name;
+        } genericType;
+
         struct
         {
             char *name;
@@ -262,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;
@@ -276,15 +363,17 @@ struct Node
         } unaryExpression;
     };
     TypeTag *typeTag;
-    IdNode *idLink;
 };
 
 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);
@@ -306,13 +395,26 @@ Node *MakeFunctionSignatureNode(
     Node *identifierNode,
     Node *typeNode,
     Node *argumentsNode,
-    Node *modifiersNode);
+    Node *modifiersNode,
+    Node *genericArgumentsNode);
 Node *MakeFunctionDeclarationNode(
     Node *functionSignatureNode,
     Node *functionBodyNode);
+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);
@@ -320,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);
@@ -333,11 +440,28 @@ 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);
 
+/* Helper function for applying a void function generically over the children of
+ * an AST node. Used for functions that need to traverse the entire tree but
+ * only perform operations on a subset of node types. Such functions can match
+ * the syntaxKinds relevant to their purpose and invoke this function in all
+ * other cases. */
+void Recurse(Node *node, void (*func)(Node *));
+
+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);
 
 #endif /* WRAITH_AST_H */

src/identcheck.c

@@ -1,485 +0,0 @@
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "ast.h"
-#include "identcheck.h"
-
-IdNode *MakeIdNode(NodeType type, char *name, IdNode *parent)
-{
-    IdNode *node = (IdNode *)malloc(sizeof(IdNode));
-    node->type = type;
-    node->name = strdup(name);
-    node->parent = parent;
-    node->childCount = 0;
-    node->childCapacity = 0;
-    node->children = NULL;
-    node->typeTag = NULL;
-    return node;
-}
-
-void AddChildToNode(IdNode *node, IdNode *child)
-{
-    if (child == NULL)
-        return;
-
-    if (node->children == NULL)
-    {
-        node->childCapacity = 2;
-        node->children =
-            (IdNode **)malloc(sizeof(IdNode *) * node->childCapacity);
-    }
-    else if (node->childCount == node->childCapacity)
-    {
-        node->childCapacity *= 2;
-        node->children = (IdNode **)realloc(
-            node->children,
-            sizeof(IdNode *) * node->childCapacity);
-    }
-
-    node->children[node->childCount] = child;
-    node->childCount += 1;
-}
-
-IdNode *MakeIdTree(Node *astNode, IdNode *parent)
-{
-    uint32_t i;
-    IdNode *mainNode;
-    switch (astNode->syntaxKind)
-    {
-    case AccessExpression:
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->accessExpression.accessee, parent));
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->accessExpression.accessor, parent));
-        return NULL;
-
-    case AllocExpression:
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->allocExpression.type, parent));
-        return NULL;
-
-    case Assignment:
-    {
-        if (astNode->assignmentStatement.left->syntaxKind == Declaration)
-        {
-            return MakeIdTree(astNode->assignmentStatement.left, parent);
-        }
-        else
-        {
-            AddChildToNode(
-                parent,
-                MakeIdTree(astNode->assignmentStatement.left, parent));
-            AddChildToNode(
-                parent,
-                MakeIdTree(astNode->assignmentStatement.right, parent));
-            return NULL;
-        }
-    }
-
-    case BinaryExpression:
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->binaryExpression.left, parent));
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->binaryExpression.right, parent));
-        return NULL;
-
-    case Declaration:
-    {
-        Node *idNode = astNode->declaration.identifier;
-        mainNode = MakeIdNode(Variable, idNode->identifier.name, parent);
-        mainNode->typeTag = MakeTypeTag(astNode);
-        idNode->typeTag = mainNode->typeTag;
-        break;
-    }
-
-    case DeclarationSequence:
-    {
-        mainNode = MakeIdNode(UnorderedScope, "", parent);
-        for (i = 0; i < astNode->declarationSequence.count; i++)
-        {
-            AddChildToNode(
-                mainNode,
-                MakeIdTree(astNode->declarationSequence.sequence[i], mainNode));
-        }
-        break;
-    }
-
-    case ForLoop:
-    {
-        Node *loopDecl = astNode->forLoop.declaration;
-        Node *loopBody = astNode->forLoop.statementSequence;
-        mainNode = MakeIdNode(OrderedScope, "for-loop", parent);
-        AddChildToNode(mainNode, MakeIdTree(loopDecl, mainNode));
-        AddChildToNode(mainNode, MakeIdTree(loopBody, mainNode));
-        break;
-    }
-
-    case FunctionArgumentSequence:
-        for (i = 0; i < astNode->functionArgumentSequence.count; i++)
-        {
-            AddChildToNode(
-                parent,
-                MakeIdTree(
-                    astNode->functionArgumentSequence.sequence[i],
-                    parent));
-        }
-        return NULL;
-
-    case FunctionCallExpression:
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->functionCallExpression.identifier, parent));
-        AddChildToNode(
-            parent,
-            MakeIdTree(
-                astNode->functionCallExpression.argumentSequence,
-                parent));
-        return NULL;
-
-    case FunctionDeclaration:
-    {
-        Node *sigNode = astNode->functionDeclaration.functionSignature;
-        Node *idNode = sigNode->functionSignature.identifier;
-        char *funcName = idNode->identifier.name;
-        mainNode = MakeIdNode(Function, funcName, parent);
-        mainNode->typeTag = MakeTypeTag(astNode);
-        idNode->typeTag = mainNode->typeTag;
-        MakeIdTree(sigNode->functionSignature.arguments, mainNode);
-        MakeIdTree(astNode->functionDeclaration.functionBody, mainNode);
-        break;
-    }
-
-    case FunctionSignatureArguments:
-    {
-        for (i = 0; i < astNode->functionSignatureArguments.count; i++)
-        {
-            Node *argNode = astNode->functionSignatureArguments.sequence[i];
-            AddChildToNode(parent, MakeIdTree(argNode, parent));
-        }
-        return NULL;
-    }
-
-    case Identifier:
-    {
-        char *name = astNode->identifier.name;
-        mainNode = MakeIdNode(Placeholder, name, parent);
-        IdNode *lookupNode = LookupId(mainNode, NULL, name);
-        if (lookupNode == NULL)
-        {
-            fprintf(stderr, "wraith: Could not find IdNode for id %s\n", name);
-            TypeTag *tag = (TypeTag *)malloc(sizeof(TypeTag));
-            tag->type = Unknown;
-            astNode->typeTag = tag;
-        }
-        else
-        {
-            astNode->typeTag = lookupNode->typeTag;
-        }
-        break;
-    }
-
-    case IfStatement:
-    {
-        Node *clause = astNode->ifStatement.expression;
-        Node *stmtSeq = astNode->ifStatement.statementSequence;
-        mainNode = MakeIdNode(OrderedScope, "if", parent);
-        MakeIdTree(clause, mainNode);
-        MakeIdTree(stmtSeq, mainNode);
-        break;
-    }
-
-    case IfElseStatement:
-    {
-        Node *ifNode = astNode->ifElseStatement.ifStatement;
-        Node *elseStmts = astNode->ifElseStatement.elseStatement;
-        mainNode = MakeIdNode(OrderedScope, "if-else", parent);
-        IdNode *ifBranch = MakeIdTree(ifNode, mainNode);
-        AddChildToNode(mainNode, ifBranch);
-        IdNode *elseScope = MakeIdNode(OrderedScope, "else", mainNode);
-        MakeIdTree(elseStmts, elseScope);
-        AddChildToNode(mainNode, elseScope);
-        break;
-    }
-
-    case ReferenceTypeNode:
-        AddChildToNode(parent, MakeIdTree(astNode->referenceType.type, parent));
-        return NULL;
-
-    case Return:
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->returnStatement.expression, parent));
-        return NULL;
-
-    case StatementSequence:
-    {
-        for (i = 0; i < astNode->statementSequence.count; i++)
-        {
-            Node *argNode = astNode->statementSequence.sequence[i];
-            AddChildToNode(parent, MakeIdTree(argNode, parent));
-        }
-        return NULL;
-    }
-
-    case StructDeclaration:
-    {
-        Node *idNode = astNode->structDeclaration.identifier;
-        Node *declsNode = astNode->structDeclaration.declarationSequence;
-        mainNode = MakeIdNode(Struct, idNode->identifier.name, parent);
-        mainNode->typeTag = MakeTypeTag(astNode);
-        for (i = 0; i < declsNode->declarationSequence.count; i++)
-        {
-            Node *decl = declsNode->declarationSequence.sequence[i];
-            AddChildToNode(mainNode, MakeIdTree(decl, mainNode));
-        }
-        break;
-    }
-
-    case Type:
-        AddChildToNode(parent, MakeIdTree(astNode->type.typeNode, parent));
-        return NULL;
-
-    case UnaryExpression:
-        AddChildToNode(
-            parent,
-            MakeIdTree(astNode->unaryExpression.child, parent));
-        return NULL;
-
-    case Comment:
-    case CustomTypeNode:
-    case FunctionModifiers:
-    case FunctionSignature:
-    case Number:
-    case PrimitiveTypeNode:
-    case ReturnVoid:
-    case StaticModifier:
-    case StringLiteral:
-        return NULL;
-    }
-
-    astNode->idLink = mainNode;
-    return mainNode;
-}
-
-void PrintIdNode(IdNode *node)
-{
-    if (node == NULL)
-    {
-        fprintf(
-            stderr,
-            "wraith: Attempted to call PrintIdNode with null value.\n");
-        return;
-    }
-
-    switch (node->type)
-    {
-    case Placeholder:
-        printf("Placeholder (%s)\n", node->name);
-        break;
-    case OrderedScope:
-        printf("OrderedScope (%s)\n", node->name);
-        break;
-    case UnorderedScope:
-        printf("UnorderedScope (%s)\n", node->name);
-        break;
-    case Struct:
-        printf("%s : %s\n", node->name, TypeTagToString(node->typeTag));
-        break;
-    case Function:
-        printf(
-            "%s : Function<%s>\n",
-            node->name,
-            TypeTagToString(node->typeTag));
-        break;
-    case Variable:
-        printf("%s : %s\n", node->name, TypeTagToString(node->typeTag));
-        break;
-    }
-}
-
-void PrintIdTree(IdNode *tree, uint32_t tabCount)
-{
-    if (tree == NULL)
-    {
-        fprintf(
-            stderr,
-            "wraith: Attempted to call PrintIdTree on a null value.\n");
-        return;
-    }
-
-    uint32_t i;
-    for (i = 0; i < tabCount; i++)
-    {
-        printf("| ");
-    }
-
-    PrintIdNode(tree);
-
-    for (i = 0; i < tree->childCount; i++)
-    {
-        PrintIdTree(tree->children[i], tabCount + 1);
-    }
-}
-
-int PrintAncestors(IdNode *node)
-{
-    if (node == NULL)
-        return -1;
-
-    int i;
-    int indent = 1;
-    indent += PrintAncestors(node->parent);
-    for (i = 0; i < indent; i++)
-    {
-        printf(" ");
-    }
-    PrintIdNode(node);
-    return indent;
-}
-
-IdNode *LookdownId(IdNode *root, NodeType targetType, char *targetName)
-{
-    if (root == NULL)
-    {
-        fprintf(
-            stderr,
-            "wraith: Attempted to call LookdownId on a null value.\n");
-        return NULL;
-    }
-
-    IdNode *result = NULL;
-    IdNode **frontier = (IdNode **)malloc(sizeof(IdNode *));
-    frontier[0] = root;
-    uint32_t frontierCount = 1;
-
-    while (frontierCount > 0)
-    {
-        IdNode *current = frontier[0];
-
-        if (current->type == targetType &&
-            strcmp(current->name, targetName) == 0)
-        {
-            result = current;
-            break;
-        }
-
-        uint32_t i;
-        for (i = 1; i < frontierCount; i++)
-        {
-            frontier[i - 1] = frontier[i];
-        }
-        size_t newSize = frontierCount + current->childCount - 1;
-        if (frontierCount != newSize)
-        {
-            frontier = (IdNode **)realloc(frontier, sizeof(IdNode *) * newSize);
-        }
-        for (i = 0; i < current->childCount; i++)
-        {
-            frontier[frontierCount + i - 1] = current->children[i];
-        }
-        frontierCount = newSize;
-    }
-
-    free(frontier);
-    return result;
-}
-
-bool ScopeHasOrdering(IdNode *node)
-{
-    switch (node->type)
-    {
-    case OrderedScope:
-    case Function:
-    case Variable: /* this is only technically true */
-        return true;
-    default:
-        return false;
-    }
-}
-
-IdNode *LookupId(IdNode *node, IdNode *prev, char *target)
-{
-    if (node == NULL)
-    {
-        return NULL;
-    }
-
-    if (strcmp(node->name, target) == 0 && node->type != Placeholder)
-    {
-        return node;
-    }
-
-    /* If this is the start of our search, we should not attempt to look at
-     * child nodes. Only looking up the scope tree is valid at this point.
-     *
-     * This has the notable side-effect that this function will return NULL if
-     * you attempt to look up a struct's internals starting from the node
-     * representing the struct itself. This is because an IdNode corresponds to
-     * the location *where an identifier is first declared.* Thus, an identifier
-     * has no knowledge of identifiers declared "inside" of it.
-     */
-    if (prev == NULL)
-    {
-        return LookupId(node->parent, node, target);
-    }
-
-    /* If the current node forms an ordered scope then we want to prevent
-     * ourselves from looking up identifiers declared after the scope we have
-     * just come from.
-     */
-    uint32_t idxLimit;
-    if (ScopeHasOrdering(node))
-    {
-        uint32_t i;
-        for (i = 0, idxLimit = 0; i < node->childCount; i++, idxLimit++)
-        {
-            if (node->children[i] == prev)
-            {
-                break;
-            }
-        }
-    }
-    else
-    {
-        idxLimit = node->childCount;
-    }
-
-    uint32_t i;
-    for (i = 0; i < idxLimit; i++)
-    {
-        IdNode *child = node->children[i];
-        if (child == prev || child->type == Placeholder)
-        {
-            /* Do not inspect the node we just came from or placeholders. */
-            continue;
-        }
-
-        if (strcmp(child->name, target) == 0)
-        {
-            return child;
-        }
-
-        if (child->type == Struct)
-        {
-            uint32_t j;
-            for (j = 0; j < child->childCount; j++)
-            {
-                IdNode *grandchild = child->children[j];
-                if (strcmp(grandchild->name, target) == 0)
-                {
-                    return grandchild;
-                }
-            }
-        }
-    }
-
-    return LookupId(node->parent, node, target);
-}

src/identcheck.h

@@ -1,49 +0,0 @@
-/* Validates identifier usage in an AST. */
-
-#ifndef WRAITH_IDENTCHECK_H
-#define WRAITH_IDENTCHECK_H
-
-#include <stdint.h>
-
-#include "ast.h"
-
-struct TypeTag;
-struct Node;
-
-typedef enum NodeType
-{
-    Placeholder,
-    UnorderedScope,
-    OrderedScope,
-    Struct,
-    Function,
-    Variable
-} NodeType;
-
-typedef struct IdNode
-{
-    NodeType type;
-    char *name;
-    struct TypeTag *typeTag;
-    struct IdNode *parent;
-    struct IdNode **children;
-    uint32_t childCount;
-    uint32_t childCapacity;
-} IdNode;
-
-typedef struct IdStatus
-{
-    enum StatusCode
-    {
-        Valid,
-    } StatusCode;
-} IdStatus;
-
-IdNode *MakeIdTree(struct Node *astNode, IdNode *parent);
-void PrintIdNode(IdNode *node);
-void PrintIdTree(IdNode *tree, uint32_t tabCount);
-int PrintAncestors(IdNode *node);
-IdNode *LookdownId(IdNode *root, NodeType targetType, char *targetName);
-IdNode *LookupId(IdNode *node, IdNode *prev, char *target);
-
-#endif /* WRAITH_IDENTCHECK_H */

src/main.c

@@ -2,8 +2,8 @@
 #include <stdlib.h>
 
 #include "codegen.h"
-#include "identcheck.h"
 #include "parser.h"
+#include "validation.h"
 
 int main(int argc, char *argv[])
 {
@@ -85,12 +85,15 @@ int main(int argc, char *argv[])
                 }
                 else
                 {
-                    {
+                    LinkParentPointers(rootNode, NULL);
-                        IdNode *idTree = MakeIdTree(rootNode, NULL);
+                    /* FIXME: ValidateIdentifiers should return some sort of
-                        PrintIdTree(idTree, /*tabCount=*/0);
+                              error status object. */
-                        printf("\n");
+                    ValidateIdentifiers(rootNode);
-                        PrintNode(rootNode, /*tabCount=*/0);
+                    TagIdentifierTypes(rootNode);
-                    }
+                    ConvertCustomsToGenerics(rootNode);
+                    PrintNode(rootNode, 0);
+
+                    printf("Beginning codegen.\n");
                     exitCode = Codegen(rootNode, optimizationLevel);
                 }
             }

src/util.c

@@ -1,12 +1,11 @@
 #include "util.h"
 
 #include <stdlib.h>
-#include <string.h>
 
 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,3 +14,25 @@ char *strdup(const char *s)
     memcpy(result, s, slen + 1);
     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;
+    size_t c;
+
+    while ((c = *str++))
+    {
+        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+    }
+
+    return hash;
+}

src/util.h

@@ -1,8 +1,11 @@
 #ifndef WRAITH_UTIL_H
 #define WRAITH_UTIL_H
 
+#include <stdint.h>
 #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

@@ -0,0 +1,493 @@
+#include "validation.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+Node *GetIdFromStruct(Node *structDecl)
+{
+    if (structDecl->syntaxKind != StructDeclaration)
+    {
+        fprintf(
+            stderr,
+            "wraith: Attempted to call GetIdFromStruct on node with kind: "
+            "%s.\n",
+            SyntaxKindString(structDecl->syntaxKind));
+        return NULL;
+    }
+
+    return structDecl->structDeclaration.identifier;
+}
+
+Node *GetIdFromFunction(Node *funcDecl)
+{
+    if (funcDecl->syntaxKind != FunctionDeclaration)
+    {
+        fprintf(
+            stderr,
+            "wraith: Attempted to call GetIdFromFunction on node with kind: "
+            "%s.\n",
+            SyntaxKindString(funcDecl->syntaxKind));
+        return NULL;
+    }
+
+    Node *sig = funcDecl->functionDeclaration.functionSignature;
+    return sig->functionSignature.identifier;
+}
+
+Node *GetIdFromDeclaration(Node *decl)
+{
+    if (decl->syntaxKind != Declaration)
+    {
+        fprintf(
+            stderr,
+            "wraith: Attempted to call GetIdFromDeclaration on node with kind: "
+            "%s.\n",
+            SyntaxKindString(decl->syntaxKind));
+    }
+
+    return decl->declaration.identifier;
+}
+
+bool AssignmentHasDeclaration(Node *assign)
+{
+    return (
+        assign->syntaxKind == Assignment &&
+        assign->assignmentStatement.left->syntaxKind == Declaration);
+}
+
+Node *GetIdFromAssignment(Node *assign)
+{
+    if (assign->syntaxKind != Assignment)
+    {
+        fprintf(
+            stderr,
+            "wraith: Attempted to call GetIdFromAssignment on node with kind: "
+            "%s.\n",
+            SyntaxKindString(assign->syntaxKind));
+    }
+
+    if (AssignmentHasDeclaration(assign))
+    {
+        return GetIdFromDeclaration(assign->assignmentStatement.left);
+    }
+
+    return NULL;
+}
+
+bool NodeMayHaveId(Node *node)
+{
+    switch (node->syntaxKind)
+    {
+    case StructDeclaration:
+    case FunctionDeclaration:
+    case Declaration:
+    case Assignment:
+        return true;
+    default:
+        return false;
+    }
+}
+
+Node *TryGetId(Node *node)
+{
+    switch (node->syntaxKind)
+    {
+    case Assignment:
+        return GetIdFromAssignment(node);
+    case Declaration:
+        return GetIdFromDeclaration(node);
+    case FunctionDeclaration:
+        return GetIdFromFunction(node);
+    case StructDeclaration:
+        return GetIdFromStruct(node);
+    default:
+        return NULL;
+    }
+}
+
+Node *LookupFunctionArgId(Node *funcDecl, char *target)
+{
+    Node *args = funcDecl->functionDeclaration.functionSignature
+                     ->functionSignature.arguments;
+
+    uint32_t i;
+    for (i = 0; i < args->functionArgumentSequence.count; i += 1)
+    {
+        Node *arg = args->functionArgumentSequence.sequence[i];
+        if (arg->syntaxKind != Declaration)
+        {
+            fprintf(
+                stderr,
+                "wraith: Encountered %s node in function signature args "
+                "list.\n",
+                SyntaxKindString(arg->syntaxKind));
+            continue;
+        }
+
+        Node *argId = GetIdFromDeclaration(arg);
+        if (argId != NULL && strcmp(target, argId->identifier.name) == 0)
+            return argId;
+    }
+
+    return NULL;
+}
+
+Node *LookupStructInternalId(Node *structDecl, char *target)
+{
+    Node *decls = structDecl->structDeclaration.declarationSequence;
+
+    uint32_t i;
+    for (i = 0; i < decls->declarationSequence.count; i += 1)
+    {
+        Node *match = TryGetId(decls->declarationSequence.sequence[i]);
+        if (match != NULL && strcmp(target, match->identifier.name) == 0)
+            return match;
+    }
+
+    return NULL;
+}
+
+Node *InspectNode(Node *node, char *target)
+{
+    /* If this node may have an identifier declaration inside it, attempt to
+     * look up the identifier
+     * node itself, returning it if it matches the given target name. */
+    if (NodeMayHaveId(node))
+    {
+        Node *candidateId = TryGetId(node);
+        if (candidateId != NULL &&
+            strcmp(target, candidateId->identifier.name) == 0)
+            return candidateId;
+    }
+
+    /* If the candidate node was not the one we wanted, but the node node is a
+     * function declaration, it's possible that the identifier we want is one of
+     * the function's parameters rather than the function's name itself. */
+    if (node->syntaxKind == FunctionDeclaration)
+    {
+        Node *match = LookupFunctionArgId(node, target);
+        if (match != NULL)
+            return match;
+    }
+
+    /* Likewise if the node node is a struct declaration, inspect the struct's
+     * internals
+     * to see if a top-level definition is the one we're looking for. */
+    if (node->syntaxKind == StructDeclaration)
+    {
+        Node *match = LookupStructInternalId(node, target);
+        if (match != NULL)
+            return match;
+    }
+
+    return NULL;
+}
+
+/* FIXME: Handle staged lookups for AccessExpressions. */
+/* FIXME: Similar to above, disallow inspection of struct internals outside of
+ *        AccessExpressions. */
+Node *LookupId(Node *current, Node *prev, char *target)
+{
+    if (current == NULL)
+        return NULL;
+
+    Node *match;
+
+    /* First inspect the current node to see if it contains the target
+     * identifier. */
+    match = InspectNode(current, target);
+    if (match != NULL)
+        return match;
+
+    /* If this is the start of our search, we should not attempt to look at
+     * child nodes. Only looking up the AST is valid at this point.
+     *
+     * This has the notable side-effect that this function will return NULL if
+     * you attempt to look up a struct's internals starting from the node
+     * representing the struct itself. The same is true for functions. */
+    if (prev == NULL)
+        return LookupId(current->parent, current, target);
+
+    uint32_t i;
+    uint32_t idxLimit;
+    switch (current->syntaxKind)
+    {
+    case DeclarationSequence:
+        for (i = 0; i < current->declarationSequence.count; i += 1)
+        {
+            Node *decl = current->declarationSequence.sequence[i];
+            match = InspectNode(decl, target);
+            if (match != NULL)
+                return match;
+        }
+        break;
+    case StatementSequence:
+        idxLimit = current->statementSequence.count;
+        for (i = 0; i < current->statementSequence.count; i += 1)
+        {
+            if (current->statementSequence.sequence[i] == prev)
+            {
+                idxLimit = i;
+                break;
+            }
+        }
+
+        for (i = 0; i < idxLimit; i += 1)
+        {
+            Node *stmt = current->statementSequence.sequence[i];
+            if (stmt == prev)
+                break;
+
+            match = InspectNode(stmt, target);
+            if (match != NULL)
+                return match;
+        }
+        break;
+    }
+
+    return LookupId(current->parent, current, target);
+}
+
+/* FIXME: This function should be extended to handle multi-stage ID lookups for
+ *        AccessExpression nodes. */
+/* FIXME: Make this function return an error status object of some kind.
+ *        A non-OK status should halt compilation. */
+void ValidateIdentifiers(Node *node)
+{
+    if (node == NULL)
+        return;
+
+    /* Skip over generic arguments. They contain Identifiers but are not
+     * actually identifiers, they declare types. */
+    if (node->syntaxKind == GenericDeclarations)
+        return;
+
+    if (node->syntaxKind != Identifier)
+    {
+        Recurse(node, *ValidateIdentifiers);
+        return;
+    }
+
+    char *name = node->identifier.name;
+    Node *decl = LookupId(node, NULL, name);
+    if (decl == NULL)
+    {
+        /* FIXME: Express this case as an error with AST information, see the
+         *        FIXME comment above. */
+        fprintf(
+            stderr,
+            "wraith: Could not find definition of identifier %s.\n",
+            name);
+    }
+}
+
+/* FIXME: This function should be extended to handle multi-stage ID lookups for
+ *        AccessExpression nodes. */
+void TagIdentifierTypes(Node *node)
+{
+    if (node == NULL)
+        return;
+
+    switch (node->syntaxKind)
+    {
+    case AllocExpression:
+        node->typeTag = MakeTypeTag(node);
+        break;
+
+    case Declaration:
+        node->declaration.identifier->typeTag = MakeTypeTag(node);
+        break;
+
+    case FunctionDeclaration:
+        node->functionDeclaration.functionSignature->functionSignature
+            .identifier->typeTag = MakeTypeTag(node);
+        break;
+
+    case StructDeclaration:
+        node->structDeclaration.identifier->typeTag = MakeTypeTag(node);
+        break;
+
+    case GenericDeclaration:
+        node->genericDeclaration.identifier->typeTag = MakeTypeTag(node);
+        break;
+
+    case Type:
+        node->typeTag = MakeTypeTag(node);
+        break;
+
+    case Identifier:
+    {
+        if (node->typeTag != NULL)
+            return;
+
+        char *name = node->identifier.name;
+        Node *declaration = LookupId(node, NULL, name);
+        /* FIXME: Remove this case once ValidateIdentifiers returns error status
+         * info and halts compilation. See ValidateIdentifiers FIXME. */
+        if (declaration == NULL)
+        {
+            TypeTag *tag = (TypeTag *)malloc(sizeof(TypeTag));
+            tag->type = Unknown;
+            node->typeTag = tag;
+        }
+        else
+        {
+            node->typeTag = declaration->typeTag;
+        }
+        break;
+    }
+    }
+
+    Recurse(node, *TagIdentifierTypes);
+}
+
+Node *LookupType(Node *current, char *target)
+{
+    if (current == NULL)
+        return NULL;
+
+    switch (current->syntaxKind)
+    {
+    /* If we've encountered a function declaration, check to see if it's generic
+     * and, if so, if one of its type parameters is the target. */
+    case FunctionDeclaration:
+    {
+        Node *typeArgs = current->functionDeclaration.functionSignature
+                             ->functionSignature.genericDeclarations;
+        uint32_t i;
+        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;
+            }
+        }
+
+        return LookupType(current->parent, 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);
+    }
+
+    /* If we encounter a declaration sequence, search each of its children for
+     * struct definitions in case one of them is the target. */
+    case DeclarationSequence:
+    {
+        uint32_t i;
+        for (i = 0; i < current->declarationSequence.count; i += 1)
+        {
+            Node *decl = current->declarationSequence.sequence[i];
+            if (decl->syntaxKind == StructDeclaration)
+            {
+                Node *structId = GetIdFromStruct(decl);
+                if (strcmp(target, structId->identifier.name) == 0)
+                    return structId;
+            }
+        }
+
+        return LookupType(current->parent, target);
+    }
+
+    default:
+        return LookupType(current->parent, target);
+    }
+}
+
+/* FIXME: This function should be modified to handle type parameters over
+ * structs. */
+void ConvertCustomsToGenerics(Node *node)
+{
+    if (node == NULL)
+        return;
+
+    switch (node->syntaxKind)
+    {
+    case Declaration:
+    {
+        Node *id = node->declaration.identifier;
+        Node *type = node->declaration.type->type.typeNode;
+        if (type->syntaxKind == CustomTypeNode)
+        {
+            char *target = id->typeTag->value.customType;
+            Node *typeLookup = LookupType(node, target);
+            if (typeLookup != NULL &&
+                typeLookup->syntaxKind == GenericDeclaration)
+            {
+                id->typeTag->type = Generic;
+                free(node->declaration.type);
+                node->declaration.type =
+                    MakeGenericTypeNode(id->typeTag->value.genericType);
+            }
+        }
+        break;
+    }
+
+    case FunctionSignature:
+    {
+        Node *id = node->functionSignature.identifier;
+        Node *type = node->functionSignature.type->type.typeNode;
+        if (type->syntaxKind == CustomTypeNode)
+        {
+            char *target = id->typeTag->value.customType;
+            Node *typeLookup = LookupType(node, target);
+            if (typeLookup != NULL &&
+                typeLookup->syntaxKind == GenericDeclaration)
+            {
+                id->typeTag->type = Generic;
+                free(node->functionSignature.type);
+                node->functionSignature.type =
+                    MakeGenericTypeNode(id->typeTag->value.genericType);
+            }
+        }
+        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);
+}

src/validation.h

@@ -0,0 +1,10 @@
+#ifndef WRAITH_VALIDATION_H
+#define WRAITH_VALIDATION_H
+
+#include "ast.h"
+
+void ValidateIdentifiers(Node *node);
+void TagIdentifierTypes(Node *node);
+void ConvertCustomsToGenerics(Node *node);
+
+#endif /* WRAITH_VALIDATION_H */