parser.cpp

#include "nc_defines.h"
#include "nc_types.h"
#include "nc_memory.h"
#include "nc_arena.h"
#include "nc_string.h"
#include "nc_log.h"
#include "nc_tls.h"
#include "nc_profile.h"
#include "parser.h"
#include "ast.h"
#include "token.h"
#include "symbol_table.h"
#include "intern.h"
#include "type.h"
#include "type_check.h"

global const OpName OP_NAME_TABLE[] = {
    {
        Str8Lit("+"),
        FALSE,
        TOKEN_KIND_PLUS
    },
    {
        Str8Lit("-"),
        FALSE,
        TOKEN_KIND_MINUS
    },
    {
        Str8Lit("*"),
        FALSE,
        TOKEN_KIND_STAR
    },
    {
        Str8Lit("/"),
        FALSE,
        TOKEN_KIND_SLASH
    },
    {
        Str8Lit("%"),
        FALSE,
        TOKEN_KIND_PERCENT
    },
    {
        Str8Lit("&"),
        FALSE,
        TOKEN_KIND_BIT_AND
    },
    {
        Str8Lit("|"),
        FALSE,
        TOKEN_KIND_BIT_OR
    },
    {
        Str8Lit("^"),
        FALSE,
        TOKEN_KIND_CARET
    },
    {
        Str8Lit("<"),
        FALSE,
        TOKEN_KIND_LESS
    },
    {
        Str8Lit(">"),
        FALSE,
        TOKEN_KIND_GREATER
    },
    {
        Str8Lit("!"),
        FALSE,
        TOKEN_KIND_EXCLAIM
    },
    {
        Str8Lit("~"),
        FALSE,
        TOKEN_KIND_TILDE
    },
    {
        Str8Lit("<<"),
        FALSE,
        TOKEN_KIND_L_SHIFT
    },
    {
        Str8Lit(">>"),
        FALSE,
        TOKEN_KIND_R_SHIFT
    },
    {
        Str8Lit("=="),
        FALSE,
        TOKEN_KIND_EQ_EQ
    },
    {
        Str8Lit("!="),
        FALSE,
        TOKEN_KIND_EXCLAIM_EQ
    },
    {
        Str8Lit("<="),
        FALSE,
        TOKEN_KIND_LESS_EQ
    },
    {
        Str8Lit(">="),
        FALSE,
        TOKEN_KIND_GREATER_EQ
    },
    {
        Str8Lit("&&"),
        FALSE,
        TOKEN_KIND_LOG_AND
    },
    {
        Str8Lit("||"),
        FALSE,
        TOKEN_KIND_LOG_OR
    },
    {
        Str8Lit("+="),
        TRUE,
        TOKEN_KIND_PLUS_EQ
    },
    {
        Str8Lit("-="),
        TRUE,
        TOKEN_KIND_MINUS_EQ
    },
    {
        Str8Lit("*="),
        TRUE,
        TOKEN_KIND_TIMES_EQ
    },
    {
        Str8Lit("/="),
        TRUE,
        TOKEN_KIND_DIV_EQ
    },
    {
        Str8Lit("%="),
        TRUE,
        TOKEN_KIND_PERCENT_EQ
    },
    {
        Str8Lit("&="),
        TRUE,
        TOKEN_KIND_BIT_AND_EQ
    },
    {
        Str8Lit("|="),
        TRUE,
        TOKEN_KIND_BIT_OR_EQ
    },
    {
        Str8Lit("^="),
        TRUE,
        TOKEN_KIND_CARET_EQ
    },
    {
        Str8Lit("<<="),
        TRUE,
        TOKEN_KIND_LESS_LESS_EQ
    },
    {
        Str8Lit(">>="),
        TRUE,
        TOKEN_KIND_GREATER_GREATER_EQ
    }
};

global NameIndex OP_NAMES[256] = {};
global b32       OP_IS_ASSIGNMENT[256] = {};
global NameIndex OP_NAME_INDEX = {};
global NameIndex OP_NAME_INDEX_ASSIGN = {};
global NameIndex ANON_NAME = {
    NAME_INDEX_INVALID_VALUE
};

INTERNAL Token
CurrentToken(void)
{
    return GetTLS()->PARSER_STATE->Tokens[GetTLS()->PARSER_STATE->CurrentIndex.V];
}

INTERNAL Token
PeekToken(u32 Skip = 1)
{
    return GetTLS()->PARSER_STATE->Tokens[GetTLS()->PARSER_STATE->CurrentIndex.V + Skip];
}

INTERNAL Token
ConsumeToken()
{
    Token Result = CurrentToken();

    ++GetTLS()->PARSER_STATE->CurrentIndex.V;

    return Result;
}

INTERNAL b32
MatchToken(u8 Kind)
{
    if (CurrentToken().Kind ==  Kind) {
        ConsumeToken();

        return TRUE;
    }

    return FALSE;
}

INTERNAL NameIndex
CurrentName(void)
{
    return GetTLS()->PARSER_STATE->TokenNames[GetTLS()->PARSER_STATE->CurrentIndex.V];
}

INTERNAL b32
PeekIsColon(void)
{
    return PeekToken().Kind == TOKEN_KIND_COLON;
}

API_INTERNAL void
ExpectToken(u8 Kind)
{
    if (CurrentToken().Kind != Kind) {
        LogPanic(
            "expected [%c] (%u) but got [%c] (%u) instead",
            Kind,
            Kind,
            CurrentToken().Kind,
            CurrentToken().Kind
        );
        LogPanic("error found at offset %u", CurrentToken().Offset);
        ASSERT_ALWAYS(FALSE);
    }

    ConsumeToken();
}

API_INTERNAL void
ConsumeUntil(u8 Kind)
{
    while (CurrentToken().Kind != Kind)
        ConsumeToken();
}

INTERNAL void
PushWork(i32 Item)
{
    i32* Slot = ArenaPushArray(
        GetTLS()->PARSER_STATE->WorkMemPool, 
        i32, 
        1
    );
    *Slot = Item;
    ++GetTLS()->PARSER_STATE->Tree->WorkCount;
}

INTERNAL void
ArenaExInit(ArenaEx* Stream, u64 ReserveSize)
{
    u8* Base = (u8*) MemReserve(ReserveSize);

    ASSERT_ALWAYS(Base);

    Stream->End = Base + ReserveSize;
    Stream->Reserved = ReserveSize;
    Stream->Committed = 0;
    Stream->Count = 0;
}

INTERNAL void*
ArenaExPushSize(ArenaEx* Stream, u64 Size)
{
    Stream->Count += Size;

    if (Stream->Count > Stream->Committed) {
        u64 NewComitted = ALIGNTO(Stream->Count, EXPR_ARENA_COMMIT_SIZE);

        ASSERT_ALWAYS(NewComitted <= Stream->Reserved);

        b32 Committed = MemCommit(
            Stream->End - NewComitted,
            NewComitted - Stream->Committed
        );

        ASSERT_ALWAYS(Committed);

        Stream->Committed = NewComitted;
    }

    return (Stream->End - Stream->Count);
}

INTERNAL void
DeferIdent(
    NameIndex Name, 
    TokIndex Tok, 
    i32 Index, 
    DeferredArenaKind ArenaKind
) {
    DeferredIdent* Entry = ArenaPushStruct(
        GetTLS()->PARSER_STATE->DeferredMemPool,
        DeferredIdent
    );

    ++GetTLS()->PARSER_STATE->DeferredCount;
    Entry->Name = Name;
    Entry->Tok = Tok;
    Entry->Index = Index;
    Entry->ArenaKind = ArenaKind;
}

INTERNAL void
ResolveDeferred(void)
{
    AST* Tree = GetTLS()->PARSER_STATE->Tree;

    for (u32 Index = 0; Index < GetTLS()->PARSER_STATE->DeferredCount; ++Index) {
        DeferredIdent* Entry = &GetTLS()->PARSER_STATE->Deferred[Index];
        BindIndex Bind = FindBinding(Entry->Name);

        if (Bind.V == BINDING_INVALID_VALUE) {
            Token Tok = GetTLS()->PARSER_STATE->Tokens[Entry->Tok.V];

            LogError(
                "use of undeclared identifier \"%.*s\" at offset %u",
                Tok.Count,
                GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                Tok.Offset
            );
            continue;
        }

        switch (Entry->ArenaKind) {
            default: {} break;

            case DEFERRED_ARENA_KIND_EXPR: {
                ASTNodeExprIdent* Node = (ASTNodeExprIdent*) (
                    Tree->Exprs + Entry->Index
                );

                Node->Bind = Bind;
            } break;

            case DEFERRED_ARENA_KIND_STMT: {} break;
        }
    }

    GetTLS()->PARSER_STATE->DeferredCount = 0;
    ArenaClear(GetTLS()->PARSER_STATE->DeferredMemPool);
}

INTERNAL void
RecipeEmit(TypeOp Op, u32 Arg, u16 Count, u8 Flags)
{
    TypeRecipeOp* RecipeOp = ArenaPushStruct(
        GetTLS()->PARSER_STATE->RecipeMemPool,
        TypeRecipeOp
    );

    RecipeOp->Arg = Arg;
    RecipeOp->Count = Count;
    RecipeOp->Op = Op;
    RecipeOp->Flags = Flags;
    ++GetTLS()->PARSER_STATE->RecipeCount;
}

INTERNAL void
RecipeRelease(u32 Mark)
{
    GetTLS()->PARSER_STATE->RecipeCount = Mark;
    ArenaPopTo(
        GetTLS()->PARSER_STATE->RecipeMemPool,
        ARENA_HEADER_SIZE + Mark * sizeof(TypeRecipeOp)
    );
}

INTERNAL void
DeferType(u32 Mark, BindIndex Bind, u32 DeclSlot, TokIndex Tok)
{
    u32 Count = GetTLS()->PARSER_STATE->RecipeCount - Mark;
    TypeRecipeOp* Ops = ArenaPushArray(
        GetTLS()->PARSER_STATE->DeferredOpMemPool,
        TypeRecipeOp,
        Count
    );
    DeferredType* Entry = ArenaPushStruct(
        GetTLS()->PARSER_STATE->DeferredTypeMemPool,
        DeferredType
    );

    MemCpy(
        Ops,
        GetTLS()->PARSER_STATE->Recipe + Mark,
        Count * sizeof(TypeRecipeOp)
    );
    Entry->OpOffset = GetTLS()->PARSER_STATE->DeferredOpCount;
    Entry->OpCount = Count;
    Entry->DeclSlot = DeclSlot;
    Entry->Bind = Bind;
    Entry->Tok = Tok;
    Entry->IsDone = FALSE;
    GetTLS()->PARSER_STATE->DeferredOpCount += Count;
    ++GetTLS()->PARSER_STATE->DeferredTypeCount;
}

INTERNAL RecipeStatus
EvalRecipe(
    TypeRecipeOp const* Ops, 
    u32 Count, 
    TokIndex Tok, 
    OUT TypeIndex* Result
) {
    TempArena Scratch = GetScratch(NULL, 0);
    TypeIndex* Stack = ArenaPushArray(
        Scratch.MemPool,
        TypeIndex,
        Count + 1
    );
    u32 StackHead = 0;
    RecipeStatus Status = RECIPE_STATUS_RESOLVED;

    for (
        u32 Index = 0; 
        Index < Count && Status == RECIPE_STATUS_RESOLVED; 
        ++Index
    ) {
        TypeRecipeOp const* Op = &Ops[Index];

        switch (Op->Op) {
            default: {} break;

            case TYPE_OP_TYPE: {
                Stack[StackHead++].V = Op->Arg;
            } break;

            case TYPE_OP_PTR: {
                Stack[StackHead - 1] = TypePtrTo(Stack[StackHead - 1]);
            } break;

            case TYPE_OP_ARR: {
                Stack[StackHead - 1] = TypeArrayOf(
                    Stack[StackHead - 1],
                    Op->Arg,
                    !!(Op->Flags & TYPE_FLAG_UNSIZED)
                );
            } break;

            case TYPE_OP_FUNC: {
                TypeIndex Return = Stack[--StackHead];

                StackHead -= Op->Count;
                MemMove(
                    Stack + StackHead + 1,
                    Stack + StackHead,
                    Op->Count * sizeof(TypeIndex)
                );
                Stack[StackHead] = Return;
                Stack[StackHead] = TypeFunc(Stack + StackHead, Op->Count);
                ++StackHead;
            } break;

            case TYPE_OP_NAME:
            case TYPE_OP_INST: {
                NameIndex Name = {
                    Op->Arg
                };
                BindIndex Bind = FindBinding(Name);

                if (Bind.V == BINDING_INVALID_VALUE) {
                    Str8 NameString = GetName(GetTLS()->SYMBOL_TABLE->Names, Name);

                    LogError(
                        "use of undeclared type \"%.*s\" at offset %u",
                        PRINT_STR(NameString),
                        GetTLS()->PARSER_STATE->Tokens[Tok.V].Offset
                    );
                    Status = RECIPE_STATUS_FAILED;
                    break;
                }

                Binding* B = &GetTLS()->SYMBOL_TABLE->Bindings[Bind.V];

                if (
                    B->Kind == BINDING_KIND_VALUE ||
                    B->Kind == BINDING_KIND_FUNC
                ) {
                    Str8 NameString = GetName(GetTLS()->SYMBOL_TABLE->Names, Name);

                    LogError(
                        "\"%.*s\" is not a type at offset %u",
                        PRINT_STR(NameString),
                        GetTLS()->PARSER_STATE->Tokens[Tok.V].Offset
                    );
                    Status = RECIPE_STATUS_FAILED;
                    break;
                }

                if (Op->Op == TYPE_OP_INST) {
                    StackHead -= Op->Count;
                    Stack[StackHead] = TypeInstance(
                        B->Decl, 
                        Stack + StackHead, 
                        Op->Count
                    );
                    ++StackHead;
                } else if (B->Type.V == TYPE_INDEX_INVALID_TYPE) {
                    Status = RECIPE_STATUS_WAITING;
                } else {
                    Stack[StackHead++] = B->Type;
                }
            } break;
        }
    }

    if (Status == RECIPE_STATUS_RESOLVED) {
        ASSERT(StackHead == 1);

        *Result = *Stack;
    }

    ReleaseScratch(Scratch);

    return Status;
}

NameIndex 
ParseDeclName(OUT TokIndex* NameTok)
{
    Token Tok = CurrentToken();
    NameIndex Result = {
        NAME_INDEX_INVALID_VALUE
    };

    *NameTok = GetTLS()->PARSER_STATE->CurrentIndex;

    if (Tok.Kind == TOKEN_KIND_IDENT) {
        Result = CurrentName();
        ConsumeToken();
    } else if (Tok.Kind == TOKEN_KIND_OPEN_SQ_BRACK) {
        ConsumeToken();
        ExpectToken(TOKEN_KIND_CLOSE_SQ_BRACK);

        if (MatchToken(TOKEN_KIND_EQUAL))
            Result = OP_NAME_INDEX_ASSIGN;
        else
            Result = OP_NAME_INDEX;
    } else if (IsOpTok(Tok.Kind)) {
        Result = OP_NAMES[Tok.Kind];
        ConsumeToken();
    } else {
        LogPanic(
            "expected a declaration name at offset %u, got kind %u instead",
            Tok.Offset,
            Tok.Kind
        );
        ASSERT_ALWAYS(FALSE);
    }

    return Result;
}

void 
ParserInternNames(NamePool* Names)
{
    for (u32 Index = 0; Index < ARRAY_COUNT(OP_NAMES); ++Index)
        OP_NAMES[Index].V = NAME_INDEX_INVALID_VALUE;

    for (u32 Index = 0; Index < ARRAY_COUNT(OP_NAME_TABLE); ++Index) {
        OpName const* Entry = &OP_NAME_TABLE[Index];

        OP_NAMES[Entry->Kind] = InternName(Names, Entry->Name);
        OP_IS_ASSIGNMENT[Entry->Kind] = Entry->IsAssignment;
    }

    OP_NAME_INDEX = InternName(Names, "[]"_s8);
    OP_NAME_INDEX_ASSIGN = InternName(Names, "[]="_s8);
    ANON_NAME = InternName(Names, "_"_s8);
}

INTERNAL b32
IsOpNameTok(TokIndex NameTok)
{
    u8 Kind = GetTLS()->PARSER_STATE->Tokens[NameTok.V].Kind;

    return (
        Kind == TOKEN_KIND_OPEN_SQ_BRACK ||
        IsOpTok(Kind)
    );
}

INTERNAL b32
IsAssignOpName(TokIndex NameTok, NameIndex Name)
{
    u8 Kind = GetTLS()->PARSER_STATE->Tokens[NameTok.V].Kind;

    return (
        Name.V == OP_NAME_INDEX_ASSIGN.V ||
        OP_IS_ASSIGNMENT[Kind]
    );
}

void
ResolveDeferredTypes(void)
{
    for (;;) {
        u32 Progress = 0;
        u32 Waiting = 0;

        for (u32 Index = 0; Index < GetTLS()->PARSER_STATE->DeferredTypeCount; ++Index) {
            DeferredType* Entry = &GetTLS()->PARSER_STATE->DeferredTypes[Index];

            if (Entry->IsDone)
                continue;

            TypeIndex Result = {
                TYPE_INDEX_INVALID_TYPE
            };
            RecipeStatus Status = EvalRecipe(
                GetTLS()->PARSER_STATE->DeferredOps + Entry->OpOffset,
                Entry->OpCount,
                Entry->Tok,
                &Result
            );

            if (Status == RECIPE_STATUS_WAITING) {
                ++Waiting;
                continue;
            }

            if (Status == RECIPE_STATUS_RESOLVED) {
                if (Entry->Bind.V != BINDING_INVALID_VALUE)
                    GetTLS()->SYMBOL_TABLE->Bindings[Entry->Bind.V].Type = Result;

                if (Entry->DeclSlot != AST_NODE_INDEX_INVALID) {
                    *(TypeIndex*) (
                        GetTLS()->PARSER_STATE->Tree->Decls + Entry->DeclSlot
                    ) = Result;
                }

                ++Progress;
            }

            Entry->IsDone = TRUE;
        }

        if (!Waiting)
            break;

        if (!Progress) {
            for (
                u32 Index = 0; 
                Index < GetTLS()->PARSER_STATE->DeferredTypeCount; 
                ++Index
            ) {
                DeferredType* Entry = &GetTLS()->PARSER_STATE->DeferredTypes[Index];

                if (Entry->IsDone)
                    continue;

                LogError(
                    "type at offset %u cannot be resolved (cyclic definition)",
                    GetTLS()->PARSER_STATE->Tokens[Entry->Tok.V].Offset
                );
                Entry->IsDone = TRUE;
            }

            break;
        }
    }
}

INTERNAL TokIndex
SkipBraceBody(void)
{
    ASSERT(CurrentToken().Kind == TOKEN_KIND_OPEN_BRACK);

    TokIndex Result = GetTLS()->PARSER_STATE->CurrentIndex;
    u32 Depth = 0;

    for (;;) {
        u8 Kind = CurrentToken().Kind;

        if (Kind == TOKEN_KIND_EOF) {
            LogPanic(
                "unterminated function body at offset %u",
                CurrentToken().Offset
            );
            ASSERT_ALWAYS(FALSE);
        }

        if (Kind == TOKEN_KIND_OPEN_BRACK)
            ++Depth;

        if (Kind == TOKEN_KIND_CLOSE_BRACK) {
            ConsumeToken();

            if (!--Depth)
                break;

            continue;
        }

        ConsumeToken();
    }

    return Result;
}

INTERNAL void
QueueBody(TokIndex BodyStart, DeclIndex Decl, BindIndex FuncBind)
{
    PendingBody* Entry = ArenaPushStruct(
        GetTLS()->PARSER_STATE->PendingMemPool,
        PendingBody
    );

    ++GetTLS()->PARSER_STATE->PendingCount;
    Entry->BodyStart = BodyStart;
    Entry->Decl = Decl;
    Entry->FuncBind = FuncBind;
}

b32
IsOpTok(u8 Kind)
{
    return OP_NAMES[Kind].V != NAME_INDEX_INVALID_VALUE;
}


void*
ASTNodeStmtAlloc(u32 Size)
{
    u32 SizeAligned = ALIGNTO(Size, sizeof(u32));
    void* Result = ArenaPushSize(
        GetTLS()->PARSER_STATE->StmtMemPool, 
        SizeAligned, 
        sizeof(u32),
        FALSE
    );

    GetTLS()->PARSER_STATE->Tree->StmtsCount += SizeAligned;

    return Result;
}

void*
ASTNodeExprAlloc(u32 Size, u8 NodeType)
{
    u32 SizeAligned = ALIGNTO(Size, sizeof(u32));
    void* Result = ArenaExPushSize(
        &GetTLS()->PARSER_STATE->ExprMemPool, 
        SizeAligned
    );

    ((ASTNodeHeader*) Result)->Type = NodeType;
    ((ASTNodeHeader*) Result)->Count = 0;

    if (ASTExprIsTyped(NodeType))
        ((ASTNodeExprAccel*) Result)->Type.V = TYPE_INDEX_INVALID_TYPE;

    GetTLS()->PARSER_STATE->ExprCount = SafeTruncateU64(
        GetTLS()->PARSER_STATE->ExprMemPool.Count
    );
    GetTLS()->PARSER_STATE->Tree->ExprsCount = GetTLS()->PARSER_STATE->ExprCount;
    PushWork(-(i32) GetTLS()->PARSER_STATE->ExprCount);

    return Result;
}

void*
ASTNodeDeclAlloc(u32 Size)
{
    u32 SizeAligned = ALIGNTO(Size, sizeof(u32));
    void* Result = ArenaPushSize(
        GetTLS()->PARSER_STATE->DeclMemPool, 
        SizeAligned, 
        sizeof(u32),
        FALSE
    );

    GetTLS()->PARSER_STATE->Tree->DeclsCount += SizeAligned;

    return Result;
}

void*
ASTNodeInitAlloc(u32 Size)
{
    u32 SizeAligned = ALIGNTO(Size, sizeof(u32));
    void* Result = ArenaPushSize(
        GetTLS()->PARSER_STATE->InitMemPool, 
        SizeAligned, 
        sizeof(u32),
        FALSE
    );

    GetTLS()->PARSER_STATE->Tree->InitsCount += SizeAligned;

    return Result;
}

INTERNAL ExprIndex
ExprIndexOf(void const* Node)
{
    ExprIndex Result = {
        (i32) ((u8 const*) Node - GetTLS()->PARSER_STATE->Tree->Exprs)
    };

    return Result;
}

INTERNAL StmtIndex
StmtIndexOf(void const* Node)
{
    StmtIndex Result = {
        SafeTruncateU64((u8 const*) Node - GetTLS()->PARSER_STATE->Tree->Stmts)
    };

    return Result;
}

INTERNAL DeclIndex
DeclIndexOf(void const* Node)
{
    DeclIndex Result = {
        SafeTruncateU64((u8 const*) Node - GetTLS()->PARSER_STATE->Tree->Decls)
    };

    return Result;
}

INTERNAL u32
CountParams(void)
{
    ASSERT(CurrentToken().Kind == TOKEN_KIND_OPEN_PAREN);

    TokIndex Saved = GetTLS()->PARSER_STATE->CurrentIndex;
    u32 Depth = 0;
    u32 Result = 0;

    for (;;) {
        u8 Kind = CurrentToken().Kind;

        if (Kind == TOKEN_KIND_EOF) {
            LogPanic(
                "unterminated parameter list at offset %u", 
                CurrentToken().Offset
            );
            ASSERT_ALWAYS(FALSE);
        }

        if (Kind == TOKEN_KIND_OPEN_PAREN) {
            ++Depth;

            if (Depth == 1 && PeekToken().Kind != TOKEN_KIND_ClOSE_PAREN)
                Result = 1;
        } else if (Kind == TOKEN_KIND_ClOSE_PAREN) {
            --Depth;

            if (Depth == 0)
                break;
        } else if (Kind == TOKEN_KIND_COMMA && Depth == 1) {
            ++Result;
        }

        ConsumeToken();
    }

    GetTLS()->PARSER_STATE->CurrentIndex = Saved;

    return Result;
}

INTERNAL void
RebindParams(DeclIndex Decl)
{
    ASTNodeDecl* DeclNode = (ASTNodeDecl*) (GetTLS()->PARSER_STATE->Tree->Decls + Decl.V);

    if (DeclNode->FirstDecl.V == AST_NODE_INDEX_INVALID)
        return;

    ASTNodeDeclFunc* FuncNode = (ASTNodeDeclFunc*) (
        GetTLS()->PARSER_STATE->Tree->Decls + DeclNode->FirstDecl.V
    );

    if (FuncNode->Header.Type != AST_DECLARATOR_FUNCTION)
        return;

    for (u32 Index = 0; Index < FuncNode->Header.Count; ++Index) {
        DeclIndex ParamDecl = FuncNode->Param[Index];

        if (ParamDecl.V == AST_NODE_INDEX_INVALID)
            continue;

        ASTNodeDeclIdent* ParamIdent = (ASTNodeDeclIdent*) (
            GetTLS()->PARSER_STATE->Tree->Decls + ParamDecl.V
        );
        TypeIndex ParamType = {
            TYPE_INDEX_INVALID_TYPE
        };

        if (ParamIdent->Name.V == ANON_NAME.V)
            continue;

        if (ParamIdent->Bind.V != BINDING_INVALID_VALUE)
            ParamType = GetTLS()->SYMBOL_TABLE->Bindings[ParamIdent->Bind.V].Type;

        ParamIdent->Bind = AddBinding(
            GetTLS()->PARSER_STATE->CurrentScope, 
            ParamIdent->Name, 
            ParamDecl,
            ParamType,
            BINDING_KIND_VALUE
        );

        if (ParamIdent->Bind.V == BINDING_INVALID_VALUE) {
            Token Tok = GetTLS()->PARSER_STATE->Tokens[ParamIdent->Header.Tok.V];

            LogError(
                "duplicate parameter \"%.*s\" at offset %u",
                Tok.Count,
                GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                Tok.Offset
            );
        }
    }
}

ExprIndex 
ParsePrimary()
{
    Token Tok = CurrentToken();
    ExprIndex Result = {};

    switch (Tok.Kind) {
        default: {
            LogError(
                "expected an expression, got token kind [%u] at offset %u",
                Tok.Kind,
                Tok.Offset
            );

            TokIndex CurrentIndex =GetTLS()->PARSER_STATE->CurrentIndex;

            ConsumeToken();

            ASTNodeError* Node = ExprAlloc(ASTNodeError, AST_ERROR);

            Node->Header.Tok = CurrentIndex;
            Result = ExprIndexOf(Node);
        } break;

        case TOKEN_KIND_NUMBER: {
            TokIndex CurrentIndex = GetTLS()->PARSER_STATE->CurrentIndex;

            ConsumeToken();

            ASTNodeLiteral* Node = ExprAlloc(ASTNodeLiteral, AST_LITERAL);
            Str8 RawValue = {};
            u64 Value = 0;

            Node->Header.Tok = CurrentIndex;
            RawValue = Str(GetTLS()->PARSER_STATE->Source.Str + Tok.Offset, Tok.Count);
            Value = U64FromStr(RawValue);
            Node->Val.Unsigned = Value;
            Result = ExprIndexOf(Node);
        } break;

        case TOKEN_KIND_IDENT: {
            TokIndex IdentTokIndex = GetTLS()->PARSER_STATE->CurrentIndex;
            NameIndex Name = CurrentName();

            ConsumeToken();

            ASTNodeExprIdent* Node = ExprAlloc(ASTNodeExprIdent, AST_IDENT);

            Node->Header.Tok = IdentTokIndex;
            Node->Name = Name;
            Node->Bind = FindBinding(Name);
            Result = ExprIndexOf(Node);

            if (Node->Bind.V == BINDING_INVALID_VALUE) {
                DeferIdent(
                    Name, 
                    IdentTokIndex, 
                    Result.V, 
                    DEFERRED_ARENA_KIND_EXPR
                );
            }
        } break;

        case TOKEN_KIND_OPEN_PAREN: {
            ConsumeToken();
            Tok = CurrentToken();
            Result = ParseExpr();
            ExpectToken(TOKEN_KIND_ClOSE_PAREN);
        } break;
    }

    return Result;
}

ExprIndex 
ParsePostfix()
{
    ExprIndex Left = ParsePrimary();

    for (;;) {
        Token Tok = CurrentToken();
        TokIndex OpTok = GetTLS()->PARSER_STATE->CurrentIndex;

        switch (Tok.Kind) {
            default: {
                return Left;
            } break;

            case TOKEN_KIND_OPEN_PAREN: {
                ConsumeToken();

                u32 ArgCount = 0;
                ExprIndex Args[128] = {};

                if (CurrentToken().Kind != TOKEN_KIND_ClOSE_PAREN) {
                    do {
                        Args[ArgCount++] = ParseExpr();
                    } while (MatchToken(TOKEN_KIND_COMMA));
                }

                ExpectToken(TOKEN_KIND_ClOSE_PAREN);

                u32 NodeSize = OFFSETOF(ASTNodeFuncCall, Arg) + ArgCount * sizeof(ExprIndex);
                ASTNodeFuncCall* Node = (ASTNodeFuncCall*) ASTNodeExprAlloc(NodeSize, AST_FUNC_CALL);

                Node->Header.Count = ArgCount;
                Node->Header.Tok = OpTok;
                Node->Func = Left;

                for (u32 Index = 0; Index < ArgCount; ++Index)
                    Node->Arg[Index] = Args[ArgCount - 1 - Index];

                Left = ExprIndexOf(Node);
            } break;

            case TOKEN_KIND_PERIOD:
            case TOKEN_KIND_ARROW: {
                u8 OpKind = Tok.Kind;

                ConsumeToken();

                TokIndex FieldTokIndex = GetTLS()->PARSER_STATE->CurrentIndex;
                NameIndex FieldName = CurrentName();

                ExpectToken(TOKEN_KIND_IDENT);

                ASTNodeFieldAccess* Node = ExprAlloc(ASTNodeFieldAccess, AST_FIELD_ACCESS);

                Node->Header.Variant = OpKind;
                Node->Header.Tok = OpTok;
                Node->Name = FieldName;
                Node->Field = {
                    AST_NODE_INDEX_INVALID
                };
                Left = ExprIndexOf(Node);
            } break;

            case TOKEN_KIND_OPEN_SQ_BRACK: {
                ConsumeToken();

                ExprIndex Index = ParseExpr();

                ExpectToken(TOKEN_KIND_CLOSE_SQ_BRACK);

                ASTNodeBinary* Node = ExprAlloc(ASTNodeBinary, AST_INDEX);

                Node->Header.Tok = OpTok;
                Node->Left = Left;
                Left = ExprIndexOf(Node);
            } break;

            case TOKEN_KIND_INCR:
            case TOKEN_KIND_DECR: {
                u8 OpKind = Tok.Kind;

                ConsumeToken();

                ASTNodeUnary* Node = ExprAlloc(ASTNodeUnary, AST_POST_INCR);

                Node->Header.Variant = OpKind;
                Node->Header.Tok = OpTok;
                Node->Expr = Left;

                Left = ExprIndexOf(Node);
            } break;
        }
    }
}

ExprIndex 
ParseUnary()
{
    Token Tok = CurrentToken();
    ExprIndex Result = {};

    switch (Tok.Kind) {
        default: {
            return ParsePostfix();
        } break;

        case TOKEN_KIND_MINUS:
        case TOKEN_KIND_EXCLAIM:
        case TOKEN_KIND_TILDE:
        case TOKEN_KIND_STAR:
        case TOKEN_KIND_PLUS:
        case TOKEN_KIND_BIT_AND:
        case TOKEN_KIND_INCR:
        case TOKEN_KIND_DECR: {
            u8 OpKind = Tok.Kind;
            TokIndex OpTok = GetTLS()->PARSER_STATE->CurrentIndex;

            ConsumeToken();

            ExprIndex Operand = ParseUnary();
            ASTNodeUnary* Node = ExprAlloc(
                ASTNodeUnary,
                (OpKind == TOKEN_KIND_INCR || OpKind == TOKEN_KIND_DECR)
                    ? AST_PRE_INCR
                    : AST_UNARY_EXPR
            );

            Node->Header.Variant = OpKind;
            Node->Header.Tok = OpTok;
            Node->Expr = Operand;

            return ExprIndexOf(Node);
        } break;
    }
}

ExprIndex 
ParseBinary(u8 MinPrecedence)
{
    ExprIndex Left = ParseUnary();

    for (;;) {
        Token Op = CurrentToken();
        TokIndex TIndex = GetTLS()->PARSER_STATE->CurrentIndex;
        u8 Precedence = 0;

        switch (Op.Kind) {
            default: {
                Precedence = 0;
            } break;

            case TOKEN_KIND_STAR:
            case TOKEN_KIND_SLASH:
            case TOKEN_KIND_PERCENT: {
                Precedence = 10;
            } break;

            case TOKEN_KIND_PLUS:
            case TOKEN_KIND_MINUS: {
                Precedence = 9;
            } break;

            case TOKEN_KIND_L_SHIFT:
            case TOKEN_KIND_R_SHIFT: {
                Precedence = 8;
            } break;

            case TOKEN_KIND_LESS:
            case TOKEN_KIND_GREATER:
            case TOKEN_KIND_LESS_EQ:
            case TOKEN_KIND_GREATER_EQ: {
                Precedence = 7;
            } break;

            case TOKEN_KIND_EQ_EQ:
            case TOKEN_KIND_EXCLAIM_EQ: {
                Precedence = 6;
            } break;

            case TOKEN_KIND_BIT_AND: {
                Precedence = 5;
            } break;

            case TOKEN_KIND_CARET: {
                Precedence = 4;
            } break;

            case TOKEN_KIND_BIT_OR: {
                Precedence = 3;
            } break;

            case TOKEN_KIND_LOG_AND: {
                Precedence = 2;
            } break;

            case TOKEN_KIND_LOG_OR: {
                Precedence = 1;
            } break;
        }

        if (Precedence < MinPrecedence)
            break;

        u8 OpKind = Op.Kind;

        ConsumeToken();

        ExprIndex Right = ParseBinary(Precedence + 1);
        ASTNodeBinary* Node = ExprAlloc(ASTNodeBinary, AST_BINARY_EXPR);

        Node->Header.Type = AST_BINARY_EXPR;
        Node->Header.Variant = OpKind;
        Node->Header.Tok = TIndex;
        Node->Left = Left;
        Left = ExprIndexOf(Node);
    }

    return Left;
}

ExprIndex 
ParseTernary()
{
    ExprIndex Cond = ParseBinary(1);
    TokIndex TIndex = GetTLS()->PARSER_STATE->CurrentIndex;

    if (MatchToken(TOKEN_KIND_QUESTION)) {
        ExprIndex Then = ParseExpr();

        ExpectToken(TOKEN_KIND_COLON);

        ExprIndex Else = ParseTernary();
        ASTNodeTernary* Node = ExprAlloc(ASTNodeTernary, AST_TERNARY_EXPR);

        Node->Header.Type = AST_TERNARY_EXPR;
        Node->Header.Tok = TIndex;
        Node->Cond = Cond;
        Node->Then = Then;

        return ExprIndexOf(Node);
    }

    return Cond;
}

ExprIndex 
ParseAssign()
{
    ExprIndex Left = ParseTernary();
    Token Tok = CurrentToken();
    TokIndex TIndex = GetTLS()->PARSER_STATE->CurrentIndex;
    b32 IsAssignment = (
        Tok.Kind == TOKEN_KIND_EQUAL ||
        OP_IS_ASSIGNMENT[Tok.Kind]
    );

    if (IsAssignment) {
        u8 OpKind = Tok.Kind;

        ConsumeToken();

        ExprIndex Right = ParseAssign();
        ASTNodeBinary* Node = ExprAlloc(ASTNodeBinary, AST_BINARY_ASSIGNMENT);

        Node->Header.Type = AST_BINARY_ASSIGNMENT;
        Node->Header.Variant = OpKind;
        Node->Header.Tok = TIndex;
        Node->Left = Left;

        return ExprIndexOf(Node);
    }

    return Left;
}

ExprIndex 
ParseExpr()
{
    return ParseAssign();
}

StmtIndex 
ParseIf()
{
    ExpectToken(TOKEN_KIND_IF);
    ExpectToken(TOKEN_KIND_OPEN_PAREN);

    ExprIndex Cond = ParseExpr();

    ExpectToken(TOKEN_KIND_ClOSE_PAREN);

    ASTNodeIf* Node = StmtAlloc(ASTNodeIf);

    Node->Header.Type = AST_IF;
    Node->Cond = Cond;

    StmtIndex Result = StmtIndexOf(Node);

    ParseStmt();

    if (MatchToken(TOKEN_KIND_ELSE))
        Node->Else = ParseStmt();
    else
        Node->Else = {AST_NODE_INDEX_INVALID};

    return Result;
}

StmtIndex 
ParseWhile()
{
    ExpectToken(TOKEN_KIND_WHILE);
    ExpectToken(TOKEN_KIND_OPEN_PAREN);

    ExprIndex Cond = ParseExpr();

    ExpectToken(TOKEN_KIND_ClOSE_PAREN);

    ASTNodeWhile* Node = StmtAlloc(ASTNodeWhile);

    Node->Header.Type = AST_WHILE;
    Node->Cond = Cond;

    StmtIndex Result = StmtIndexOf(Node);

    ParseStmt();

    return Result;
}

StmtIndex 
ParseSwitch()
{
    ExpectToken(TOKEN_KIND_SWITCH);
    ExpectToken(TOKEN_KIND_OPEN_PAREN);

    ExprIndex Expr = ParseExpr();

    ExpectToken(TOKEN_KIND_ClOSE_PAREN);

    ASTNodeSwitch* Node = StmtAlloc(ASTNodeSwitch);
    StmtIndex Result = StmtIndexOf(Node);

    Node->Header.Type = AST_SWITCH;
    Node->Expr = Expr;
    ExpectToken(TOKEN_KIND_OPEN_BRACK);

    while (CurrentToken().Kind != TOKEN_KIND_CLOSE_BRACK) {
        if (CurrentToken().Kind == TOKEN_KIND_EOF) {
            LogPanic("unterminated switch body");
            ASSERT_ALWAYS(FALSE);
        }

        // TODO(nathan): `default` has no token kind yet; this only handles case.
        ParseCase();
    }

    ExpectToken(TOKEN_KIND_CLOSE_BRACK);

    return Result;
}

StmtIndex 
ParseCase()
{
    ExpectToken(TOKEN_KIND_CASE);

    ExprIndex Value = ParseExpr();

    ExpectToken(TOKEN_KIND_COLON);

    ASTNodeCase* Node = StmtAlloc(ASTNodeCase);
    StmtIndex Result = StmtIndexOf(Node);

    Node->Header.Type = AST_CASE;
    Node->Val = Value;
    ParseStmt();

    if (CurrentToken().Kind == TOKEN_KIND_BREAK)
        ParseBreak();

    return Result;
}

StmtIndex 
ParseBreak()
{
    ExpectToken(TOKEN_KIND_BREAK);
    ExpectToken(TOKEN_KIND_SEMICOLON);

    ASTNodeBreak* Node = StmtAlloc(ASTNodeBreak);

    Node->Header.Type = AST_BREAK;

    StmtIndex Result = StmtIndexOf(Node);

    return Result;
}

StmtIndex 
ParseReturn()
{
    ExpectToken(TOKEN_KIND_RETURN);

    ASTNodeReturn* Node = StmtAlloc(ASTNodeReturn);

    Node->Header.Type = AST_RETURN;

    if (CurrentToken().Kind != TOKEN_KIND_SEMICOLON) {
        Node->Expr = ParseExpr();

        if (GetTLS()->PARSER_STATE->CurrentFunc.V != BINDING_INVALID_VALUE) {
            PushWork(
                (i32) (
                    (
                        CHECK_WORK_KIND_RETURN << CHECK_WORK_KIND_OFFSET
                    ) | 
                    GetTLS()->PARSER_STATE->CurrentFunc.V
                )
            );
        }
    }

    ExpectToken(TOKEN_KIND_SEMICOLON);

    StmtIndex Result = StmtIndexOf(Node);

    return Result;
}

StmtIndex
ParseWrite()
{
    ExpectToken(TOKEN_KIND_OPEN_PAREN);

    ASTNodeWriteStmt* Node = StmtAlloc(ASTNodeWriteStmt);

    Node->Header.Type = AST_WRITE_STMT;
    Node->Expr = ParseExpr();
    ExpectToken(TOKEN_KIND_ClOSE_PAREN);
    ExpectToken(TOKEN_KIND_SEMICOLON);

    StmtIndex Result = StmtIndexOf(Node);

    return Result;
}

StmtIndex 
ParseStmt()
{
    StmtIndex Result = {};
    Token Tok = CurrentToken();

    switch (Tok.Kind) {
        default: {
            ASTNodeExprStmt* Node = StmtAlloc(ASTNodeExprStmt);

            Node->Header.Type = AST_EXPR_STATEMENT;
            Node->Header.Tok = GetTLS()->PARSER_STATE->CurrentIndex;
            Node->Expr = ParseExpr();
            ExpectToken(TOKEN_KIND_SEMICOLON);
            Result = StmtIndexOf(Node);
        } break;

        case TOKEN_KIND_IF: {
            Result = ParseIf();
        } break;

        case TOKEN_KIND_WHILE: {
            Result = ParseWhile();
        } break;

        case TOKEN_KIND_SWITCH: {
            Result = ParseSwitch();
        } break;

        case TOKEN_KIND_BREAK: {
            Result = ParseBreak();
        } break;

        case TOKEN_KIND_RETURN: {
            Result = ParseReturn();
        } break;

        case TOKEN_KIND_OPEN_BRACK: {
            Result = ParseBlock();
        } break;

        case TOKEN_KIND_FOR: {
            Result = ParseFor();
        } break;

        case TOKEN_KIND_CONTINUE: {
            Result = ParseContinue();
        } break;

        case TOKEN_KIND_GOTO: {
            Result = ParseGoto();
        } break;

        case TOKEN_KIND_SEMICOLON: {
            ConsumeToken();

            ASTNodeHeader* Node = StmtAlloc(ASTNodeHeader);

            Node->Type = AST_EMPTY;
            Result = StmtIndexOf(Node);
        } break;

        case TOKEN_KIND_CONST:
        case TOKEN_KIND_TYPE: {
            ASTNodeDeclStmt* Node = StmtAlloc(ASTNodeDeclStmt);

            Node->Header.Type = AST_DECL_STATEMENT;
            Node->Header.Tok = GetTLS()->PARSER_STATE->CurrentIndex;
            Node->Decl = ParseDecl();
            Result = StmtIndexOf(Node);
        } break;

        case TOKEN_KIND_IDENT: {
            if (PeekIsColon()) {
                ASTNodeDeclStmt* Node = StmtAlloc(ASTNodeDeclStmt);

                Node->Header.Type = AST_DECL_STATEMENT;
                Node->Header.Tok = GetTLS()->PARSER_STATE->CurrentIndex;
                Node->Decl = ParseDecl();
                Result = StmtIndexOf(Node);
            } else {
                ASTNodeExprStmt* Node = StmtAlloc(ASTNodeExprStmt);

                Node->Header.Type = AST_EXPR_STATEMENT;
                Node->Header.Tok = GetTLS()->PARSER_STATE->CurrentIndex;
                Node->Expr = ParseExpr();
                ExpectToken(TOKEN_KIND_SEMICOLON);
                Result = StmtIndexOf(Node);
            }
        } break;
    }

    return Result;
}

StmtIndex
ParseBlock(void)
{
    ExpectToken(TOKEN_KIND_OPEN_BRACK);

    ScopeIndex Saved = GetTLS()->PARSER_STATE->CurrentScope;

    GetTLS()->PARSER_STATE->CurrentScope = ScopeEnter();

    StmtIndex Result = ParseStmtList();

    ScopeExit(GetTLS()->PARSER_STATE->CurrentScope);
    GetTLS()->PARSER_STATE->CurrentScope = Saved;
    ExpectToken(TOKEN_KIND_CLOSE_BRACK);

    return Result;
}

StmtIndex
ParseFor(void)
{
    ExpectToken(TOKEN_KIND_FOR);
    ExpectToken(TOKEN_KIND_OPEN_PAREN);

    ScopeIndex Saved = GetTLS()->PARSER_STATE->CurrentScope;

    GetTLS()->PARSER_STATE->CurrentScope = ScopeEnter();

    ASTNodeFor* Node = StmtAlloc(ASTNodeFor);
    StmtIndex Result = {GetTLS()->PARSER_STATE->Tree->StmtsCount - (u32) sizeof(ASTNodeFor)};

    Node->Header.Type = AST_FOR;
    Node->Init = {
        (i32) AST_NODE_INDEX_INVALID
    };
    Node->Cond = {
        (i32) AST_NODE_INDEX_INVALID
    };
    Node->Update = {
        (i32) AST_NODE_INDEX_INVALID
    };

    if (CurrentToken().Kind == TOKEN_KIND_SEMICOLON) {
        ConsumeToken();
    } else if (
        CurrentToken().Kind == TOKEN_KIND_IDENT && 
        PeekIsColon()
    ) {
        ParseDecl();
    } else if (CurrentToken().Kind == TOKEN_KIND_CONST) {
        ParseDecl();
    } else {
        Node->Init = ParseExpr();
        ExpectToken(TOKEN_KIND_SEMICOLON);
    }

    if (CurrentToken().Kind != TOKEN_KIND_SEMICOLON)
        Node->Cond = ParseExpr();

    ExpectToken(TOKEN_KIND_SEMICOLON);

    if (CurrentToken().Kind != TOKEN_KIND_ClOSE_PAREN)
        Node->Update = ParseExpr();

    ExpectToken(TOKEN_KIND_ClOSE_PAREN);
    ParseStmt();
    ScopeExit(GetTLS()->PARSER_STATE->CurrentScope);
    GetTLS()->PARSER_STATE->CurrentScope = Saved;

    return Result;
}

StmtIndex
ParseContinue(void)
{
    ExpectToken(TOKEN_KIND_CONTINUE);
    ExpectToken(TOKEN_KIND_SEMICOLON);

    ASTNodeHeader* Node = StmtAlloc(ASTNodeHeader);

    Node->Type = AST_CONTINUE;

    StmtIndex Result = StmtIndexOf(Node);

    return Result;
}

StmtIndex
ParseGoto(void)
{
    ExpectToken(TOKEN_KIND_GOTO);

    TokIndex LabelTokIndex = GetTLS()->PARSER_STATE->CurrentIndex;
    NameIndex Name = CurrentName();

    ExpectToken(TOKEN_KIND_DOLLAR_SIGN);
    ExpectToken(TOKEN_KIND_IDENT);
    ExpectToken(TOKEN_KIND_SEMICOLON);

    ASTNodeGoto* Node = StmtAlloc(ASTNodeGoto);

    Node->Header.Type = AST_GOTO;
    Node->Header.Tok = LabelTokIndex;
    Node->Name = Name;
    Node->Bind = {
        BINDING_INVALID_VALUE
    };

    StmtIndex Result = StmtIndexOf(Node);

    return Result;
}

StmtIndex 
ParseStmtList()
{
    u32 StartPosition = GetTLS()->PARSER_STATE->Tree->StmtsCount;
    u32 Count = 0;
    ASTNodeStmtList* Node = StmtAlloc(ASTNodeStmtList);
    StmtIndex Result = {StartPosition};

    Node->Header.Type = AST_STATEMENT_LIST;

    while (
        CurrentToken().Kind != TOKEN_KIND_CLOSE_BRACK &&
        CurrentToken().Kind != TOKEN_KIND_EOF
    ) {
        ParseStmt();
        ++Count;
    }

    Node->Count = Count;

    return Result;
}

InitIndex 
ParseInit()
{
    if (CurrentToken().Kind == TOKEN_KIND_OPEN_BRACK) {
        ConsumeToken();

        u32 StartPosition = GetTLS()->PARSER_STATE->Tree->InitsCount;
        ASTNodeInitialiserList* Node = InitAlloc(ASTNodeInitialiserList);
        u32 Count = 0;

        Node->Header.Type = AST_INITIALISER_LIST;

        InitIndex Result = {StartPosition};

        if (CurrentToken().Kind != TOKEN_KIND_CLOSE_BRACK) {
            do {
                ParseInit();
                ++Count;
            } while (MatchToken(TOKEN_KIND_COMMA));
        }

        Node->Count = Count;
        ExpectToken(TOKEN_KIND_CLOSE_BRACK);

        return Result;
    }

    u32 StartPosition = GetTLS()->PARSER_STATE->Tree->InitsCount;
    ASTNodeInitialiserExpr* Node = InitAlloc(ASTNodeInitialiserExpr);

    Node->Header.Type = AST_INITIALISER_EXPR;
    Node->Val = ParseAssign();

    InitIndex Result = {StartPosition};

    return Result;
}

TypeIndex
ParseType(void)
{
    u32 Mark = GetTLS()->PARSER_STATE->RecipeCount;
    TempArena Scratch = GetScratch(NULL, 0);
    TypeRecipeOp* Prefix = NULL;
    u32 PrefixCount = 0;
    TypeIndex Result = {
        TYPE_INDEX_INVALID_TYPE
    };
    b32 HaveAtom = FALSE;

    for (;;) {
        TypeRecipeOp Op = {};

        if (MatchToken(TOKEN_KIND_STAR)) {
            if (
                CurrentToken().Kind == TOKEN_KIND_OPEN_PAREN ||
                CurrentToken().Kind == TOKEN_KIND_ARROW
            ) {
                Result = ParseFuncSig(FALSE, NULL);

                if (Result.V != TYPE_INDEX_INVALID_TYPE)
                    Result = TypePtrTo(Result);
                else
                    RecipeEmit(TYPE_OP_PTR, 0, 0, 0);

                HaveAtom = TRUE;
                break;
            }

            Op.Op = TYPE_OP_PTR;
        } else if (MatchToken(TOKEN_KIND_OPEN_SQ_BRACK)) {
            Op.Op = TYPE_OP_ARR;

            if (CurrentToken().Kind != TOKEN_KIND_CLOSE_SQ_BRACK) {
                Token SizeTok = CurrentToken();

                if (SizeTok.Kind == TOKEN_KIND_NUMBER) {
                    Str8 RawSize = Str(
                        GetTLS()->PARSER_STATE->Source.Str + SizeTok.Offset,
                        SizeTok.Count
                    );

                    Op.Arg = SafeTruncateU64(U64FromStr(RawSize));
                    ConsumeToken();
                } else {
                    LogError(
                        "array size must be evaluable at the point of use, at offset %u",
                        SizeTok.Offset
                    );
                    ConsumeUntil(TOKEN_KIND_CLOSE_SQ_BRACK);
                }
            } else {
                Op.Flags = TYPE_FLAG_UNSIZED;
            }

            ExpectToken(TOKEN_KIND_CLOSE_SQ_BRACK);
        } else {
            break;
        }

        TypeRecipeOp* Stored = ArenaPushStruct(
            Scratch.MemPool,
            TypeRecipeOp
        );

        if (!Prefix)
            Prefix = Stored;

        *Stored = Op;
        ++PrefixCount;
    }

    if (!HaveAtom) {
        switch (CurrentToken().Kind) {
            default: {
                LogPanic(
                    "expected a type at offset %u, got kind %u instead",
                    CurrentToken().Offset,
                    CurrentToken().Kind
                );
                ASSERT_ALWAYS(FALSE);
            } break;

            case TOKEN_KIND_STRUCT: {
                Result = ParseAggregateType(TOKEN_KIND_STRUCT, TYPE_KIND_STRUCT);
            } break;

            case TOKEN_KIND_UNION: {
                Result = ParseAggregateType(TOKEN_KIND_UNION, TYPE_KIND_UNION);
            } break;

            case TOKEN_KIND_ENUM: {
                Result = ParseEnumType();
            } break;

            case TOKEN_KIND_IDENT: {
                TokIndex NameTok = GetTLS()->PARSER_STATE->CurrentIndex;
                NameIndex Name = CurrentName();

                ConsumeToken();

                BindIndex Bind = FindBinding(Name);
                TypeIndex Base = {
                    TYPE_INDEX_INVALID_TYPE
                };

                if (Bind.V != BINDING_INVALID_VALUE) {
                    Binding* B = &GetTLS()->SYMBOL_TABLE->Bindings[Bind.V];

                    if (
                        B->Kind == BINDING_KIND_VALUE ||
                        B->Kind == BINDING_KIND_FUNC
                    ) {
                        Token Tok = GetTLS()->PARSER_STATE->Tokens[NameTok.V];

                        LogError(
                            "\"%.*s\" is not a type at offset %u",
                            Tok.Count,
                            GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                            Tok.Offset
                        );
                        Base = {
                            BUILTIN_void
                        };
                    } else {
                        Base = B->Type;
                    }
                }

                if (MatchToken(TOKEN_KIND_OPEN_PAREN)) {
                    TypeIndex* Args = NULL;
                    u32 ArgCount = 0;
                    b32 ArgsAreResolved = TRUE;

                    do {
                        TypeIndex Arg = ParseType();
                        TypeIndex* Stored = ArenaPushStruct(
                            Scratch.MemPool,
                            TypeIndex
                        );

                        if (!Args)
                            Args = Stored;

                        *Stored = Arg;
                        ++ArgCount;

                        if (Arg.V == TYPE_INDEX_INVALID_TYPE)
                            ArgsAreResolved = FALSE;
                    } while (MatchToken(TOKEN_KIND_COMMA));

                    ExpectToken(TOKEN_KIND_ClOSE_PAREN);

                    if (Bind.V != BINDING_INVALID_VALUE && ArgsAreResolved) {
                        RecipeRelease(Mark);
                        Result = TypeInstance(
                            GetTLS()->SYMBOL_TABLE->Bindings[Bind.V].Decl,
                            Args,
                            ArgCount
                        );
                    } else {
                        RecipeEmit(
                            TYPE_OP_INST, 
                            Name.V, 
                            SafeTruncateU32(ArgCount), 
                            0
                        );
                    }
                } else if (Base.V != TYPE_INDEX_INVALID_TYPE) {
                    Result = Base;
                } else {
                    RecipeEmit(TYPE_OP_NAME, Name.V, 0, 0);
                }
            } break;
        }
    }

    if (Result.V != TYPE_INDEX_INVALID_TYPE) {
        RecipeRelease(Mark);

        for (u32 Index = PrefixCount; (Index--); ) {
            if (Prefix[Index].Op == TYPE_OP_PTR) {
                Result = TypePtrTo(Result);
            } else {
                Result = TypeArrayOf(
                    Result, 
                    Prefix[Index].Arg, 
                    !!(Prefix[Index].Flags & TYPE_FLAG_UNSIZED)
                );
            }
        }

        RecipeEmit(TYPE_OP_TYPE, Result.V, 0, 0);
    } else {
        for (u32 Index = PrefixCount; (Index--); ) {
            RecipeEmit(
                Prefix[Index].Op,
                Prefix[Index].Arg,
                0,
                Prefix[Index].Flags
            );
        }
    }

    ReleaseScratch(Scratch);

    return Result;
}

INTERNAL u32
AggregateFieldEntries(DeclIndex Field, OUT ASTField* Result)
{
    u8* Decls = GetTLS()->PARSER_STATE->Tree->Decls;
    ASTNodeDecl* FieldNode = (ASTNodeDecl*) (Decls + Field.V);
    ASTNodeHeader* Head = (ASTNodeHeader*) (Decls + FieldNode->FirstDecl.V);
    u32 Count = 0;

    if (Head->Type == AST_DECLARATOR_VALUED) {
        Head = (ASTNodeHeader*) (Decls + ((ASTNodeDeclValued*) Head)->Child.V);
    }

    NameIndex FieldName = ((ASTNodeDeclIdent*) Head)->Name;
    TypeIndex FieldType = FieldNode->Type;

    if (FieldName.V != ANON_NAME.V) {
        Count = 1;

        if (Result) {
            Result->Name = FieldName;
            Result->Decl = Field;
        }
    } else if (
        FieldType.V != TYPE_INDEX_INVALID_TYPE &&
        (
            TypeAt(FieldType)->Kind == TYPE_KIND_STRUCT ||
            TypeAt(FieldType)->Kind == TYPE_KIND_UNION
        )
    ) {
        ASTNodeDeclEx* Sub = (ASTNodeDeclEx*) (Decls + TypeAt(FieldType)->A);

        Count = Sub->Count;

        if (Result) {
            MemCpy(
                Result,
                Decls + Sub->SubDeclList.V,
                Count * sizeof(ASTField)
            );
        }
    }

    return Count;
}

INTERNAL u32
AggregateFieldEnd(DeclIndex Field)
{
    u8* Decls = GetTLS()->PARSER_STATE->Tree->Decls;
    ASTNodeDecl* FieldNode = (ASTNodeDecl*) (Decls + Field.V);
    ASTNodeHeader* Prev = (ASTNodeHeader*) (Decls + FieldNode->FirstDecl.V);
    u32 PrevSize = (Prev->Type == AST_DECLARATOR_VALUED)
        ? sizeof(ASTNodeDeclValued)
        : sizeof(ASTNodeDeclIdent);

    return FieldNode->FirstDecl.V + ALIGNTO(PrevSize, sizeof(u32));
}

TypeIndex
ParseAggregateType(u8 Keyword, TypeKind Kind)
{
    ExpectToken(Keyword);

    ScopeIndex Saved = GetTLS()->PARSER_STATE->CurrentScope;
    b32 IsAnonymous = GetTLS()->PARSER_STATE->AnonAggregate;

    GetTLS()->PARSER_STATE->AnonAggregate = FALSE;

    if (!IsAnonymous)
        GetTLS()->PARSER_STATE->CurrentScope = ScopeEnter();

    if (CurrentToken().Kind == TOKEN_KIND_OPEN_PAREN)
        ParseGenericParams();

    ExpectToken(TOKEN_KIND_OPEN_BRACK);

    u32 StartPosition = GetTLS()->PARSER_STATE->Tree->DeclsCount;
    ASTNodeDeclEx* Node = (ASTNodeDeclEx*) ASTNodeDeclAlloc(
        sizeof(ASTNodeDeclEx)
    );
    u32 Count = 0;

    Node->TagName.V = NAME_INDEX_INVALID_VALUE;
    Node->TagBind.V = BINDING_INVALID_VALUE;

    u32 FieldsCount = 0;

    while (CurrentToken().Kind != TOKEN_KIND_CLOSE_BRACK) {
        if (CurrentToken().Kind == TOKEN_KIND_EOF) {
            LogPanic("unterminated aggregate body"_s8);
            ASSERT_ALWAYS(FALSE);
        }

        FieldsCount += AggregateFieldEntries(ParseDecl(), NULL);
        ++Count;
    }

    ExpectToken(TOKEN_KIND_CLOSE_BRACK);

    if (!Count) {
        LogPanic("aggregate body must hold at least one field"_s8);
        ASSERT_ALWAYS(FALSE);
    }

    u32 TablePosition = GetTLS()->PARSER_STATE->Tree->DeclsCount;
    ASTField* Table = (ASTField*) ASTNodeDeclAlloc(
        FieldsCount * sizeof(ASTField)
    );
    u32 Filled = 0;
    DeclIndex Cursor = {
        StartPosition + SafeTruncateU64(ALIGNTO(sizeof(ASTNodeDeclEx), sizeof(u32)))
    };

    for (u32 Index = 0; Index < Count; ++Index) {
        Filled += AggregateFieldEntries(Cursor, Table + Filled);
        Cursor.V = AggregateFieldEnd(Cursor);
    }

    ASSERT(Filled == FieldsCount);

    Node = (ASTNodeDeclEx*) (GetTLS()->PARSER_STATE->Tree->Decls + StartPosition);
    Node->Count = FieldsCount;
    Node->SubDeclList.V = TablePosition;

    if (!IsAnonymous) {
        ScopeExit(GetTLS()->PARSER_STATE->CurrentScope);
        GetTLS()->PARSER_STATE->CurrentScope = Saved;
    }

    DeclIndex ResultDecl = {
        StartPosition
    };

    return TypeNominal(Kind, ResultDecl);
}

TypeIndex
ParseEnumType(void)
{
    ExpectToken(TOKEN_KIND_ENUM);

    TypeIndex Underlying = {
        TYPE_INDEX_INVALID_TYPE
    };

    if (MatchToken(TOKEN_KIND_OPEN_PAREN)) {
        TokIndex UnderlyingTok = GetTLS()->PARSER_STATE->CurrentIndex;
        u32 Mark = GetTLS()->PARSER_STATE->RecipeCount;

        Underlying = ParseType();
        RecipeRelease(Mark);

        if (Underlying.V == TYPE_INDEX_INVALID_TYPE) {
            LogError(
                "enum backing type must be declared before use, at offset %u",
                GetTLS()->PARSER_STATE->Tokens[UnderlyingTok.V].Offset
            );
        }

        ExpectToken(TOKEN_KIND_ClOSE_PAREN);
    }

    ExpectToken(TOKEN_KIND_OPEN_BRACK);

    u32 StartPosition = GetTLS()->PARSER_STATE->Tree->DeclsCount;
    ASTNodeDeclEx* Node = (ASTNodeDeclEx*) ASTNodeDeclAlloc(
        sizeof(ASTNodeDeclEx)
    );
    TypeIndex EnumType = TypeEnum(
        {
            StartPosition
        },
        Underlying
    );
    u32 Count = 0;

    Node->TagName = {
        NAME_INDEX_INVALID_VALUE
    };
    Node->TagBind = {
        BINDING_INVALID_VALUE
    };

    while (CurrentToken().Kind != TOKEN_KIND_CLOSE_BRACK) {
        TokIndex MemberTokIndex = GetTLS()->PARSER_STATE->CurrentIndex;
        NameIndex MemberName = CurrentName();

        ExpectToken(TOKEN_KIND_IDENT);

        ASTNodeEnum* MemberNode = (ASTNodeEnum*) ASTNodeDeclAlloc(
            sizeof(ASTNodeEnum)
        );
        DeclIndex MemberDecl = DeclIndexOf(MemberNode);

        MemberNode->Name = MemberName;
        MemberNode->Bind = {
            BINDING_INVALID_VALUE
        };
        MemberNode->ConstExpr = {
            (i32) AST_NODE_INDEX_INVALID
        };

        if (MatchToken(TOKEN_KIND_EQUAL))
            MemberNode->ConstExpr = ParseExpr();

        MemberNode->Bind = AddBinding(
            GetTLS()->PARSER_STATE->CurrentScope, 
            MemberName, 
            MemberDecl,
            EnumType,
            BINDING_KIND_VALUE
        );

        if (MemberNode->Bind.V == BINDING_INVALID_VALUE) {
            Token Tok = GetTLS()->PARSER_STATE->Tokens[MemberTokIndex.V];

            LogError(
                "redeclaration of \"%.*s\" at offset %u",
                Tok.Count,
                GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                Tok.Offset
            );
        }

        ++Count;

        if (!MatchToken(TOKEN_KIND_COMMA))
            break;
    }

    ExpectToken(TOKEN_KIND_CLOSE_BRACK);

    if (!Count) {
        LogPanic("enum body must hold at least one member");
        ASSERT_ALWAYS(FALSE);
    }

    Node = (ASTNodeDeclEx*) (GetTLS()->PARSER_STATE->Tree->Decls + StartPosition);
    Node->Count = Count;

    return EnumType;
}

void
ParseMod(void)
{
    ExpectToken(TOKEN_KIND_MOD);
    ExpectToken(TOKEN_KIND_IDENT);
    ExpectToken(TOKEN_KIND_SEMICOLON);
}

void
ParseImport(void)
{
    ExpectToken(TOKEN_KIND_IMPORT);
    ExpectToken(TOKEN_KIND_IDENT);
    ExpectToken(TOKEN_KIND_SEMICOLON);
}

void
ParseProg(void)
{
    if (CurrentToken().Kind == TOKEN_KIND_MOD)
        ParseMod();

    while (CurrentToken().Kind == TOKEN_KIND_IMPORT)
        ParseImport();

    while (CurrentToken().Kind != TOKEN_KIND_EOF)
        ParseDecl();

    ResolveDeferredTypes();

    while (GetTLS()->PARSER_STATE->PendingHead < GetTLS()->PARSER_STATE->PendingCount) {
        PendingBody Body = GetTLS()->PARSER_STATE->Pending[GetTLS()->PARSER_STATE->PendingHead++];

        GetTLS()->PARSER_STATE->CurrentIndex = Body.BodyStart;
        GetTLS()->PARSER_STATE->CurrentScope = ScopeEnter();
        RebindParams(Body.Decl);
        GetTLS()->PARSER_STATE->CurrentFunc = Body.FuncBind;
        ExpectToken(TOKEN_KIND_OPEN_BRACK);
        ++GetTLS()->PARSER_STATE->FuncDepth;

        ASTNodeDecl* DeclNode = (ASTNodeDecl*) (GetTLS()->PARSER_STATE->Tree->Decls + Body.Decl.V);
        ASTNodeDeclValued* ValuedNode = DeclAlloc(ASTNodeDeclValued);

        ValuedNode->Header.Type = AST_DECLARATOR_VALUED;
        ValuedNode->Child = DeclNode->FirstDecl;
        ValuedNode->Func = ParseStmtList();
        DeclNode->FirstDecl = DeclIndexOf(ValuedNode);
        ExpectToken(TOKEN_KIND_CLOSE_BRACK);
        --GetTLS()->PARSER_STATE->FuncDepth;
        ScopeExit(GetTLS()->PARSER_STATE->CurrentScope);
        GetTLS()->PARSER_STATE->CurrentScope = GetTLS()->PARSER_STATE->ModuleScope;
    }

    ResolveDeferredTypes();
    ResolveDeferred();
}

DeclIndex 
ParseDecl(void)
{
    if (CurrentToken().Kind == TOKEN_KIND_TYPE) {
        ConsumeToken();

        TokIndex NameTokIndex = GetTLS()->PARSER_STATE->CurrentIndex;
        NameIndex Name = CurrentName();

        ExpectToken(TOKEN_KIND_IDENT);
        ExpectToken(TOKEN_KIND_COLON);

        u32 StartPosition = GetTLS()->PARSER_STATE->Tree->DeclsCount;
        ASTNodeDeclType* Node = DeclAlloc(ASTNodeDeclType);

        Node->Header.Type = AST_DECLARATOR_TYPE;
        Node->Header.Tok = NameTokIndex;

        u32 Mark = GetTLS()->PARSER_STATE->RecipeCount;
        TypeIndex Underlying = ParseType();

        Node = (ASTNodeDeclType*) (GetTLS()->PARSER_STATE->Tree->Decls + StartPosition);
        Node->Type = Underlying;
        ExpectToken(TOKEN_KIND_SEMICOLON);

        BindIndex Bind = AddBinding(
            GetTLS()->PARSER_STATE->CurrentScope,
            Name,
            {
                StartPosition
            },
            Underlying,
            BINDING_KIND_TYPE
        );

        if (Underlying.V == TYPE_INDEX_INVALID_TYPE) {
            DeferType(
                Mark,
                Bind,
                StartPosition + SafeTruncateU64(OFFSETOF(ASTNodeDeclType, Type)),
                NameTokIndex
            );
        }

        RecipeRelease(Mark);

        if (Bind.V == BINDING_INVALID_VALUE) {
            Token Tok = GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V];

            LogError(
                "redeclaration of \"%.*s\" at offset %u",
                Tok.Count,
                GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                Tok.Offset
            );
        }

        DeclIndex Result = {
            StartPosition
        };

        return Result;
    }

    b32 IsConst = FALSE;

    if (CurrentToken().Kind == TOKEN_KIND_CONST) {
        ConsumeToken();
        IsConst = TRUE;
    }

    TokIndex NameTokIndex = {};
    NameIndex Name = ParseDeclName(&NameTokIndex);
    b32 IsOp = IsOpNameTok(NameTokIndex);
    b32 IsAnonymous = Name.V == ANON_NAME.V;
    b32 IsFunc = (
        CurrentToken().Kind == TOKEN_KIND_COLON &&
        (
            PeekToken().Kind == TOKEN_KIND_OPEN_PAREN ||
            PeekToken().Kind == TOKEN_KIND_ARROW
        )
    );

    ExpectToken(TOKEN_KIND_COLON);

    if (IsOp && !IsFunc) {
        LogPanic(
            "an operator declaration must be a function, at offset %u",
            GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V].Offset
        );
        ASSERT_ALWAYS(FALSE);
    }

    if (IsAnonymous && IsFunc) {
        LogPanic(
            "a function cannot be anonymous, at offset %u",
            GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V].Offset
        );
        ASSERT_ALWAYS(FALSE);
    }

    u32 DeclPosition = GetTLS()->PARSER_STATE->Tree->DeclsCount;
    ASTNodeDecl* DeclNode = DeclAlloc(ASTNodeDecl);

    DeclNode->Header.Type = AST_DECLARATION;
    DeclNode->Header.Tok = NameTokIndex;
    DeclNode->Type = {TYPE_INDEX_INVALID_TYPE};
    DeclNode->DeclCount = 1;

    if (IsFunc) {
        if (IsConst) {
            LogPanic(
                "const is not permitted on a function at offset %u",
                GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V].Offset
            );
            ASSERT_ALWAYS(FALSE);
        }

        BindIndex FuncBind = AddFuncBinding(
            GetTLS()->PARSER_STATE->CurrentScope, 
            Name, 
            {
                DeclPosition
            },
            {
                TYPE_INDEX_INVALID_TYPE
            }
        );

        if (FuncBind.V == BINDING_INVALID_VALUE) {
            Token Tok = GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V];

            LogError(
                "redeclaration of \"%.*s\" at offset %u",
                Tok.Count,
                GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                Tok.Offset
            );
        }

        ScopeIndex Saved = GetTLS()->PARSER_STATE->CurrentScope;

        GetTLS()->PARSER_STATE->CurrentScope = ScopeEnter();

        u32 Mark = GetTLS()->PARSER_STATE->RecipeCount;
        DeclIndex Sig = {};
        TypeIndex FuncType = ParseFuncSig(TRUE, &Sig);

        DeclNode->FirstDecl = Sig;
        DeclNode->Type = FuncType;

        if (IsOp && IsAssignOpName(NameTokIndex, Name)) {
            ASTNodeDeclFunc* SigNode = (ASTNodeDeclFunc*) (
                GetTLS()->PARSER_STATE->Tree->Decls + Sig.V
            );
            b32 FirstIsPtr = FALSE;

            if (
                SigNode->Header.Count && 
                SigNode->Param[0].V != AST_NODE_INDEX_INVALID
            ) {
                ASTNodeDeclIdent* First = (ASTNodeDeclIdent*) (
                    GetTLS()->PARSER_STATE->Tree->Decls + SigNode->Param[0].V
                );

                if (First->Bind.V != BINDING_INVALID_VALUE) {
                    TypeIndex FirstType = GetTLS()->SYMBOL_TABLE->Bindings[First->Bind.V].Type;

                    FirstIsPtr = (
                        FirstType.V == TYPE_INDEX_INVALID_TYPE ||
                        TypeAt(FirstType)->Kind == TYPE_KIND_PTR
                    );
                }
            }

            if (!FirstIsPtr) {
                LogError(
                    "assigning operator requires first parameter to be a pointer, at offset %u",
                    GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V].Offset
                );
            }
        }

        if (FuncType.V != TYPE_INDEX_INVALID_TYPE) {
            if (FuncBind.V != BINDING_INVALID_VALUE)
                GetTLS()->SYMBOL_TABLE->Bindings[FuncBind.V].Type = FuncType;
        } else {
            DeferType(
                Mark,
                FuncBind,
                DeclPosition + SafeTruncateU64(OFFSETOF(ASTNodeDecl, Type)),
                NameTokIndex
            );
        }

        RecipeRelease(Mark);
        ExpectToken(TOKEN_KIND_OPEN_BRACK);
        --GetTLS()->PARSER_STATE->CurrentIndex.V;

        if (GetTLS()->PARSER_STATE->FuncDepth) {
            TokIndex BodyStart = SkipBraceBody();

            QueueBody(
                BodyStart, 
                {
                    DeclPosition
                },
                FuncBind
            );
            ScopeExit(GetTLS()->PARSER_STATE->CurrentScope);
            GetTLS()->PARSER_STATE->CurrentScope = Saved;

            return {DeclPosition};
        }

        ConsumeToken();
        ++GetTLS()->PARSER_STATE->FuncDepth;

        BindIndex SavedFunc = GetTLS()->PARSER_STATE->CurrentFunc;

        GetTLS()->PARSER_STATE->CurrentFunc = FuncBind;

        ASTNodeDeclValued* ValuedNode = DeclAlloc(ASTNodeDeclValued);

        ValuedNode->Header.Type = AST_DECLARATOR_VALUED;
        ValuedNode->Child = Sig;
        ValuedNode->Func = ParseStmtList();
        ExpectToken(TOKEN_KIND_CLOSE_BRACK);
        GetTLS()->PARSER_STATE->CurrentFunc = SavedFunc;
        --GetTLS()->PARSER_STATE->FuncDepth;
        ScopeExit(GetTLS()->PARSER_STATE->CurrentScope);
        GetTLS()->PARSER_STATE->CurrentScope = Saved;

        DeclIndex Result = {
            DeclPosition
        };

        return Result;
    }

    u32 Mark = GetTLS()->PARSER_STATE->RecipeCount;
    TypeIndex VarType = {
        TYPE_INDEX_INVALID_TYPE
    };
    b32 IsInferred = TRUE;

    if (CurrentToken().Kind != TOKEN_KIND_EQUAL) {
        IsInferred = FALSE;
        GetTLS()->PARSER_STATE->AnonAggregate = (
            IsAnonymous &&
            (
                CurrentToken().Kind == TOKEN_KIND_STRUCT ||
                CurrentToken().Kind == TOKEN_KIND_UNION
            )
        );
        VarType = ParseType();
        DeclNode->Type = VarType;
    }

    ASTNodeDeclIdent* IdentNode = DeclAlloc(ASTNodeDeclIdent);
    DeclIndex FullDeclarator = DeclIndexOf(IdentNode);

    IdentNode->Header.Type = AST_DECLARATOR_IDENT;
    IdentNode->Header.Tok = NameTokIndex;
    IdentNode->Name = Name;
    IdentNode->Bind = {BINDING_INVALID_VALUE};

    if (MatchToken(TOKEN_KIND_EQUAL)) {
        InitIndex Init = ParseInit();
        ASTNodeDeclValued* ValuedNode = DeclAlloc(ASTNodeDeclValued);

        ValuedNode->Header.Type = AST_DECLARATOR_VALUED;
        ValuedNode->Child = FullDeclarator;
        ValuedNode->Init = Init;
        FullDeclarator = DeclIndexOf(ValuedNode);
    } else if (IsConst) {
        LogPanic(
            "const declaration requires a value at offset %u",
            GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V].Offset
        );
        ASSERT_ALWAYS(FALSE);
    }

    ExpectToken(TOKEN_KIND_SEMICOLON);
    DeclNode->FirstDecl = FullDeclarator;

    if (IsAnonymous) {
        RecipeRelease(Mark);

        DeclIndex AnonResult = {
            DeclPosition
        };

        return AnonResult;
    }

    IdentNode->Bind = AddBinding(
        GetTLS()->PARSER_STATE->CurrentScope, 
        Name, 
        {
            DeclPosition
        },
        VarType,
        BINDING_KIND_VALUE
    );

    if (IdentNode->Bind.V != BINDING_INVALID_VALUE) {
        PushWork(
            (CHECK_WORK_KIND_BIND << CHECK_WORK_KIND_OFFSET) |
            IdentNode->Bind.V
        );
    }

    if (!IsInferred && VarType.V == TYPE_INDEX_INVALID_TYPE) {
        DeferType(
            Mark,
            IdentNode->Bind,
            DeclPosition + SafeTruncateU64(OFFSETOF(ASTNodeDecl, Type)),
            NameTokIndex
        );
    }

    RecipeRelease(Mark);

    if (IdentNode->Bind.V == BINDING_INVALID_VALUE) {
        Token Tok = GetTLS()->PARSER_STATE->Tokens[NameTokIndex.V];

        LogError(
            "redeclaration of \"%.*s\" at offset %u",
            Tok.Count,
            GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
            Tok.Offset
        );
    }

    DeclIndex Result = {
        DeclPosition
    };

    return Result;
}

void
ParseGenericParams(void)
{
    ExpectToken(TOKEN_KIND_OPEN_PAREN);

    u32 Ordinal = 0;

    do {
        TokIndex ParamTokIndex = GetTLS()->PARSER_STATE->CurrentIndex;
        NameIndex ParamName = CurrentName();

        ExpectToken(TOKEN_KIND_IDENT);

        BindIndex Bind = AddBinding(
            GetTLS()->PARSER_STATE->CurrentScope, 
            ParamName,
            {
                AST_NODE_INDEX_INVALID
            },
            {
                TYPE_INDEX_INVALID_TYPE
            },
            BINDING_KIND_GENERIC
        );

        if (Bind.V == BINDING_INVALID_VALUE) {
            Token Tok = GetTLS()->PARSER_STATE->Tokens[ParamTokIndex.V];

            LogError(
                "duplicate generic parameter \"%.*s\" at offset %u",
                Tok.Count,
                GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                Tok.Offset
            );
        } else {
            GetTLS()->SYMBOL_TABLE->Bindings[Bind.V].Type = TypeParam(Bind, Ordinal);
        }

        ++Ordinal;
    } while (MatchToken(TOKEN_KIND_COMMA));

    ExpectToken(TOKEN_KIND_ClOSE_PAREN);
}

TypeIndex
ParseFuncSig(b32 IsDefinition, OUT DeclIndex* Sig)
{
    u32 Mark = GetTLS()->PARSER_STATE->RecipeCount;

    if (
        CurrentToken().Kind == TOKEN_KIND_OPEN_PAREN &&
        PeekToken().Kind == TOKEN_KIND_IDENT &&
        (
            PeekToken(2).Kind == TOKEN_KIND_COMMA ||
            PeekToken(2).Kind == TOKEN_KIND_ClOSE_PAREN
        )
    ) {
        ParseGenericParams();
    }

    u32 ParamCount = CountParams();

    ExpectToken(TOKEN_KIND_OPEN_PAREN);

    TempArena Scratch = GetScratch(NULL, 0);
    TypeIndex* ParamTypes = ArenaPushArray(
        Scratch.MemPool,
        TypeIndex,
        ParamCount + 1
    );
    u32 StartPosition = GetTLS()->PARSER_STATE->Tree->DeclsCount;
    ASTNodeDeclFunc* Node = NULL;
    u32 Count = 0;
    b32 IsResolved = TRUE;

    if (IsDefinition) {
        u32 NodeSize = (
            SafeTruncateU64(OFFSETOF(ASTNodeDeclFunc, Param)) +
            ParamCount * SafeTruncateU64(sizeof(DeclIndex))
        );

        Node = (ASTNodeDeclFunc*) ASTNodeDeclAlloc(NodeSize);
        Node->Header.Type = AST_DECLARATOR_FUNCTION;
        Node->Header.Count = ParamCount;

        for (u32 Index = 0; Index < ParamCount; ++Index) {
            Node->Param[Index] = {
                AST_NODE_INDEX_INVALID
            };
        }
    }

    if (CurrentToken().Kind != TOKEN_KIND_ClOSE_PAREN) {
        do {
            b32 ParamIsConst = MatchToken(TOKEN_KIND_CONST);
            TokIndex ParamTokIndex = GetTLS()->PARSER_STATE->CurrentIndex;
            NameIndex ParamName = CurrentName();

            ExpectToken(TOKEN_KIND_IDENT);
            ExpectToken(TOKEN_KIND_COLON);

            u32 ParamMark = GetTLS()->PARSER_STATE->RecipeCount;
            TypeIndex ParamType = ParseType();

            ASSERT(Count < ParamCount);

            ParamTypes[Count + 1] = ParamType;

            if (ParamType.V == TYPE_INDEX_INVALID_TYPE)
                IsResolved = FALSE;

            if (IsDefinition) {
                ASTNodeDeclIdent* ParamIdent = DeclAlloc(ASTNodeDeclIdent);
                DeclIndex ParamDecl = DeclIndexOf(ParamIdent);

                ParamIdent->Header.Type = AST_DECLARATOR_IDENT;
                ParamIdent->Header.Tok = ParamTokIndex;
                ParamIdent->Header.Flags = ParamIsConst * AST_DECL_FLAG_CONST;
                ParamIdent->Name = ParamName;
                ParamIdent->Bind = {
                    BINDING_INVALID_VALUE
                };

                if (MatchToken(TOKEN_KIND_EQUAL))
                    ParseInit();

                Node = (ASTNodeDeclFunc*) (GetTLS()->PARSER_STATE->Tree->Decls + StartPosition);
                Node->Param[Count] = ParamDecl;

                if (ParamName.V == ANON_NAME.V) {
                    ++Count;
                    continue;
                }

                ParamIdent->Bind = AddBinding(
                    GetTLS()->PARSER_STATE->CurrentScope,
                    ParamName,
                    ParamDecl,
                    ParamType,
                    BINDING_KIND_VALUE
                );

                if (ParamIdent->Bind.V == BINDING_INVALID_VALUE) {
                    Token Tok = GetTLS()->PARSER_STATE->Tokens[ParamTokIndex.V];

                    LogError(
                        "duplicate parameter \"%.*s\" at offset %u",
                        Tok.Count,
                        GetTLS()->PARSER_STATE->Source.Str + Tok.Offset,
                        Tok.Offset
                    );
                } else if (ParamType.V == TYPE_INDEX_INVALID_TYPE) {
                    DeferType(
                        ParamMark, 
                        ParamIdent->Bind, 
                        AST_NODE_INDEX_INVALID, 
                        ParamTokIndex
                    );
                }
            } else if (MatchToken(TOKEN_KIND_EQUAL)) {
                ParseInit();
            }

            ++Count;
        } while (MatchToken(TOKEN_KIND_COMMA));
    }

    ExpectToken(TOKEN_KIND_ClOSE_PAREN);

    if (IsDefinition) {
        Node = (ASTNodeDeclFunc*) (GetTLS()->PARSER_STATE->Tree->Decls + StartPosition);
        Node->Header.Count = Count;
    }

    TypeIndex Return = {
        BUILTIN_void
    };

    if (MatchToken(TOKEN_KIND_ARROW))
        Return = ParseType();
    else
        RecipeEmit(TYPE_OP_TYPE, BUILTIN_void, 0, 0);

    TypeIndex Result = {
        TYPE_INDEX_INVALID_TYPE
    };

    if (IsResolved && Return.V != TYPE_INDEX_INVALID_TYPE) {
        RecipeRelease(Mark);
        ParamTypes[0] = Return;
        Result = TypeFunc(ParamTypes, Count);
        RecipeEmit(TYPE_OP_TYPE, Result.V, 0, 0);
    } else {
        RecipeEmit(TYPE_OP_FUNC, 0, SafeTruncateU32(Count), 0);
    }

    ReleaseScratch(Scratch);

    if (Sig)
        (*Sig).V = StartPosition;

    return Result;
}

AST*
ParseTokens(Arena* MemPool, TokenArray* Tokens, Str8 Source)
{
    AST* Tree;

    GetTLS()->PARSER_STATE = ArenaPushArrayZero(MemPool, ParserState, 1);
    GetTLS()->PARSER_STATE->StmtMemPool = ArenaAllocEx();
    GetTLS()->PARSER_STATE->DeclMemPool = ArenaAllocEx();
    GetTLS()->PARSER_STATE->InitMemPool = ArenaAllocEx();
    GetTLS()->PARSER_STATE->DeferredMemPool = ArenaAllocEx(GB(1));
    GetTLS()->PARSER_STATE->PendingMemPool = ArenaAllocEx(GB(1));
    GetTLS()->PARSER_STATE->RecipeMemPool = ArenaAllocEx(GB(1));
    GetTLS()->PARSER_STATE->DeferredTypeMemPool = ArenaAllocEx(GB(1));
    GetTLS()->PARSER_STATE->WorkMemPool = ArenaAllocEx(GB(1));
    GetTLS()->PARSER_STATE->DeferredOpMemPool = ArenaAllocEx(GB(1));
    GetTLS()->PARSER_STATE->Recipe = (TypeRecipeOp*) ArenaExBase(GetTLS()->PARSER_STATE->RecipeMemPool);
    GetTLS()->PARSER_STATE->DeferredTypes = (DeferredType*) ArenaExBase(GetTLS()->PARSER_STATE->DeferredTypeMemPool);
    GetTLS()->PARSER_STATE->DeferredOps = (TypeRecipeOp*) ArenaExBase(GetTLS()->PARSER_STATE->DeferredOpMemPool);
    GetTLS()->PARSER_STATE->CurrentFunc.V = BINDING_INVALID_VALUE;
    ArenaExInit(&GetTLS()->PARSER_STATE->ExprMemPool, EXPR_ARENA_RESERVE_SIZE);
    Tree = ArenaPushArrayZero(MemPool, AST, 1);
    Tree->MemPool = MemPool;
    Tree->Stmts = ArenaExBase(GetTLS()->PARSER_STATE->StmtMemPool);
    Tree->Exprs = GetTLS()->PARSER_STATE->ExprMemPool.End;
    Tree->Decls = ArenaExBase(GetTLS()->PARSER_STATE->DeclMemPool);
    Tree->Inits = ArenaExBase(GetTLS()->PARSER_STATE->InitMemPool);
    Tree->Work = (i32*) ArenaExBase(GetTLS()->PARSER_STATE->WorkMemPool);
    GetTLS()->PARSER_STATE->Tree = Tree;
    GetTLS()->PARSER_STATE->Tokens = Tokens->Tokens;
    GetTLS()->PARSER_STATE->TokenNames = Tokens->Names;
    GetTLS()->PARSER_STATE->Source = Source;
    GetTLS()->PARSER_STATE->CurrentIndex = {};
    GetTLS()->PARSER_STATE->Deferred = (DeferredIdent*) ArenaExBase(GetTLS()->PARSER_STATE->DeferredMemPool);
    GetTLS()->PARSER_STATE->Pending = (PendingBody*) ArenaExBase(GetTLS()->PARSER_STATE->PendingMemPool);
    GetTLS()->PARSER_STATE->ModuleScope = ScopeEnter();
    GetTLS()->PARSER_STATE->CurrentScope = GetTLS()->PARSER_STATE->ModuleScope;
    ParseProg();
    Tree->ExprsCount = GetTLS()->PARSER_STATE->ExprCount;

    return GetTLS()->PARSER_STATE->Tree;
}