Generics (#7)

Co-authored-by: venko <alexmflores@gmail.com>
Reviewed-on: #7
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.y

@@ -307,14 +307,38 @@ Body                    : LEFT_BRACE Statements RIGHT_BRACE
                             $$ = $2;
                         }
 
-FunctionSignature       : Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+GenericArgument         : Identifier
                         {
-                            $$ = MakeFunctionSignatureNode($1, $6, $3, MakeFunctionModifiersNode(NULL, 0));
+                            $$ = MakeGenericArgumentNode($1, NULL);
                         }
-                        | STATIC Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+
+GenericArguments        : GenericArgument
+                        {
+                            $$ = StartGenericArgumentsNode($1);
+                        }
+                        | GenericArguments COMMA GenericArgument
+                        {
+                            $$ = AddGenericArgument($1, $3);
+                        }
+
+GenericArgumentsClause  : LESS_THAN GenericArguments GREATER_THAN
+                        {
+                            $$ = $2;
+                        }
+                        |
+                        {
+                            $$ = MakeEmptyGenericArgumentsNode();
+                        }
+
+
+FunctionSignature       : Identifier GenericArgumentsClause 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
                         {
                             Node *modifier = MakeStaticNode();
-                            $$ = MakeFunctionSignatureNode($2, $7, $4, MakeFunctionModifiersNode(&modifier, 1));
+                            $$ = MakeFunctionSignatureNode($2, $8, $5, MakeFunctionModifiersNode(&modifier, 1), $3);
                         }
 
 FunctionDeclaration     : FunctionSignature Body

generic.w

@@ -0,0 +1,18 @@
+struct Foo {
+    static Func2<U>(u: U) : U {
+        return u;
+    }
+
+    static Func<T>(t: T): T {
+        foo: T = t;
+        return Foo.Func2(foo);
+    }
+}
+
+struct Program {
+    static Main(): int {
+        x: int = 4;
+        y: int = Foo.Func(x);
+        return x;
+    }
+}

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

@@ -39,6 +39,12 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "FunctionSignature";
     case FunctionSignatureArguments:
         return "FunctionSignatureArguments";
+    case GenericArgument:
+        return "GenericArgument";
+    case GenericArguments:
+        return "GenericArguments";
+    case GenericTypeNode:
+        return "GenericTypeNode";
     case Identifier:
         return "Identifier";
     case IfStatement:
@@ -271,7 +277,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 +286,7 @@ Node *MakeFunctionSignatureNode(
     node->functionSignature.type = typeNode;
     node->functionSignature.arguments = arguments;
     node->functionSignature.modifiers = modifiersNode;
+    node->functionSignature.genericArguments = genericArgumentsNode;
     return node;
 }
 
@@ -359,6 +367,54 @@ Node *MakeEmptyFunctionArgumentSequenceNode()
     return node;
 }
 
+Node *MakeGenericArgumentNode(Node *identifierNode, Node *constraintNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = GenericArgument;
+    node->genericArgument.identifier = identifierNode;
+    node->genericArgument.constraint = constraintNode;
+    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 = (Node **)realloc(
+        genericArgumentsNode->genericArguments.arguments,
+        sizeof(Node *) * (genericArgumentsNode->genericArguments.count + 1));
+    genericArgumentsNode->genericArguments
+        .arguments[genericArgumentsNode->genericArguments.count] =
+        genericArgumentNode;
+    genericArgumentsNode->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)
@@ -557,6 +613,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.arguments, tabCount + 1);
         PrintNode(node->functionSignature.type, tabCount + 1);
         PrintNode(node->functionSignature.modifiers, tabCount + 1);
@@ -572,6 +629,25 @@ void PrintNode(Node *node, uint32_t tabCount)
         }
         return;
 
+    case GenericArgument:
+        printf("\n");
+        PrintNode(node->genericArgument.identifier, tabCount + 1);
+        /* Constraint nodes are not implemented. */
+        /* PrintNode(node->genericArgument.constraint, 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 GenericTypeNode:
+        printf("%s\n", node->genericType.name);
+        return;
+
     case Identifier:
         if (node->typeTag == NULL)
         {
@@ -630,7 +706,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:
@@ -651,6 +727,173 @@ 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 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 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);
+        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.genericArguments);
+        return;
+
+    case FunctionSignatureArguments:
+        for (i = 0; i < node->functionSignatureArguments.count; i += 1)
+        {
+            func(node->functionSignatureArguments.sequence[i]);
+        }
+        return;
+
+    case GenericArgument:
+        func(node->genericArgument.identifier);
+        func(node->genericArgument.constraint);
+        return;
+
+    case GenericArguments:
+        for (i = 0; i < node->genericArguments.count; i += 1)
+        {
+            func(node->genericArguments.arguments[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 Type:
+        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)
 {
     if (node == NULL)
@@ -698,6 +941,21 @@ TypeTag *MakeTypeTag(Node *node)
                               ->functionSignature.type);
         break;
 
+    case AllocExpression:
+        tag = MakeTypeTag(node->allocExpression.type);
+        break;
+
+    case GenericArgument:
+        tag->type = Generic;
+        tag->value.genericType =
+            strdup(node->genericArgument.identifier->identifier.name);
+        break;
+
+    case GenericTypeNode:
+        tag->type = Generic;
+        tag->value.genericType = strdup(node->genericType.name);
+        break;
+
     default:
         fprintf(
             stderr,
@@ -706,6 +964,7 @@ TypeTag *MakeTypeTag(Node *node)
             SyntaxKindString(node->syntaxKind));
         return NULL;
     }
+
     return tag;
 }
 
@@ -729,11 +988,199 @@ 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;
+    }
+    }
+}
+
+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 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.genericArguments, 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.identifier, node);
+        LinkParentPointers(node->genericArgument.constraint, node);
+        return;
+
+    case GenericArguments:
+        for (i = 0; i < node->genericArguments.count; i += 1)
+        {
+            LinkParentPointers(node->genericArguments.arguments[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 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 */
@@ -30,6 +29,9 @@ typedef enum
     FunctionModifiers,
     FunctionSignature,
     FunctionSignatureArguments,
+    GenericArgument,
+    GenericArguments,
+    GenericTypeNode,
     Identifier,
     IfStatement,
     IfElseStatement,
@@ -87,7 +89,8 @@ typedef struct TypeTag
         Unknown,
         Primitive,
         Reference,
-        Custom
+        Custom,
+        Generic
     } type;
     union
     {
@@ -97,6 +100,8 @@ typedef struct TypeTag
         struct TypeTag *referenceType;
         /* Valid when type = Custom. */
         char *customType;
+        /* Valid when type = Generic. */
+        char *genericType;
     } value;
 } TypeTag;
 
@@ -192,6 +197,7 @@ struct Node
             Node *type;
             Node *arguments;
             Node *modifiers;
+            Node *genericArguments;
         } functionSignature;
 
         struct
@@ -200,6 +206,23 @@ struct Node
             uint32_t count;
         } functionSignatureArguments;
 
+        struct
+        {
+            Node *identifier;
+            Node *constraint;
+        } genericArgument;
+
+        struct
+        {
+            Node **arguments;
+            uint32_t count;
+        } genericArguments;
+
+        struct
+        {
+            char *name;
+        } genericType;
+
         struct
         {
             char *name;
@@ -276,7 +299,6 @@ struct Node
         } unaryExpression;
     };
     TypeTag *typeTag;
-    IdNode *idLink;
 };
 
 const char *SyntaxKindString(SyntaxKind syntaxKind);
@@ -306,10 +328,16 @@ Node *MakeFunctionSignatureNode(
     Node *identifierNode,
     Node *typeNode,
     Node *argumentsNode,
-    Node *modifiersNode);
+    Node *modifiersNode,
+    Node *genericArgumentsNode);
 Node *MakeFunctionDeclarationNode(
     Node *functionSignatureNode,
     Node *functionBodyNode);
+Node *MakeGenericArgumentNode(Node *identifierNode, Node *constraintNode);
+Node *MakeEmptyGenericArgumentsNode();
+Node *StartGenericArgumentsNode(Node *genericArgumentNode);
+Node *AddGenericArgument(Node *genericArgumentsNode, Node *genericArgumentNode);
+Node *MakeGenericTypeNode(char *name);
 Node *MakeStructDeclarationNode(
     Node *identifierNode,
     Node *declarationSequenceNode);
@@ -337,7 +365,18 @@ Node *MakeForLoopNode(
 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);
 
+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,7 +1,6 @@
 #include "util.h"
 
 #include <stdlib.h>
-#include <string.h>
 
 char *strdup(const char *s)
 {
@@ -15,3 +14,16 @@ char *strdup(const char *s)
     memcpy(result, s, slen + 1);
     return result;
 }
+
+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,10 @@
 #ifndef WRAITH_UTIL_H
 #define WRAITH_UTIL_H
 
+#include <stdint.h>
 #include <string.h>
 
 char *strdup(const char *s);
+uint64_t str_hash(char *str);
 
 #endif /* WRAITH_UTIL_H */

src/validation.c

@@ -0,0 +1,452 @@
+#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 == GenericArguments)
+        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 GenericArgument:
+        node->genericArgument.identifier->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.genericArguments;
+        uint32_t i;
+        for (i = 0; i < typeArgs->genericArguments.count; i += 1)
+        {
+            Node *arg = typeArgs->genericArguments.arguments[i];
+            Node *argId = arg->genericArgument.identifier;
+            char *argName = argId->identifier.name;
+            /* note: return the GenericArgument, 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:
+    {
+        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 == GenericArgument)
+            {
+                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 == GenericArgument)
+            {
+                id->typeTag->type = Generic;
+                free(node->functionSignature.type);
+                node->functionSignature.type =
+                    MakeGenericTypeNode(id->typeTag->value.genericType);
+            }
+        }
+        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 */