CMakeLists.txt

@@ -41,15 +41,13 @@ add_executable(
 	# Source
 	src/ast.h
 	src/codegen.h
-	src/identcheck.h
 	src/parser.h
-	src/typeutils.h
+	src/validation.h
 	src/util.h
     src/ast.c
 	src/codegen.c
-	src/identcheck.c
 	src/parser.c
-	src/typeutils.c
+	src/validation.c
 	src/util.c
 	src/main.c
 	# Generated code

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;
+    }
+}

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

@@ -638,7 +638,8 @@ void PrintNode(Node *node, uint32_t tabCount)
 
     case GenericArguments:
         printf("\n");
-        for (i = 0; i < node->genericArguments.count; i += 1) {
+        for (i = 0; i < node->genericArguments.count; i += 1)
+        {
             PrintNode(node->genericArguments.arguments[i], tabCount + 1);
         }
         return;
@@ -705,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:
@@ -726,7 +727,7 @@ void PrintNode(Node *node, uint32_t tabCount)
     }
 }
 
-void Recurse(Node *node, void (*func)(Node*))
+void Recurse(Node *node, void (*func)(Node *))
 {
     uint32_t i;
     switch (node->syntaxKind)
@@ -762,7 +763,8 @@ void Recurse(Node *node, void (*func)(Node*))
         return;
 
     case DeclarationSequence:
-        for (i = 0; i < node->declarationSequence.count; i += 1) {
+        for (i = 0; i < node->declarationSequence.count; i += 1)
+        {
             func(node->declarationSequence.sequence[i]);
         }
         return;
@@ -775,7 +777,8 @@ void Recurse(Node *node, void (*func)(Node*))
         return;
 
     case FunctionArgumentSequence:
-        for (i = 0; i < node->functionArgumentSequence.count; i += 1) {
+        for (i = 0; i < node->functionArgumentSequence.count; i += 1)
+        {
             func(node->functionArgumentSequence.sequence[i]);
         }
         return;
@@ -791,7 +794,8 @@ void Recurse(Node *node, void (*func)(Node*))
         return;
 
     case FunctionModifiers:
-        for (i = 0; i < node->functionModifiers.count; i += 1) {
+        for (i = 0; i < node->functionModifiers.count; i += 1)
+        {
             func(node->functionModifiers.sequence[i]);
         }
         return;
@@ -805,7 +809,8 @@ void Recurse(Node *node, void (*func)(Node*))
         return;
 
     case FunctionSignatureArguments:
-        for (i = 0; i < node->functionSignatureArguments.count; i += 1) {
+        for (i = 0; i < node->functionSignatureArguments.count; i += 1)
+        {
             func(node->functionSignatureArguments.sequence[i]);
         }
         return;
@@ -816,7 +821,8 @@ void Recurse(Node *node, void (*func)(Node*))
         return;
 
     case GenericArguments:
-        for (i = 0; i < node->genericArguments.count; i += 1) {
+        for (i = 0; i < node->genericArguments.count; i += 1)
+        {
             func(node->genericArguments.arguments[i]);
         }
         return;
@@ -855,7 +861,8 @@ void Recurse(Node *node, void (*func)(Node*))
         return;
 
     case StatementSequence:
-        for (i = 0; i < node->statementSequence.count; i += 1) {
+        for (i = 0; i < node->statementSequence.count; i += 1)
+        {
             func(node->statementSequence.sequence[i]);
         }
         return;
@@ -879,7 +886,9 @@ void Recurse(Node *node, void (*func)(Node*))
         return;
 
     default:
-        fprintf(stderr, "wraith: Unhandled SyntaxKind %s in recurse function.\n", 
+        fprintf(
+            stderr,
+            "wraith: Unhandled SyntaxKind %s in recurse function.\n",
             SyntaxKindString(node->syntaxKind));
         return;
     }
@@ -936,9 +945,16 @@ TypeTag *MakeTypeTag(Node *node)
         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(
@@ -948,6 +964,7 @@ TypeTag *MakeTypeTag(Node *node)
             SyntaxKindString(node->syntaxKind));
         return NULL;
     }
+
     return tag;
 }
 
@@ -977,15 +994,193 @@ char *TypeTagToString(TypeTag *tag)
     }
     case Custom:
     {
-        char *result = malloc(sizeof(char) * (strlen(tag->value.customType) + 8));
+        char *result =
+            malloc(sizeof(char) * (strlen(tag->value.customType) + 8));
         sprintf(result, "Custom<%s>", tag->value.customType);
         return result;
     }
     case Generic:
     {
-        char *result = malloc(sizeof(char) * (strlen(tag->value.customType) + 9));
+        char *result =
+            malloc(sizeof(char) * (strlen(tag->value.customType) + 9));
         sprintf(result, "Generic<%s>", tag->value.customType);
         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 */
@@ -300,7 +299,6 @@ struct Node
         } unaryExpression;
     };
     TypeTag *typeTag;
-    IdNode *idLink;
 };
 
 const char *SyntaxKindString(SyntaxKind syntaxKind);
@@ -367,13 +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. 
+/* Helper function for applying a void function generically over the children of
- * Used for functions that need to traverse the entire tree but only perform operations on a subset
+ * an AST node. Used for functions that need to traverse the entire tree but
- * of node types. Such functions can match the syntaxKinds relevant to their purpose and invoke this
+ * only perform operations on a subset of node types. Such functions can match
- * function in all other cases. */
+ * the syntaxKinds relevant to their purpose and invoke this function in all
-void Recurse(Node *node, void (*func)(Node*));
+ * 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,507 +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:
-        astNode->typeTag = MakeTypeTag(astNode);
-        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.genericArguments, mainNode);
-        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 GenericArgument:
-    {
-        char *name = astNode->genericArgument.identifier->identifier.name;
-        mainNode = MakeIdNode(GenericType, name, parent);
-        break;
-    }
-
-    case GenericArguments:
-    {
-        for (i = 0; i < astNode->genericArguments.count; i += 1)
-        {
-            Node *argNode = astNode->genericArguments.arguments[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;
-    case GenericType:
-        printf("Generic type: %s\n", node->name);
-        break;
-    case Alloc:
-        printf("Alloc: %s\n", 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,51 +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,
-    GenericType,
-    Alloc
-} 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,9 +2,8 @@
 #include <stdlib.h>
 
 #include "codegen.h"
-#include "identcheck.h"
 #include "parser.h"
-#include "typeutils.h"
+#include "validation.h"
 
 int main(int argc, char *argv[])
 {
@@ -86,22 +85,15 @@ int main(int argc, char *argv[])
                 }
                 else
                 {
-                    {
+                    LinkParentPointers(rootNode, NULL);
-                        IdNode *idTree = MakeIdTree(rootNode, NULL);
+                    /* FIXME: ValidateIdentifiers should return some sort of
-                        printf("\n");
+                              error status object. */
-                        PrintIdTree(idTree, /*tabCount=*/0);
+                    ValidateIdentifiers(rootNode);
+                    TagIdentifierTypes(rootNode);
+                    ConvertCustomsToGenerics(rootNode);
+                    PrintNode(rootNode, 0);
 
-                        printf("\nConverting custom types in the ID-tree.\n");
+                    printf("Beginning codegen.\n");
-                        ConvertIdCustomsToGenerics(idTree);
-                        printf("\n");
-                        PrintIdTree(idTree, /*tabCount=*/0);
-
-                        printf("\nConverting custom type nodes in the AST.\n");
-                        ConvertASTCustomsToGenerics(rootNode);
-                        printf("\n");
-                        PrintNode(rootNode, /*tabCount=*/0);
-
-                    }
                     exitCode = Codegen(rootNode, optimizationLevel);
                 }
             }

src/typeutils.c

@@ -1,83 +0,0 @@
-#include "typeutils.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-void ConvertIdCustomsToGenerics(IdNode *node) {
-    uint32_t i;
-    switch(node->type)
-    {
-        case UnorderedScope:
-        case OrderedScope:
-        case Struct:
-            /* FIXME: This case will need to be modified to handle type parameters over structs. */
-            for (i = 0; i < node->childCount; i += 1) {
-                ConvertIdCustomsToGenerics(node->children[i]);
-            }
-            return;
-
-        case Variable: {
-            TypeTag *varType = node->typeTag;
-            if (varType->type == Custom) {
-                IdNode *x = LookupId(node->parent, node, varType->value.customType);
-                if (x != NULL && x->type == GenericType) {
-                    varType->type = Generic;
-                }
-            }
-            return;
-        }
-
-        case Function: {
-            TypeTag *funcType = node->typeTag;
-            if (funcType->type == Custom) {
-                /* For functions we have to handle the type lookup manually since the generic type
-                 * identifiers are declared as children of the function's IdNode. */
-                for (i = 0; i < node->childCount; i += 1) {
-                    IdNode *child = node->children[i];
-                    if (child->type == GenericType && strcmp(child->name, funcType->value.customType) == 0) {
-                        funcType->type = Generic;
-                    }
-                }
-            }
-
-            for (i = 0; i < node->childCount; i += 1) {
-                ConvertIdCustomsToGenerics(node->children[i]);
-            }
-            return;
-        }
-    }
-}
-
-/* FIXME: This function will need to be modified to handle type parameters over structs. */
-void ConvertASTCustomsToGenerics(Node *node) {
-    uint32_t i;
-    switch (node->syntaxKind)
-    {
-    case Declaration:
-    {
-        Node *type = node->declaration.type->type.typeNode;
-        Node *id = node->declaration.identifier;
-        if (id->typeTag->type == Generic && type->syntaxKind == CustomTypeNode) {
-            free(node->declaration.type);
-            node->declaration.type = MakeGenericTypeNode(id->typeTag->value.genericType);
-        }
-        return;
-    }
-
-    case FunctionSignature:
-    {
-        Node *id = node->functionSignature.identifier;
-        Node *type = node->functionSignature.type;
-        if (id->typeTag->type == Generic && type->syntaxKind == CustomTypeNode) {
-            free(node->functionSignature.type);
-            node->functionSignature.type = MakeGenericTypeNode(id->typeTag->value.genericType);
-        }
-        ConvertASTCustomsToGenerics(node->functionSignature.arguments);
-        return;
-    }
-
-    default:
-        recurse(node, *ConvertASTCustomsToGenerics);
-    }
-}

src/typeutils.h

@@ -1,13 +0,0 @@
-/* Helper functions for working with types in the AST and ID-tree. */
-
-#ifndef WRAITH_TYPEUTILS_H
-#define WRAITH_TYPEUTILS_H
-
-#include "ast.h"
-#include "identcheck.h"
-
-/* FIXME: These two functions will need to be modified to handle type parameters over structs. */
-void ConvertIdCustomsToGenerics(IdNode *node);
-void ConvertASTCustomsToGenerics(Node *node);
-
-#endif /* WRAITH_TYPEUTILS_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 */