Goose  Check-in [7d2def7b75]

#include "builtins/builtins.h"
#include "eir/eir.h"

using namespace goose;

namespace goose::builtins
{
    void SetupApiCGFunc( Env& e )
    {

#include "builtins/builtins.h"
#include "eir/eir.h"
#include "lld/Common/Driver.h"
#include "llvm/Support/raw_os_ostream.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::builtins;

namespace
{
    bool BuildArgArrayFromTuple( const Value& tup, vector< string >& array )
    {
        if( !IsTuple( tup ) )

#include "builtins/builtins.h"
#include "eir/eir.h"

using namespace goose;

namespace goose::builtins
{
    void SetupApiCGMangle( Env& e )
    {
        RegisterBuiltinFunc< string ( Value ) >( e, "CGMangle"_sid,
            []( const Value& v ) -> string
            {
                auto func = FromValue< Func >( v );
                if( !func )
                    return "";

                if( !func->cir() )
                    return "";

                auto result = codegen::Mangle( func->cir()->identity() );
                if( !result )
                    return "";

                return *result;
            } );
    }
}

#include "builtins/builtins.h"
#include "eir/eir.h"

namespace goose::builtins
{
    void SetupApiCGModule( Env& e )
    {
        RegisterBuiltinFunc< ptr< codegen::Module > ( string ) >( e, "CGModuleCreate"_sid,
            []( const string& name )

            []( const ptr< codegen::Module >& module, const string& filename )
            {
                return module->emitToFile( filename, llvm::CGFT_ObjectFile );
            } );
    }
}

namespace goose::eir
{
    const Term& Bridge< ptr< codegen::Module > >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( ct_type ), TSID( cg_module ) ) ) );
        return type;
    }

#ifndef GOOSE_BUILTINS_API_CODEGEN_MODULE_H
#define GOOSE_BUILTINS_API_CODEGEN_MODULE_H

namespace goose::builtins
{
    extern void SetupApiCGModule( Env& e );
}

namespace goose::eir
{
    template<>
    struct Bridge< ptr< codegen::Module > >
    {
        static const Term& Type();
        static Value ToValue( const ptr< codegen::Module >& os );
        static optional< ptr< codegen::Module > > FromValue( const Value& v );

                auto funcIdentity = AppendToVectorTerm( builtins::RootIdentity(),
                    TERM( StringId( Env::NewUniqueId() ) ) );

                c.env()->addVisibilityRule( builtins::RootIdentity(), funcIdentity );

                auto func = BuildFunc( localC, ftype, funcIdentity, params, nullptr, c );
                const auto& pFuncCIR = func.cir();

                auto cfg = Compiler::LoadAndParseFile( pEnv.lock(), filename, funcIdentity,
                    ftype.returnType(), defReturnValue );

                if( !cfg )
                    return PoisonValue();

                if( cfg->isPoisoned() )
                    return PoisonValue();

                pFuncCIR->body() = cfg;
                return ToValue( func );
            } );
    }
}

#include "builtins/builtins.h"
#include "eir/eir.h"

namespace goose::eir
{
    const Term& Bridge< ptr< sema::CodeBuilder > >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( ct_type ), TSID( ext_codebuilder ) ) ) );
        return type;
    }

#ifndef GOOSE_BUILTINS_API_EXTENSIBILITY_CODEBUILDER_H
#define GOOSE_BUILTINS_API_EXTENSIBILITY_CODEBUILDER_H

namespace goose::eir
{
    template<>
    struct Bridge< ptr< sema::CodeBuilder > >
    {
        static const Term& Type();
        static Value ToValue( const ptr< sema::CodeBuilder >& cb );
        static optional< ptr< sema::CodeBuilder > > FromValue( const Value& v );

#include "builtins/builtins.h"
#include "eir/eir.h"

using namespace goose::builtins;

namespace goose::eir
{
    const Term& Bridge< TermWrapper >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( ct_type ), TSID( ext_termwrapper ) ) ) );
        return type;
    }

            }

        private:
            Term m_term;
    };
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::TermWrapper >
    {
        static const Term& Type();
        static Value ToValue( const builtins::TermWrapper& tw );
        static optional< Term > FromValue( const Value& v );

#include "builtins/builtins.h"
#include "eir/eir.h"

using namespace goose::builtins;

namespace goose::eir
{
    const Term& Bridge< ValueWrapper >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( ct_type ), TSID( ext_valuewrapper ) ) ) );
        return type;
    }

            }

        private:
            Value m_value;
    };
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::ValueWrapper >
    {
        static const Term& Type();
        static Value ToValue( const builtins::ValueWrapper& vw );
        static optional< Value > FromValue( const Value& v );

#include "builtins/builtins.h"
#include "eir/eir.h"

using namespace goose;

namespace goose::builtins
{
    void SetupApiCastFuncs( Env& e )
    {

#include "builtins/builtins.h"
#include "eir/eir.h"
#include "parse/parse.h"

using namespace goose;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupApiVerificationFuncs( Env& e )
    {
        RegisterBuiltinFunc< Intrinsic< Value ( bool ) > >( e, "assert"_sid,
            []( const Context& c, const Value& cond )
            {
                return BuildComputedValue( GetValueType< void >(),
                    cir::Assert( cond ) );
            } );
    }
}

#ifndef GOOSE_BUILTINS_H
#define GOOSE_BUILTINS_H

#include "eir/eir.h"
#include "cir/cir.h"
#include "sema/sema.h"
#include "diagnostics/diagnostics.h"

namespace goose::builtins
{
    using namespace eir;
    using namespace sema;
    using namespace diagnostics;

    extern const Term& RootIdentity();
}

#include "codegen/codegen.h"

#ifndef GOOSE_BUILTINS_EXPRBUILDER_H
#define GOOSE_BUILTINS_EXPRBUILDER_H

#include "parse/parse.h"

namespace goose::builtins::exprbuilder
{
    template< typename V >
    Value Not( V&& val )
    {
        return BuildComputedValue( GetValueType< bool >(),
            cir::Not( forward< V >( val ) ) ).setLocationId( val.locationId() );
    }

    template< typename L, typename R >
    Value Or( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::Or( forward< L >( lhs ), forward< R >( rhs ) ) );
    }

    template< typename L, typename R >
    Value And( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::And( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value Eq( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::Eq( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value Neq( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::Neq( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value UGT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::UGT( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value UGE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::UGE( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value ULT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::ULT( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value ULE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::ULE( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SGT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::SGT( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SGE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::SGE( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SLT( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::SLT( forward< L >( lhs ), forward< R >( rhs ) ) ).setLocationId( locId );
    }

    template< typename L, typename R >
    Value SLE( L&& lhs, R&& rhs )
    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue( GetValueType< bool >(),
            cir::SLE( forward< L >( lhs ), forward< R >( rhs ) ) );
    }
}

#endif

#include "builtins/builtins.h"
#include "builtins/helpers.h"

using namespace goose::parse;

namespace goose::builtins
{
    void RegisterRule( sema::Env& env, const StringId& name, parse::Rule&& rule )
    {
        parse::RegisterRule( env, AppendToVectorTerm( RootIdentity(), TERM( name ) ), move( rule ) );
    }

    ptr< cir::BasicBlock > ParseSubStatement( Parser& p, uint32_t precedence )
    {
        auto next = p.resolver()->lookAheadUnresolved();
        if( !next )
            return nullptr;

        auto np = p.makeNestedParser();

    extern void RegisterRule( sema::Env& env, const StringId& name, parse::Rule&& rule );

    // Utility function used to parse flow control statements, such as if and loops.
    // This parses a sub statement, which can be enclosed in a brace block or not.
    // It will get its own scope, with visibility rules setup to see the current
    // scope.
    // It returns a pointer to the final basic block generated by the statement.
    ptr< cir::BasicBlock > ParseSubStatement( parse::Parser& p, uint32_t precedence );

    enum class ValUnifyError
    {
        NoSolution,
        Ambiguous
    };

#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"
#include "tuple.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::cir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupArithOps( Env& e )
    {
        BuildParseRule( e, "+"_sid,

                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->emplace_back(
                        cir::Assert( move( cond ) )
                    );

                    return BuildComputedValue( lhs.type(),
                        SDiv( lhs, rhs ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->emplace_back(
                        cir::Assert( move( cond ) )
                    );

                    return BuildComputedValue( lhs.type(),
                        UDiv( lhs, rhs ) );
                } )
            )
        );

                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->emplace_back(
                        cir::Assert( move( cond ) )
                    );

                    return BuildComputedValue( lhs.type(),
                        SRem( lhs, rhs ) );
                } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    auto zeroValue = Value( rhs.type(), APSInt::get( 0 ) );
                    auto cond = Neq( rhs, zeroValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the divisor may be 0." );

                    cfg->currentBB()->emplace_back(
                        cir::Assert( move( cond ) )
                    );

                    return BuildComputedValue( lhs.type(),
                        URem( lhs, rhs ) );
                } )
            )
        );
    }
}

#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"
#include "tuple.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::cir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupAssignmentOps( Env& e )
    {
        auto assOp = GetOrCreateOverloadSet( e, "operator_assign"_sid );

#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupCommaOp( Env& e )
    {
        using LocVarOfAnyType =

#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"
#include "tuple.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::cir;
using namespace goose::parse;

// TODO: tuple comparisons. Bit of a pita to implement and cba right now. Maybe something to implement in the lib.

namespace goose::builtins
{
    void SetupComparisonOps( Env& e )

#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"
using namespace goose;
using namespace goose::eir;
using namespace goose::cir;
using namespace goose::parse;

namespace goose::builtins
{
    // Helper to build a compound assignment operator
    template< typename L, typename R >
    auto MakeCompoundAssOpFunc( Env& e, StringId opName )

#include "builtins/builtins.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;
using namespace goose::builtins;

// Dollar is a low level operator: it doesn't expect a value rhs operand,
// but just an identifier eir instruction.
// So we can't use the convenient operator wrapper rule.
//
// Also, it works both as a prefix operator to construct a TVar,
// and as an infix operator (with a decl or TEXpr as the left value) to
// construct a Decl of the form "<type> $FOO" or a TDecl of the form
// "<TExpr> $FOO" (for instance $T $FOO)
namespace

#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"
#include "tuple.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::cir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupDotOp( Env& e )
    {
        BuildParseRule( e, "."_sid,

#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"
#include "tuple.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::cir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupLogicOps( Env& e )
    {
        BuildParseRule( e, "!"_sid,
            PrefixOp( "operator_logical_not"_sid, precedence::UnaryOps,
                BuildGenericTupleOperator(),

                ForType< bool >( []( auto&& c, auto&& operand ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        cir::Not( operand ) );
                } )
            )
        );

        BuildParseRule( e, "~"_sid,
            PrefixOp( "operator_bitwise_not"_sid, precedence::UnaryOps,
                BuildGenericTupleOperator(),

                    auto cond = ULT( rhs, bitSizeValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the shift amount may be equal or greater than the bitsize." );

                    cfg->currentBB()->emplace_back(
                        cir::Assert( move( cond ) )
                    );

                    return BuildComputedValue( lhs.type(),
                        Shl( lhs, rhs ) );
                } )
            )
        );

                    auto cond = ULT( rhs, bitSizeValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the shift amount may be equal or greater than the bitsize." );

                    cfg->currentBB()->emplace_back(
                        cir::Assert( move( cond ) )
                    );

                    return BuildComputedValue( lhs.type(),
                        AShr( lhs, rhs ) );
                } ),

                // runtime unsigned integer right shift, defined to work for any two integers of same

                    auto cond = ULT( rhs, bitSizeValue );

                    DiagnosticsManager::GetInstance().defineCustomDiagnostic(
                        cond.locationId(), "assert"_sid, "the shift amount may be equal or greater than the bitsize." );

                    cfg->currentBB()->emplace_back(
                        cir::Assert( move( cond ) )
                    );

                    return BuildComputedValue( lhs.type(),
                        LShr( lhs, rhs ) );
                } )
            )
        );
    }
}

#include "builtins/builtins.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace
{
    bool parseSemicolon( Parser& p, uint32_t locationId, uint32_t prec )
    {
        return p.parseExpression( prec );

#include "builtins/builtins.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;
using namespace goose::builtins;

namespace goose::builtins
{
    void SetupWhereOp( Env& e )
    {

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupBreakStmt( Env& e )
    {
        auto handleBreak = []( Parser& p, uint32_t locationId, uint32_t prec )

                cb->poison();
                return true;
            }

            // Emit cleanups for all live variables in the scopes that we are breaking through.
            cb->destroyAllLiveValuesFromBreakScope( p.context(), cb->breakableScopeLevels() );

            cfg->currentBB()->setTerminator( cir::Break( cb->breakableScopeLevels() ) );
            return true;
        };

        Rule r( handleBreak );
        auto ruleVal = ToValue( move( r ) );
        auto ruleTerm = ValueToIRExpr( ruleVal );
        e.storeValue( AppendToVectorTerm( RootIdentity(), TSID( break ) ), ANYTERM( _ ), ruleTerm );
    }
}

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupContinueStmt( Env& e )
    {
        auto handleContinue = []( Parser& p, uint32_t locationId, uint32_t prec )

                cb->poison();
                return true;
            }

            // Emit cleanups for all live variables in the scopes that we are continuing through.
            cb->destroyAllLiveValuesFromBreakScope( p.context(), cb->continuableScopeLevels() );

            cfg->currentBB()->setTerminator( cir::Continue( cb->continuableScopeLevels() ) );
            return true;
        };

        Rule r( handleContinue );
        auto ruleVal = ToValue( move( r ) );
        auto ruleTerm = ValueToIRExpr( ruleVal );
        e.storeValue( AppendToVectorTerm( RootIdentity(), TSID( continue ) ), ANYTERM( _ ), ruleTerm );
    }
}

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupHIfStmt( Env& e )
    {
        auto handleHIf = []( Parser& p, uint32_t locationId, uint32_t prec )

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupIfStmt( Env& e )
    {
        auto handleIf = []( Parser& p, uint32_t locationId, uint32_t prec )

                dm.emitSyntaxErrorMessage( p.resolver()->currentLocation(), "expected a statement after the if condition.", 0 );
                return false;
            }

            // Retrieve the successor block of the then branch, if any
            auto pThenSuccBB = cfg->currentBB();

            ptr< cir::BasicBlock > pElseBB, pElseSuccBB;

            auto next = p.resolver()->lookAheadUnresolved();
            if( next )
            {
                const auto* nextSid = get_if< StringId >( &next->first );
                if( nextSid && *nextSid == "else"_sid )
                {

                    pElseSuccBB = cfg->currentBB();
                }
            }

            if( !pPrecBB )
                return true;

            ptr< cir::BasicBlock > pSuccBB;

            // If both the then and the else blocks successors exist and are terminated,
            // we don't need a successor block.
            if( !pElseBB || ( pThenSuccBB && !pThenSuccBB->terminator() )
                || ( pElseSuccBB && !pElseSuccBB->terminator() ) )
                pSuccBB = cb->cfg()->createBB();

            pPrecBB->setTerminator( cir::CondBranch(
                get< Value >( converted ),
                pThenBB,
                pElseBB ? pElseBB : pSuccBB ) );

            if( pThenSuccBB && !pThenSuccBB->terminator() )
                pThenSuccBB->setTerminator( cir::Branch( pSuccBB ) );

            if( pElseSuccBB && !pElseSuccBB->terminator() )
                pElseSuccBB->setTerminator( cir::Branch( pSuccBB ) );

            // Intentionally set the current BB to null if no
            // successor block was created: it means all our code paths
            // are already terminated and there is no point in emitting any more
            // instructions.
            cfg->setCurrentBB( pSuccBB );
            return true;

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupReturnStmt( Env& e )
    {
        auto handleReturn = []( Parser& p, uint32_t locationId, uint32_t prec )

            // Emit cleanups (destructor calls) for all currently live values in the function.
            cb->destroyAllLiveValues( p.context() );

            const auto& context = p.context();

            if( context.returnType() == GetValueType< void >() )
            {
                cb->emitTerminator( p.resolver()->currentLocation(), cir::Ret() );
                return true;
            }

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::ReturnStmt + 1 ) )
            {
                dm.emitSyntaxErrorMessage( locationId, "expected an expression following the return statement.", 0 );
                cb->emitTerminator( p.resolver()->currentLocation(), cir::Ret( PoisonValue() ) );
                return false;
            }

            auto retVal = np.popValue();
            if( !retVal )
            {
                dm.emitSyntaxErrorMessage( locationId, "expected an expression following the return statement.", 0 );
                cb->emitTerminator( p.resolver()->currentLocation(), cir::Ret( PoisonValue() ) );
                return false;
            }

            auto converted = ConvertValueToType( context, *retVal, *context.returnType() );
            if( holds_alternative< ValUnifyError >( converted ) )
            {
                switch( get< ValUnifyError >( converted ) )
                {
                    case ValUnifyError::NoSolution:
                        dm.emitErrorMessage( retVal->locationId(), "return value type mismatch." );
                        break;

                    case ValUnifyError::Ambiguous:
                        dm.emitErrorMessage( retVal->locationId(), "ambiguous return value conversion." );
                        break;
                }

                // Emit a terminator with a poison value to avoid the function compilation
                // code to complain about a missing return.
                cb->emitTerminator( p.resolver()->currentLocation(), cir::Ret( PoisonValue() ) );
                cb->poison();
                return true;
            }

            cb->emitTerminator( p.resolver()->currentLocation(), cir::Ret( get< Value >( converted ) ) );
            return true;
        };

        Rule r( handleReturn );
        auto ruleVal = ToValue( move( r ) );
        auto ruleTerm = ValueToIRExpr( ruleVal );
        e.storeValue( AppendToVectorTerm( RootIdentity(), TSID( return ) ), ANYTERM( _ ), ruleTerm );
    }
}

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupUsingStmt( Env& e )
    {
        auto handleUsing = []( Parser& p, uint32_t locationId, uint32_t prec )

#include "builtins/builtins.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;
using namespace goose::builtins;

namespace
{
    optional< uint32_t > VerifStmtPrecedence( const Parser& p )
    {

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupWhileStmt( Env& e )
    {
        auto handleWhile = []( Parser& p, uint32_t locationId, uint32_t prec )

            if( !pPrecBB )
                return true;

            // Retrieve the final block of the loop body, if any
            if( auto pBodySuccBB = cfg->currentBB(); pBodySuccBB && !pBodySuccBB->terminator() )
            {
                // Jump from the end of the body BB back to the loop header
                pBodySuccBB->setTerminator( cir::Branch( pHeaderBB ) );
            }

            // Jump unconditionally from the pred block to the loop header.
            pPrecBB->setTerminator( cir::Branch( pHeaderBB ) );

            auto pSuccBB = cfg->createBB();

            auto breakLevel = cb->breakableScopeLevels();
            auto continueLevel = cb->continuableScopeLevels();

            // Go through all basic blocks, find all break and continue terminators
            // for our scope level and replace them with branches respectively to
            // the successor BB or to the loop header BB.
            cfg->forEachBB( [&]( auto&& bb )
            {
                const auto& t = bb->terminator();
                if( !t )
                    return;

                if( const auto* pBreak = get_if< cir::Break >( &t->content() ) )
                {
                    if( pBreak->level() == breakLevel )
                        bb->setTerminator( cir::Branch( pSuccBB ) );
                    return;
                }

                if( const auto* pCont = get_if< cir::Continue >( &t->content() ) )
                {
                    if( pCont->level() == continueLevel )
                        bb->setTerminator( cir::Branch( pHeaderBB ) );
                    return;
                }
            } );

            // Emit the conditional branch that will either run an iteration of the loop or exit to the succ bb.
            pHeaderBB->setTerminator( cir::CondBranch(
                get< Value >( converted ),
                pBodyBB, pSuccBB ) );

            cfg->setCurrentBB( pSuccBB );
            return true;
        };

        Rule r( handleWhile );
        auto ruleVal = ToValue( move( r ) );
        auto ruleTerm = ValueToIRExpr( ruleVal );
        e.storeValue( AppendToVectorTerm( RootIdentity(), TSID( while ) ), ANYTERM( _ ), ruleTerm );
    }
}

    const Term& ValuePatternT::GetPattern()
    {
        static auto pattern = HOLE( "T"_sid );
        return pattern;
    }
}

namespace goose::eir
{
    // void
    const Term& Bridge< void >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), TSID( void ) ) );
        return type;
    }

        }
    };

    template< typename T >
    using ValueTypeOf = CustomPattern< Value, PatternValueTypeOf< T > >;
}

namespace goose::eir
{
    template<>
    struct Bridge< void >
    {
        static const Term& Type();
    };

#include "builtins/builtins.h"

using namespace goose::builtins;

bool goose::builtins::IsConstrainedFunc( const Value& tcc )
{
    return tcc.type() == GetValueType< ConstrainedFunc >();
}

namespace goose::eir
{
    const Term& Bridge< builtins::ConstrainedFunc >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( ct_type ), TSID( constrainedfunc ) ) ) );
        return type;
    }

            ptr< InvocationRule >   m_pInvRule;
            Value                   m_func;
    };

    extern bool IsConstrainedFunc( const Value& tcc );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::ConstrainedFunc >
    {
        static const Term& Type();
        static Value ToValue( const builtins::ConstrainedFunc& cf );
        static optional< builtins::ConstrainedFunc > FromValue( const Value& v );

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;

namespace goose::builtins
{
    void SetupConstrainedFuncTypeChecking( Env& e )
    {
        auto funcTypePat = ValueToIRExpr( Value( TypeType(), VEC( TSID( func ),
            ANYTERM( _ ), ANYTERM( _ ) ) ) );

        static auto pattern = ValueToIRExpr(
            Value( TypeType(), VEC( TSID( decl ), HOLE( "_"_sid ) ) ) );

        return pattern;
    }
}

namespace goose::eir
{
    Term Bridge< Decl >::Type( const Term& declType )
    {
        return ValueToIRExpr( Value( TypeType(), VEC( TSID( decl ), declType ) ) );
    }

    Value Bridge< Decl >::ToValue( const Decl& d )

            Term m_type;
            StringId m_name;
    };

    extern bool IsDecl( const Value& d );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::Decl >
    {
        static Term Type( const Term& declType );
        static Value ToValue( const builtins::Decl& d );
        static optional< builtins::Decl > FromValue( const Value& v );

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupDestroyValue( Env& e )
    {
        // Default implementation of DestroyValue().
        // Does nothing.

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupDropValue( Env& e )
    {
        // Default implementation of DropValue().
        // Constant values are discarded, and the cir of computed values
        // is appended to the current BB of the current parser.
        RegisterBuiltinFunc< Intrinsic< void ( Value ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& v )
            {
                if( v.isConstant() || !c.codeBuilder() )
                    return;

                // Reference use a load instruction to store their address,
                // so don't emit them. There is never any point in emitting
                // a load whose result isn't used anyway.
                if( holds_alternative< Load >( v.cir()->content() ) )
                    return;

                auto bb = c.codeBuilder()->cfg()->currentBB();
                bb->emplace_back( move( *v.cir() ) );
            } );

        using AnyDeclType = CustomPattern< Decl, Decl::Pattern >;

        // DropValue for Decls: declare a local variable with default initialization.
        // TODO: if the invocation to InitializeValue fails, we should have a way to
        // replace the generic "function arguments mismatch" error message with something

    // Same as above, but takes a type pattern provider.
    template< typename PP >
    struct TypePatternParam
    {};
}

namespace goose::eir
{
    template< typename R, typename... T >
    struct Bridge< R ( T... ) >
    {
        using functype = function< R ( T... ) >;

        static const Term& Type( const ptr< builtins::FuncVerificationInfos >& fvi = nullptr );

        {
            return GetValueType< T >();
        }

        template< typename TT >
        static auto ToValue( TT&& val )
        {
            return eir::ToValue( forward< TT >( val ) );
        }

        static auto FromValue( const Value& v )
        {
            return eir::FromValue< T >( v );
        }
    };
}

#endif

        if( !pOvlSet->add( env, ToValue< FT >( forward< F >( func ), fvi ), GetFuncInvocationRule() ) )
            throw logic_error( "panic: duplicate overload registered for builtin func." );

        return fvi;
    }
}

namespace goose::eir
{
    template< typename T >
    struct BuildBuiltinFuncParamPat
    {
        static const auto& GetParamPattern()
        {
            static auto pat = builtins::ParamPat( GetValueType< T >() );

            if constexpr( is_void_v< builtins::remove_eager_t< R > > )
            {
                apply( func, *params );
                return Value( GetValueType< void >(), 0U );
            }
            else
                return eir::ToValue( apply( func, *params ) );
        };
    }
}

#endif

                auto decl = *FromValue< Decl >( param );
                tv->append( ParamPat( decl.type() ) );

                // Bind a stand-in value with the parameters name to be used inside of verification expressions.
                auto paramVerificationIdentity = AppendToVectorTerm( verificationIdentity,
                    TERM( decl.name() ) );

                Reference argRef( ReferenceType{ decl.type(), TSID( const ) }, cir::VarBaseAddr( varId++ ) );

                c.env()->storeValue( paramVerificationIdentity, ANYTERM( _ ),
                    ValueToIRExpr( BuildComputedValue( decl.type(),
                    cir::Load( ToValue( argRef ), decl.type() ) ) ) );
            }
            else if( param.isConstant() )
                tv->append( ValueToIRExpr( param ) );

            return true;
        } );

        // If the return type is non-void, expose @result under the verification identity as a computed value whose type
        // is the function's return type, and the value is a placeholder cir instruction. This will allow verification
        // expressions to refer to the current function's return value as a value of the correct type.
        auto rtTerm = ValueToIRExpr( returnType );
        if( rtTerm != GetValueType< void >() )
        {
            auto name = "@result"_sid;
            auto retValVerificationIdentity = AppendToVectorTerm( verificationIdentity, TERM( name ) );

            c.env()->storeValue( retValVerificationIdentity, ANYTERM( _ ),
                ValueToIRExpr( BuildComputedValue( rtTerm, cir::Placeholder( rtTerm, name ) ) ) );
        }

        auto pVerifInfos = make_shared< FuncVerificationInfos >( move( verificationIdentity ) );
        return FuncType( ValueToIRExpr( returnType ), tv, move( pVerifInfos ) );
    }

    Func BuildExternalFunc( FuncType funcType, const string& symbol, bool varArg )

        auto funcTypeTerm = ValueToIRExpr( ToValue( funcType ) );
        auto identity = VEC( funcIdentity, funcTypeTerm );

        assert( c.identity() != identity );
        c.env()->addVisibilityRule( c.identity(), identity );

        out_bodyContext = Context( c.env(), identity, funcType.returnType() );
        auto pFuncCIR = c.env()->createCIRFunc( identity );

        return Func( funcType, unparsedBody, get< pvec >( paramsDecl.val() ), pFuncCIR.get() );
    }

    Term BuildCallPatternFromFuncType( const Value& funcType )
    {
        auto ftype = *FromValue< FuncType >( funcType );

        auto apv = make_shared< Vector >();

    }

    bool ParseFuncBody( const Context& c, const Func& f )
    {
        if( !ParseFuncConstraints( c, f.type() ) )
            return false;

        const auto& pFuncCIR = f.cir();

        // If the function was already marked as invalid, don't bother trying to compile it again.
        if( !pFuncCIR->isValid() )
            return false;

        // Perform lazy parsing on param types' predicates
        bool predsOk = true;

        ForEachInVectorTerm( f.type().params(), [&]( auto&& param )
        {
            auto result = Decompose( param,
                Vec(
                    Lit( "value"_sid ),
                    SubTerm(),
                    SubTerm(),
                    SubTerm(),
                    Val< LocationId >()
                )
            );
            assert( result );

            auto&& [sort, type, val, locId] = *result;

            if( !ParseTypePredicates( c, pFuncCIR->identity(), *ValueFromIRExpr( type ) ) )
                predsOk = false;

            return true;
        } );

        if( !predsOk )
            return false;

        // Perform lazy parsing on return type predicates
        if( !ParseTypePredicates( c, pFuncCIR->identity(), *ValueFromIRExpr( f.type().returnType() ) ) )
            return false;

        // If the function already have a cir body, nothing to do.
        if( pFuncCIR->body() )
            return true;

        if( !f.tokens() )
            return false;

        Context localContext( c.env(), pFuncCIR->identity(), f.type().returnType() );

        auto cfg = make_shared< cir::CFG >( VecSize( f.type().params() ) );
        cfg->createBB();
        cfg->setCurrentBB( cfg->entryBB() );

        auto cb = make_shared< CodeBuilder >( cfg );
        localContext.setBuilder( cb );

        // Create the local variable bindings to access the function params
        // from inside the body, as well as the signature.
        uint32_t varId = 0;
        for( auto&& t : f.paramsDecl()->terms() )
        {
            auto param = *ValueFromIRExpr( t );

            if( !IsDecl( param ) )
                continue;

            auto decl = *FromValue< Decl >( param );

            auto paramIdentity = AppendToVectorTerm(
                pFuncCIR->identity(),// ANYTERM( _ ),
                TERM( decl.name() ) );

            // Create a locvar to hold the param.
            LocalVar lv( decl.name(), decl.type(), varId++ );
            auto locVar = ToValue( lv ).setLocationId( param.locationId() );

            c.env()->storeValue( paramIdentity, ANYTERM( _ ),

        if( !success || cfg->isPoisoned() )
        {
            // Fail silently here, because it may be a case of trying
            // to execute an invocation at compile time before falling
            // back to code generation.
            // It's up to our caller to catch the error here, if any.
            pFuncCIR->setInvalid();
            return false;
        }

        if( cfg->currentBB() && !cfg->currentBB()->terminator() )
        {
            if( localContext.returnType() != GetValueType< void >() )
            {
                pFuncCIR->setInvalid();

                // TODO: this location sucks, we might need to store the last parsed location
                // inside each BB to improve that
                DiagnosticsManager::GetInstance().emitErrorMessage( r->currentLocation(),
                    "missing return statement in a function with non-void return type." );
                return false;
            }

            // Implicit return at the end of a void function:
            // Emit the cleanups, and the terminator.
            // TODO: at some point we'll want to check for reachability in the static verifier,
            // and either emit the implicit return or declare the code unreachable depending on the result.
            // The reachability analysis will have to be done before contract validation, as the
            // calls to DestroyValue() may also have requirements to enforce, so we'll need to emit
            // the eventual implicit return first.
            p.flushValue();
            cb->destroyAllLiveValues( localContext );
            cb->emitTerminator( r->currentLocation(), cir::Ret() );
        }

        pFuncCIR->body() = cfg;

        verify::Func fv( localContext, f );
        return fv.verify();
    }
}

        );
        assert( typeDecomp );
        auto&& [kind, rtype, ptypes, vinf, varArg] = *typeDecomp;

        return rtype;
    }

    const cir::Func* GetFuncCIR( const Value& f )
    {
        if( !f.isConstant() )
            return nullptr;

        auto func = FromValue< Func >( f );
        assert( func );
        return func->cir();
    }

    ParamListKind CheckParamListKind( const Value& tup )
    {
        if( !IsTuple( tup ) )
            return ParamListKind::Invalid;

            return true;
        } );

        return av;
    }
}

namespace goose::eir
{
    const Term& Bridge< FuncType >::Type()
    {
        return TypeType();
    }

    Value Bridge< FuncType >::ToValue( const FuncType& ft )

    Value Bridge< Func >::ToValue( const builtins::Func& func )
    {
        if( func.isExternal() )
            return Value( Type( func ), TERM( *func.symbol() ) );

        return Value( Type( func ), VEC(
            TERM( func.tokens() ), TERM( func.paramsDecl() ), TERM( func.cir() ) ) );
    }

    optional< Func > Bridge< Func >::FromValue( const Value& v )
    {
        if( !v.isConstant() || v.isPoison() )
            return nullopt;

        auto funcTypeVal = ValueFromIRExpr( v.type() );
        if( !funcTypeVal )
            return nullopt;

        auto funcType = ::FromValue< FuncType >( *funcTypeVal );
        if( !funcType )
            return nullopt;

        auto result = Decompose( v.val(),
            Vec(
                Val< ptr< void > >(),   // body toks
                Val< pvec >(),          // param decls
                Val< void* >()          // cir
            )
        );

        if( result )
        {
            auto&& [toks,paramDecls,cir] = *result;
            return Func( move( *funcType ), toks, paramDecls, static_cast< cir::Func* >( cir ) );
        }

        // Try to decode it as an external func
        auto result2 = Decompose( v.val(),
            Val< string >()
        );

        if( !result2 )
            return nullopt;

        return Func( move( *funcType ), *result2 );
    }
}

        Template,
        Invalid
    };

    extern Term GetFuncSig( const Value& func );
    extern Term GetFuncSigFromType( const Value& funcType );
    extern Term GetFuncRType( const Value& func );
    extern const cir::Func* GetFuncCIR( const Value& func );

    // Given a tuple, determines whether it is a valid param list, and of which kind.
    extern ParamListKind CheckParamListKind( const Value& tup );

    template< typename F >
    void ForEachDeclInTuple( const Value& tup, F&& func );

    extern bool IsExternalFunc( const Value& f );
    extern bool IsFuncType( const Value& t );

    class Func
    {
        public:
            template< typename T, typename B, typename P >
            Func( T&& funcType, B&& toks, P&& paramsDecls, cir::Func* cir ) :
                m_type( forward< T >( funcType ) ),
                m_tokens( forward< B >( toks ) ),
                m_paramsDecl( forward< P >( paramsDecls ) ),
                m_cir( cir )
            {}

            template< typename T, typename B, typename P >
            Func( T&& funcType, B&& toks, P&& paramsDecls ) :
                m_type( forward< T >( funcType ) ),
                m_tokens( forward< B >( toks ) ),
                m_paramsDecl( forward< P >( paramsDecls ) )
            {}

            template< typename T >
            Func( T&& funcType, const string& symbol ) :
                m_type( forward< T >( funcType ) ),
                m_symbol( symbol )
            {}

            bool isExternal() const { return m_symbol.has_value(); }

            const auto& type() const { return m_type; }
            const auto& tokens() const { return m_tokens; }
            const auto& paramsDecl() const { return m_paramsDecl; }
            const auto& cir() const { return m_cir; }
            const auto& symbol() const { return m_symbol; }

            void setCIR( cir::Func* cir )
            {
                m_cir = cir;
            }

        private:
            FuncType m_type;

            ptr< void > m_tokens;  // the unparsed body

            pvec m_paramsDecl;
            cir::Func* m_cir = nullptr;

            // The function's symbol, if this is an external function.
            optional< string > m_symbol;
    };

    extern Value CompileFunc( const Context& c, const Value& f );
    extern bool ParseFuncConstraints( const Context& c, const FuncType& funcType );
    extern bool ParseFuncBody( const Context& c, const Value& f );
    extern bool ParseFuncBody( const Context& c, const Func& f );

    // The args for a function may include constants that are specialization args.
    // When building a call instruction, we need to strip those out and keep only
    // the args that actually exist at runtime / execution time.
    extern Term BuildArgListForCall( const FuncType& ft, const Term& unifiedArgs );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::FuncType >
    {
        static const Term& Type();
        static Value ToValue( const builtins::FuncType& ft );
        static optional< builtins::FuncType > FromValue( const Value& v );

                );

                auto&& [unifiedArgs, unifiedRType] = *callDecomp;

                newCallee.setLocationId( loc );

                if( IsBuiltinFunc( newCallee ) )
                    return BuildComputedValue( unifiedRType, cir::Call( newCallee, unifiedArgs ) );

                if( IsIntrinsicFunc( newCallee ) )
                    return GetBuiltinIntrinsicFuncWrapper( newCallee )( c, unifiedArgs );

                auto ft = *FromValue< FuncType >( *ValueFromIRExpr( newCallee.type() ) );
                auto argList = BuildArgListForCall( ft, unifiedArgs );

                return BuildComputedValue( unifiedRType, cir::Call( newCallee, argList ) );
            }

            optional< Term > getSignature( const Value& callee ) const final
            {
                return GetFuncSig( callee );
            }

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::builtins;

namespace goose::builtins
{
    optional< FuncType > LowerFunctionTypeForRuntime( const Context& c, const FuncType& ft )
    {
        // If the passed function already have an associated llvm type,

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;

namespace goose::builtins
{
    void SetupFunctionTypeChecking( Env& e )
    {
        // Default param rule: we basically treat it like a regular value.
        // Things that need a more specific rule for params can override this with

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupInitialize( Env& e )
    {
        using ValueOfTypeT = CustomPattern< Value, ValuePatternT >;

    struct VerificationIntrinsic
    {};

    using BuiltinIntrinsicFuncWrapper = function< Value ( const Context& c, const Term& argVec ) >;
    extern const BuiltinIntrinsicFuncWrapper& GetBuiltinIntrinsicFuncWrapper( const Value& func );
}

namespace goose::eir
{
    template< typename R, typename... T >
    struct Bridge< builtins::Intrinsic< R ( T... ) > >
    {
        using functype = function< R ( T... ) >;

        static const Term& Type( const ptr< builtins::FuncVerificationInfos >& fvi = nullptr );

#ifndef GOOSE_BUILTINS_TYPES_INTRINSIC_INL
#define GOOSE_BUILTINS_TYPES_INTRINSIC_INL

namespace goose::eir
{
    template< typename R, typename... T >
    const Term& Bridge< builtins::Intrinsic< R ( T... ) > >::Type( const ptr< builtins::FuncVerificationInfos >& fvi )
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( func ), TSID( intrinsic ),
            GetValueType< Value >(),
            sema::Quote( BuildBuiltinFuncParamTypeList< T... >() ),

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupLocalVarDropValue( Env& e )
    {
        using AnyLocVarType = CustomPattern< LocalVar, LocalVar::PatternAny >;

    {
        public:
            bool canBeInvoked( const Context& c, const Value& callee ) const final
            {
                auto lv = *FromValue< LocalVar >( callee );

                auto val = BuildComputedValue( lv.type(),
                    cir::Load( ToValue( BuildLocalVarConstRef( lv ) ), lv.type() ) );

                return sema::CanBeInvoked( c, val );
            }

            Value resolveInvocation( const Context& c, uint32_t locationId, const Value& callee, const Term& args ) const final
            {
                auto lv = *FromValue< LocalVar >( callee );

                auto val = BuildComputedValue( lv.type(),
                    cir::Load( ToValue( BuildLocalVarConstRef( lv ) ), lv.type() ) );

                return sema::GetInvocationRule( *c.env(), val )->resolveInvocation( c, locationId, val, args );
            }
    };

    void SetupLocalVarInvocationRule( Env& e )
    {

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::builtins;
using namespace goose::cir;
using namespace goose::parse;

namespace goose::builtins
{
    const Term& LocalVar::PatternAny::GetPattern()
    {
        static auto pattern = GetValueType< LocalVar >( HOLE( "_"_sid ) );

        bb->emplace_back( AllocVar( ValueFromIRExpr( lv.type() )->setLocationId( typeLoc ), index ) );

        DiagnosticsContext dc( 0, "When invoking Initialize." );

        auto initResult = ResolveInvocation( c, GetInvocationRule( *c.env(), initializerVal ), initializerVal,
            MakeTuple( ToValue( lv ), initVal ) );

        if( !initResult.isConstant() && cir::CanValueBeEagerlyEvaluated( initResult ) )
        {
            execute::VM vm;
            initResult = execute::Evaluate( initResult, vm );
        }

        if( !initResult.isPoison() )
        {

        }

        cb->pushLiveValue( locVar, lv.index() );
        return locVar;
    }
}

namespace goose::eir
{
    const Term& Bridge< LocalVarType >::Type()
    {
        return TypeType();
    }

    Value Bridge< LocalVarType >::ToValue( const LocalVarType& t )

        private:
            StringId m_name;
            Term m_type;
            uint32_t m_index = 0;
    };
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::LocalVarType >
    {
        static const Term& Type();
        static Value ToValue( const builtins::LocalVarType& t );
        static Value ToValue( const Term& type );

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupLocalVarTypeChecking( Env& e )
    {
        auto localVarPattern = GetValueType< LocalVar >( ANYTERM( _ ) );

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupLower( Env& e )
    {
        // Default implementation of LowerTypeForVerification():
        // Do nothing.

        assert( pOvlSet );

        Context localC( c.env(), c.identity(), GetValueType< uint32_t >() );
        localC.setBuilder( c.codeBuilder() );

        execute::VM vm;

        if( !args.isConstant() && cir::CanValueBeEagerlyEvaluated( args ) )
            args = execute::Evaluate( args, vm );
        if( args.isPoison() )
            return PoisonValue();

        auto val = ResolveInvocation( localC, GetOverloadSetInvocationRule(), ToValue( pOvlSet ), args );

        if( val.isConstant() || !cir::CanValueBeEagerlyEvaluated( val ) )
            return val;

        return execute::Evaluate( val, vm );
    }
}

#include "builtins/builtins.h"

using namespace goose::builtins;

bool goose::builtins::IsOverloadSet( const Value& os )
{
    return os.type() == GetValueType< ptr< OverloadSet > >();
}

namespace goose::eir
{
    const Term& Bridge< ptr< builtins::OverloadSet > >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( ct_type ), TSID( overloadset ) ) ) );
        return type;
    }

    extern ptr< InvocationRule >& GetOverloadSetInvocationRule();
    extern void SetupOverloadSetInvocationRule( Env& e );
    extern void SetupOverloadSetTypeChecking( Env& e );

    extern bool IsOverloadSet( const Value& os );
}

namespace goose::eir
{
    template<>
    struct Bridge< ptr< builtins::OverloadSet > >
    {
        static const Term& Type();
        static Value ToValue( const ptr< builtins::OverloadSet >& os );
        static optional< ptr< builtins::OverloadSet > > FromValue( const Value& v );

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;

namespace goose::builtins
{
    void SetupOverloadSetTypeChecking( Env& e )
    {
        auto funcTypePat = ValueToIRExpr( Value( TypeType(), VEC( TSID( func ),
            ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ), ANYTERM( VA ) ) ) );

#include "builtins/builtins.h"
#include "parse/parse.h"
#include "precedence.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupRefTypeParsingRule( Env& e )
    {
        auto parseRefType = []( Parser& p, uint32_t locationId, uint32_t prec )

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::builtins;
using namespace goose::cir;
using namespace goose::parse;

namespace goose::builtins
{
    bool IsReferenceType( const Term& t )
    {
        auto result = Decompose( ValueFromIRExpr( t )->val(),

    {
        static auto pattern = GetValueType< Reference >( HOLE( "T"_sid ), TSID( mut ) );
        return pattern;
    }

    Reference BuildLocalVarConstRef( const LocalVar& lv )
    {
        return { ReferenceType{ lv.type(), TSID( const ) }, cir::VarBaseAddr( lv.index() ) };
    }

    Reference BuildLocalVarMutRef( const LocalVar& lv )
    {
        return { ReferenceType{ lv.type(), TSID( mut ) }, cir::VarBaseAddr( lv.index() ) };
    }
}

namespace goose::eir
{
    const Term& Bridge< ReferenceType >::Type()
    {
        return TypeType();
    }

    Value Bridge< ReferenceType >::ToValue( const ReferenceType& t )

    Term Bridge< builtins::Reference >::Type( const Term& type, const Term& bhv )
    {
        return ValueToIRExpr( ::ToValue( ReferenceType( type, bhv ) ) );
    }

    Value Bridge< builtins::Reference >::ToValue( const builtins::Reference& ref )
    {
        return BuildComputedValue( ValueToIRExpr( ::ToValue( ref.type() ) ), cir::CalcAddress{ ref.address() } );
    }

    optional< builtins::Reference > Bridge< builtins::Reference >::FromValue( const Value& v )
    {
        if( v.isConstant() )
            return nullopt;

        auto cirRef = get_if< cir::CalcAddress >( &v.cir()->content() );
        if( !cirRef )
            return nullopt;

        auto t = FromValue< ReferenceType >( *ValueFromIRExpr( v.type() ) );
        if( !t )
            return nullopt;

        return builtins::Reference( move( *t ), get< cir::CalcAddress >( v.cir()->content() ) );
    }
}

                    static auto pattern = GetValueType< Reference >( PP::GetPattern(), TSID( const ) );
                    return pattern;
                }
            };

        private:
            ReferenceType m_type;
            cir::CalcAddress m_addr;
    };

    extern Reference BuildLocalVarConstRef( const LocalVar& lv );
    extern Reference BuildLocalVarMutRef( const LocalVar& lv );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::ReferenceType >
    {
        static const Term& Type();
        static Value ToValue( const builtins::ReferenceType& t );
        static optional< builtins::ReferenceType > FromValue( const Value& v );

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupReferenceTypeChecking( Env& e )
    {
        auto localVarPattern = GetValueType< LocalVar >( ANYTERM( _ ) );

            {
                auto refval = *ValueFromIRExpr( rhs );
                auto ref = FromValue< Reference >( refval );
                if( !ref )
                    co_return;

                auto content = ValueToIRExpr( BuildComputedValue( ref->type().type(),
                    cir::Load( refval, ref->type().type() ) )
                    .setLocationId( refval.locationId() ) );

                // TypeCheck the param with the ref's content
                co_yield TypeCheck( lhs, content, tcc );
            } );

        // LocalVar type checking against a param (implicit referencing):

    llvm::Type* GetLLVMType( const ArrayType& a )
    {
        return llvm::ArrayType::get( GetLLVMType( *ValueFromIRExpr( a.m_containedType ) ), a.m_count );
    }
}

namespace goose::eir
{
    Value Bridge< ArrayType >::ToValue( const ArrayType& a )
    {
        return Value( Type(), MkStdRTType( TSID( array ),
            GetLLVMType( a ),
            TERM( a.m_count ), a.m_containedType ) );
    }

        Term m_containedType;
        uint32_t m_count = 1;
    };

    extern llvm::Type* GetLLVMType( const ArrayType& a );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::ArrayType >
    {
        static const Term& Type() { return TypeType(); }
        static Value ToValue( const builtins::ArrayType& a );
        static optional< builtins::ArrayType > FromValue( const Value& v );

    llvm::Type* GetLLVMType( const IntegerType& t )
    {
        return llvm::IntegerType::get( GetLLVMContext(), t.m_numBits );
    }
}

namespace goose::eir
{
    //// Half
    Value Bridge< HalfFloatType >::ToValue( const HalfFloatType& t )
    {
        return Value( Type(), MkStdRTType( TSID( half ), GetLLVMType( t ) ) );
    }

        auto&& [predicates, llvmType, params] = *result;
        auto&& [numBits, signd] = params;
        return IntegerType( numBits, !!signd );
    }

    Term Bridge< APSInt >::Type( const APSInt& i )
    {
        return ValueToIRExpr( eir::ToValue(
            IntegerType( i.getBitWidth(), i.isSigned() ) ) );
    }

    Value Bridge< APSInt >::ToValue( const APSInt& i )
    {
        return Value( Type( i ), TERM( i ) );
    }

        return *result;
    }


    const Term& Bridge< uint8_t >::Type()
    {
        static auto type = ValueToIRExpr( eir::ToValue(
            IntegerType( 8, false ) ) );
        return type;
    }

    Value Bridge< uint8_t >::ToValue( uint8_t x )
    {
        return eir::ToValue( APSInt::getUnsigned( x ).trunc( 8 ) );
    }

    optional< uint8_t > Bridge< uint8_t >::FromValue( const Value& v )
    {
        return FromValue< APSInt >( v )->getLimitedValue();
    }


    const Term& Bridge< uint32_t >::Type()
    {
        static auto type = ValueToIRExpr( eir::ToValue(
            IntegerType( 32, false ) ) );
        return type;
    }

    Value Bridge< uint32_t >::ToValue( uint32_t x )
    {
        return eir::ToValue( APSInt::getUnsigned( x ).trunc( 32 ) );
    }

    optional< uint32_t > Bridge< uint32_t >::FromValue( const Value& v )
    {
        return FromValue< APSInt >( v )->getLimitedValue();
    }


    const Term& Bridge< uint64_t >::Type()
    {
        static auto type = ValueToIRExpr( eir::ToValue(
            IntegerType( 64, false ) ) );
        return type;
    }

    Value Bridge< uint64_t >::ToValue( uint64_t x )
    {
        return eir::ToValue( APSInt::getUnsigned( x ) );
    }

    optional< uint64_t > Bridge< uint64_t >::FromValue( const Value& v )
    {
        if( !v.isConstant() )
            return nullopt;
        return FromValue< APSInt >( v )->getLimitedValue();
    }
}

    extern llvm::Type* GetLLVMType( const HalfFloatType& t );
    extern llvm::Type* GetLLVMType( const FloatType& t );
    extern llvm::Type* GetLLVMType( const DoubleFloatType& t );
    extern llvm::Type* GetLLVMType( const IntegerType& t );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::HalfFloatType >
    {
        static const Term& Type() { return TypeType(); }
        static Value ToValue( const builtins::HalfFloatType& i );
        static optional< builtins::HalfFloatType > FromValue( const Value& v );

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupRuntimeBasicTypesInitialize( Env& e )
    {
        using IntegerMutRefType =
            CustomPattern< Reference, Reference::PatternMutable< IntegerType::Pattern > >;

    llvm::Type* GetLLVMType( const PointerType& p )
    {
        return llvm::PointerType::getUnqual( GetLLVMType( *ValueFromIRExpr( p.m_pointedType ) ) );
    }
}

namespace goose::eir
{
    Value Bridge< PointerType >::ToValue( const PointerType& p )
    {
        return Value( Type(), MkStdRTType( TSID( pointer ),
            GetLLVMType( p ),
            p.m_pointedType ) );
    }

            return nullopt;

        return NullPointerType();
    }

    const Term& Bridge< NullPointer >::Type()
    {
        static auto type = ValueToIRExpr( eir::ToValue( NullPointerType() ) );
        return type;
    }

    const Value& Bridge< NullPointer >::ToValue( const NullPointer& np )
    {
        static auto val = Value( Type(), TSID( nullptr ) );
        return val;

    struct NullPointer
    {};

    extern llvm::Type* GetLLVMType( const PointerType& p );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::PointerType >
    {
        static const Term& Type() { return TypeType(); }
        static Value ToValue( const builtins::PointerType& p );
        static optional< builtins::PointerType > FromValue( const Value& v );

            elements.emplace_back( llvmType );
        }

        return llvm::StructType::get( GetLLVMContext(), elements, rt.m_packed );
    }
}

namespace goose::eir
{
    Value Bridge< RecordType >::ToValue( const RecordType& rt )
    {
        return Value( Type(), MkStdRTType( TSID( record ), GetLLVMType( rt ),
            TERM( rt.m_packed ? 1U : 0U ),
            TERM( rt.m_memberTypes ) ) );
    }

#ifndef GOOSE_BUILTINS_TYPES_RUNTIME_RECORD_H
#define GOOSE_BUILTINS_TYPES_RUNTIME_RECORD_H

namespace goose::builtins
{
    extern void SetupRuntimeRecordType( Env& e );

    struct RecordType
    {
        RecordType( bool packed = false ) :
            m_memberTypes( make_shared< eir::Vector >() ),
            m_packed( packed )
        {}

        template< typename M >
        RecordType( M&& memberTypes, bool packed = false ) :
            m_memberTypes( forward< M >( memberTypes ) ),
            m_packed( packed )

        auto rt = ValueToIRExpr( ToValue( RecordType( forward< T >( types ), packed ) ) );
        return Value( move( rt ), forward< V >( vals ) );
    }

    extern llvm::Type* GetLLVMType( const RecordType& rt );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::RecordType >
    {
        static const Term& Type() { return TypeType(); }
        static Value ToValue( const builtins::RecordType& rt );
        static optional< builtins::RecordType > FromValue( const Value& v );
    };
}

#endif

#include "builtins/builtins.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::eir;

namespace goose::builtins
{
    void SetupRuntimeTypesUnification( Env& e )
    {
        auto rtIntTypePattern = Value( TypeType(), MkStdType( TSID( integer ),
            VEC( ANYTERM( _ ), ANYTERM( _ ) ) ) );

        []( const Term& lhs, const Term& rhs, const TypeCheckingContext& c ) -> TCGen
        {
            co_return;
        } );

        // ct_integer constant type checking against a IntegerType:
        // Check if the IntegerType is big enough for the constant,
        // and emit a LoadConstantInt cir instruction if so.
        e.typeCheckingRuleSet()->addTypeCheckingRule( TCRINFOS,

            ValueToIRExpr( ValuePattern(
                ANYTERM( _ ),
                ValueToIRExpr( rtIntTypePattern ),
                ANYTERM( _ ) ) ),

            GetValueType< string >(),
        []( const Term& lhs, const Term& rhs, const TypeCheckingContext& c ) -> TCGen
        {
            co_yield HalfUnify( lhs, c );
        } );

        // ct_string constant type checking against a pointer to a integer( 8 ):
        // Emit a LoadConstantStr cir instruction.
        e.typeCheckingRuleSet()->addTypeCheckingRule( TCRINFOS,

            ValueToIRExpr( ValuePattern(
                ANYTERM( _ ),
                ValueToIRExpr( rtInt8PtrTypePattern ),
                ANYTERM( _ ) ) ),

            ValueToIRExpr( ValuePattern(
                ANYTERM( _ ),
                GetValueType< string >(),
                ANYTERM( _ ) ) ),

        []( const Term& lhs, const Term& rhs, const TypeCheckingContext& c ) -> TCGen
        {
            auto str = *FromValue< string >( *ValueFromIRExpr( rhs ) );
            auto lhsVal = *ValuePatternFromIRExpr( lhs );

            co_yield { ValueToIRExpr(
                BuildComputedValue( lhsVal.type(), cir::LoadConstStr( str ) ) ), c };
        } );

        auto ptrTypePattern = Value( TypeType(), MkStdType( TSID( pointer ),
            ANYTERM( _ ) ) );

        // nullptr constant type checking against a pointer of any type;
        // Yield a value of the given pointer type, with a 0 integer as its content.

#include "builtins/builtins.h"

using namespace goose::builtins;

namespace goose::builtins
{
    bool IsTDecl( const Value& td )
    {
        return td.type() == GetValueType< TDecl >();
    }
}

namespace goose::eir
{
    const Term& Bridge< TDecl >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), TSID( tdecl ) ) );
        return type;
    }

            Term m_type;
            StringId m_name;
    };

    extern bool IsTDecl( const Value& td );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::TDecl >
    {
        static const Term& Type();
        static Value ToValue( const builtins::TDecl& td );
        static optional< builtins::TDecl > FromValue( const Value& v );

#include "builtins/builtins.h"
#include "lex/lex.h"
#include "parse/parse.h"

using namespace goose::builtins;
using namespace goose::parse;

namespace goose::eir
{
    Term Bridge< TFunc >::Type( const builtins::TFunc& tf )
    {
        return ValueToIRExpr( ::ToValue( tf.type() ) );
    }

    Value Bridge< TFunc >::ToValue( const TFunc& tf )

            Term        m_identity;
            ptr< void > m_toks;
    };

    extern Value InstantiateTFunc( const Context& c, const Value& callee, const Term& unifiedCallPat, const TypeCheckingContext& tcc );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::TFunc >
    {
        static Term Type( const builtins::TFunc& tf );
        static Value ToValue( const builtins::TFunc& tf );
        static optional< builtins::TFunc > FromValue( const Value& v );

    bool IsTFunc( const Value& t )
    {
        return IsTFuncType( *ValueFromIRExpr( t.type() ) );
    }
}

namespace goose::eir
{
    const Term& Bridge< TFuncType >::Type()
    {
        return TypeType();
    }

    Value Bridge< TFuncType >::ToValue( const TFuncType& tft )

            ptr< vector< TermLoc > > m_postCondToks = make_shared< vector< TermLoc > >();
    };

    extern bool IsTFuncType( const Value& t );
    extern bool IsTFunc( const Value& t );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::TFuncType >
    {
        static const Term& Type();
        static Value ToValue( const builtins::TFuncType& tft );
        static optional< builtins::TFuncType > FromValue( const Value& v );

    const Term& TNamedDecl::Pattern::GetPattern()
    {
        static auto pattern = GetValueType< TNamedDecl >();
        return pattern;
    }
}

namespace goose::eir
{
    const Term& Bridge< TNamedDecl >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), TSID( tnameddecl ) ) );
        return type;
    }

            Term m_type;
            StringId m_name;
    };

    extern bool IsTNamedDecl( const Value& td );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::TNamedDecl >
    {
        static const Term& Type();
        static Value ToValue( const builtins::TNamedDecl& td );
        static optional< builtins::TNamedDecl > FromValue( const Value& v );

    bool IsTVar( const Value& tv )
    {
        return tv.type() == GetValueType< TVar >();
    }
}

namespace goose::eir
{
    const Term& Bridge< TVar >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( texpr ), TSID( tvar ) ) ) );
        return type;
    }

    };

    extern bool IsTExpr( const optional< Value >& te );
    extern bool IsTExpr( const Value& te );
    extern bool IsTVar( const Value& tv );
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::TVar >
    {
        static const Term& Type();
        static Value ToValue( builtins::TVar&& tv );
        static optional< builtins::TVar > FromValue( const Value& v );

#include "builtins/builtins.h"

using namespace goose::builtins;

namespace goose::eir
{
    const Term& Bridge< TVec >::Type()
    {
        static auto type = ValueToIRExpr( Value( TypeType(), VEC( TSID( texpr ), TSID( tvec ) ) ) );
        return type;
    }

        private:
            pvec m_content;
    };

    // Construct either a normal Vector term or a TVec.
    // If any of the provided term is a TExpr, construct a TVec.
    //
    // This is used to construct eir expressions for parametric types,
    // so that they are automatically turned into a suitable TExpr if
    // TExprs are passed as parameters.
    template< typename... T >
    extern Term BuildVecOrTVec( T&&... terms )
    {
        auto vec = Vector::Make( terms... );

        if( ( IsTExpr( ValueFromIRExpr( terms ) ) || ... ) )
            return ValueToIRExpr( ToValue( TVec( move( vec ) ) ) );

        return vec;
    }

    #define TVEC( ... ) BuildVecOrTVec( __VA_ARGS__ )
}

namespace goose::eir
{
    template<>
    struct Bridge< builtins::TVec >
    {
        static const Term& Type();
        static Value ToValue( const builtins::TVec& tv );
        static optional< builtins::TVec > FromValue( const Value& v );
    };
}

#endif

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;

namespace goose::builtins
{
    void SetupTemplateFunctionTypeChecking( Env& e )
    {
        auto funcTypePat = ValueToIRExpr( Value( TypeType(), VEC( TSID( func ),
            ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ), ANYTERM( VA ) ) ) );

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupTupleDestroyValue( Env& e )
    {
        // DestroyValue() for tuples: destroy every member value.
        RegisterBuiltinFunc< Intrinsic< void ( CustomPattern< Value, TuplePattern > ) > >( e, e.extDestroyValue(),

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void SetupTupleDropValue( Env& e )
    {
        // DropValue() for tuples: drop every member value.
        RegisterBuiltinFunc< Intrinsic< void ( CustomPattern< Value, TuplePattern > ) > >( e, e.extDropValue(),

#include "builtins/builtins.h"
#include "parse/parse.h"

using namespace goose::parse;
using namespace goose::cir;

namespace goose::builtins
{
    void InitTuple( const Context& c, const Value& tupRef, const Value& initTup )
    {
        auto lref = *FromValue< Reference >( tupRef );

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;
using namespace goose::builtins;

namespace goose::builtins
{
    void SetupTupleLowering( Env& e )
    {
        RegisterBuiltinFunc< Intrinsic< Value ( TypePatternParam< TuplePattern > ) > >( e, e.extLowerTypeForRuntime(),

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;

namespace goose::builtins
{
    Value MkTupleType( const Term& state, const Term& types )
    {
        return Value( TypeType(), VEC( TSID( tuple ), state, types ) );
    }

    struct TuplePatternOfTypeT
    {
        static const Term& GetPattern();
    };
}

namespace goose::eir
{
    template< typename... T >
    struct Bridge< tuple< T... > >
    {
        static const Term& Type();
        static Value ToValue( const tuple< T... >& x );
        static optional< tuple< T... > > FromVectorTerm( const Term& v );

        return ForEachInVectorTerms( tup1.val(), tup2.val(), [&]( auto&& t1, auto&& t2 )
        {
            return func( *ValueFromIRExpr( t1 ), *ValueFromIRExpr( t2 ) );
        } );
    }
}

namespace goose::eir
{
    // Type
    static inline const Value& BuildTupleType( const Value& typeSoFar )
    {
        return typeSoFar;
    }

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::eir;

namespace goose::builtins
{
    TCGen TypeCheckConstantTuple( const TypeCheckingContext& tcc, const Value& tupType, const Value& tupArg, uint32_t index, const Value& out )
    {
        auto param = ParamPat( GetTupleTypeElement( tupType, index ) );

            if( index == ( tupSize - 1 ) )
                co_yield { ValueToIRExpr( newOut ), tcc };
            else
                co_yield TypeCheckConstantTuple( tcc, tupType, tupArg, index + 1, newOut );
        }
    }

    TCGen TypeCheckComputedTuple( const TypeCheckingContext& tcc, const Value& tupType, const Value& tupArg, const cir::CalcAddress& tupAddr, uint32_t index, const Value& out )
    {
        auto param = ParamPat( GetTupleTypeElement( tupType, index ) );

        auto argType = GetTupleElementType( tupArg, index );
        ReferenceType rt( argType, TSID( const ) );
        auto argAddr = tupAddr;
        argAddr.appendToPath( index );

            if( !ltup || !rtup || !tcc.context().codeBuilder() )
                co_return;

            auto tupType = *ValueFromIRExpr( ltup->type() );
            assert( TupleTypeSize( tupType ) == TupleTypeSize( *ValueFromIRExpr( rtup->type() ) ) );

            auto tempIndex = tcc.context().codeBuilder()->cfg()->getNewTemporaryIndex();
            cir::CalcAddress addr( cir::TemporaryBaseAddr( tempIndex, *rtup ) );

            co_yield TypeCheckComputedTuple( tcc, tupType, *rtup, addr, 0, EmptyTuple() );
        } );

        // Single element tuple unwrapping rules: if we encounter such a tuple, attempt to typecheck
        // its contained value with whatever's on the other side.
        e.typeCheckingRuleSet()->addTypeCheckingRule( TCRINFOS,

        c.env()->addVisibilityRule( parentIdentity, predicatesIdentity );

        auto typeTerm = ValueToIRExpr( type );

        auto name = "@val"_sid;
        auto valuePlaceholderIdentity = AppendToVectorTerm( predicatesIdentity, TERM( name ) );
        c.env()->storeValue( valuePlaceholderIdentity, ANYTERM( _ ),
            ValueToIRExpr( BuildComputedValue( typeTerm, cir::Placeholder( typeTerm, name ) ) ) );

        Context localContext( c.env(), predicatesIdentity );

        for( auto&& toks : tp.m_unparsedPredicates )
        {
            auto tokProvider = lex::MakeVectorAdapter( toks );
            auto r = make_shared< parse::Resolver >( tokProvider, localContext );

#ifndef GOOSE_CIR_ALLOCVAR_H
#define GOOSE_CIR_ALLOCVAR_H

namespace goose::cir
{
    class AllocVar
    {
        public:
            template< typename T >
            AllocVar( T&& type, uint32_t index ) :
                m_type( forward< T >( type ) ),

            bool canBeEagerlyEvaluated() const
            {
                return false;
            }

        private:
            eir::Value m_type;
            uint32_t m_index = 0;
    };
}

#endif

#ifndef GOOSE_CIR_ARITH_H
#define GOOSE_CIR_ARITH_H

namespace goose::cir
{
    class Add : public BinaryOp
    {
        public:
            template< typename L, typename R >
            Add( L&& lhs, R&& rhs ) : BinaryOp( forward< L >( lhs ), forward< R >( rhs ) ) {}
    };

#ifndef GOOSE_CIR_ASS_H
#define GOOSE_CIR_ASS_H

// This file is not called "assert.h" because that fucks the cassert header up
// when it tries to include assert.h.
// "ass" is both a good shortcut and an accurate description of the problem.

namespace goose::cir
{
    class Assert
    {
        public:
            template< typename V >
            Assert( V&& cond ) :
                m_cond( forward< V >( cond ) )

            bool canBeEagerlyEvaluated() const
            {
                return false;
            }

        private:
            eir::Value m_cond;
    };
}

#endif

#ifndef GOOSE_CIR_BASICBLOCK_H
#define GOOSE_CIR_BASICBLOCK_H

namespace llvm
{
    class BasicBlock;
}

namespace goose::cir
{
    class BasicBlock
    {
        public:
            BasicBlock( const ptr< CFG >& owner, uint32_t index ) :
                m_owner( owner ),
                m_index( index )

#ifndef GOOSE_CIR_BASICBLOCK_INL
#define GOOSE_CIR_BASICBLOCK_INL

namespace goose::cir
{
    template< typename... T >
    void BasicBlock::emplace_back( T&&... args )
    {
        m_instructions.emplace_back( forward< T >( args )... );
        m_canBeExecuted = m_canBeExecuted && m_instructions.back().canBeExecuted();
        m_canBeEagerlyEvaluated = m_canBeEagerlyEvaluated && m_instructions.back().canBeEagerlyEvaluated();

#include "cir.h"

namespace goose::cir
{
    bool BinaryOp::canBeExecuted() const
    {
        return IsValueConstantOrExecutable( m_lhs )
            && IsValueConstantOrExecutable( m_rhs );
    }

#ifndef GOOSE_CIR_BINARYINSTR_H
#define GOOSE_CIR_BINARYINSTR_H

namespace goose::cir
{
    class BinaryOp
    {
        public:
            template< typename L, typename R >
            BinaryOp( L&& lhs, R&& rhs ) :
                m_lhs( forward< L >( lhs ) ),
                m_rhs( forward< R >( rhs ) )
            {}

            const auto& lhs() const { return m_lhs; }
            const auto& rhs() const { return m_rhs; }

            bool canBeExecuted() const;
            bool canBeEagerlyEvaluated() const;

        private:
            eir::Value m_lhs;
            eir::Value m_rhs;
    };

    class BinaryOpSameTypes : public BinaryOp
    {
        public:
            template< typename L, typename R >
            BinaryOpSameTypes( L&& l, R&& r ) :

#ifndef GOOSE_CIR_BITWISE_H
#define GOOSE_CIR_BITWISE_H

namespace goose::cir
{
    class And : public BinaryOp
    {
        public:
            template< typename L, typename R >
            And( L&& lhs, R&& rhs ) : BinaryOp( forward< L >( lhs ), forward< R >( rhs ) ) {}
    };

#ifndef GOOSE_CIR_BRANCH_H
#define GOOSE_CIR_BRANCH_H

namespace goose::cir
{
    class BasicBlock;

    class Branch
    {
        public:
            template< typename B >

            {
                return CanValueBeEagerlyEvaluated( m_cond );
            }

            void addCFGEdges( const ptr< CFG >& cfg, uint32_t srcBBIndex );

        private:
            eir::Value m_cond;
            wptr< BasicBlock > m_trueDest;
            wptr< BasicBlock > m_falseDest;
    };
}

#endif

#ifndef GOOSE_CIR_BREAK_H
#define GOOSE_CIR_BREAK_H

namespace goose::cir
{
    class Break
    {
        public:
            Break() {}

            Break( uint32_t level ) :

#ifndef GOOSE_CIR_CALCADDR_H
#define GOOSE_CIR_CALCADDR_H

namespace goose::cir
{
    struct TemporaryBaseAddr
    {
        template< typename T >
        TemporaryBaseAddr( uint32_t i, T&& init ) :
            m_initValue( forward< T >( init ) ),
            index( i )
        {}

        auto operator<=>( const TemporaryBaseAddr& rhs ) const
        {
            return index <=> rhs.index;
        }

        eir::Value m_initValue;
        uint32_t index = 0;
    };

    struct VarBaseAddr
    {
        VarBaseAddr( uint32_t i ) : index( i ) {}

#include "cir/cir.h"
#include "builtins/builtins.h"

using namespace goose::builtins;

namespace goose::cir
{
    bool Call::canBeExecuted() const
    {
        if( !IsValueConstantOrExecutable( m_func ) )
            return false;

        if( IsExternalFunc( m_func ) )

        if( !argsCanBeExecuted )
            return false;

        if( IsBuiltinFunc( m_func ) )
            return true;

        const auto* pFunc = GetFuncCIR( m_func );

        // If the func is passed as a value, we might not have been able to evaluate
        // it yet, so we assume it's going to be executable. If it isn't, we'll fail
        // at execution time, which isn't a big deal - we should be able to avoid trying
        // executing it in the first place in most cases.
        return !pFunc || pFunc->canBeExecuted();
    }

        if( !argsAreConstant )
            return false;

        if( IsEagerBuiltinFunc( m_func ) )
            return true;

        const auto* pFuncCIR = GetFuncCIR( m_func );

        if( !pFuncCIR )
            return false;

        return pFuncCIR->canBeExecuted();
    }
}

#ifndef GOOSE_CIR_CALL_H
#define GOOSE_CIR_CALL_H

namespace goose::cir
{
    class Call
    {
        public:
            template< typename F, typename A >
            Call( F&& func, A&& args ) :
                m_func( forward< F >( func ) ),
                m_args( forward< A >( args ) )
            {}

            const auto& func() const { return m_func; }
            const auto& args() const { return m_args; }

            bool canBeExecuted() const;
            bool canBeEagerlyEvaluated() const;

        private:
            eir::Value m_func;
            eir::Term m_args;
    };
}

#endif

#include "cir.h"

using namespace goose;
using namespace goose::cir;

const ptr< cir::BasicBlock >& CFG::createBB()
{
    m_basicBlocks.emplace_back( make_shared< cir::BasicBlock >( shared_from_this(), m_basicBlocks.size() + 1 ) );
    return m_basicBlocks.back();
}

void CFG::addEdge( uint32_t srcIndex, uint32_t destIndex )
{
    m_edges.emplace( srcIndex, destIndex );
}

#ifndef GOOSE_CIR_CFG_H
#define GOOSE_CIR_CFG_H

namespace goose::cir
{
    class BasicBlock;

    class CFG : public enable_shared_from_this< CFG >
    {
        public:
            CFG( uint32_t numParams ) :

            // calling ComputeDominators().
            optional< uint32_t > getDominatorDistance( uint32_t bbIndex1, uint32_t bbIndex2 ) const;

            const auto& getBB( uint32_t index ) const { return m_basicBlocks[index - 1]; }

            auto count() const { return m_basicBlocks.size(); }

            const ptr< cir::BasicBlock >& createBB();

            auto getNewTemporaryIndex() { return m_temporariesCount++; }

            // Clear the llvm basic block pointers from the entire cfg.
            void unbindFromLLVM();

            bool canBeExecuted() const;
            bool canBeEagerlyEvaluated() const;

            template< typename F >
            void forEachBB( F&& func )
            {
                for( auto&& bb : m_basicBlocks )
                    func( bb );
            }

            void setAddressModifiedByLoop( uint32_t loopId, const eir::Term& type, const CalcAddress& addr )
            {
                m_loopModifiedAddresses.emplace( make_pair( loopId, addr ), type );
            }

            template< typename F >
            void forEachAddressModifiedInLoop( uint32_t loopId, F&& func ) const
            {

            // For each BB, store the index of its immediate dominator.
            // May be be empty if it has not (yet) been computed.
            vector< uint32_t > m_idoms;

            // For each loop, store all of the adresses modified
            // during that loop.
            // May be be empty if it has not (yet) been computed.
            multimap< pair< uint32_t, CalcAddress >, eir::Term > m_loopModifiedAddresses;

            // The number of temporary indices used by this CFG.
            uint32_t m_temporariesCount = 0;

            uint32_t m_loopCount = 0;

            bool m_poisoned = false;

#include "cir/cir.h"
#include "builtins/builtins.h"

using namespace goose::builtins;

namespace goose::cir
{
    void CfgViz( GraphVizBuilder& builder, const CFG& cfg )
    {
        CfgViz( builder, cfg.entryBB() );
    }

    void CfgViz( GraphVizBuilder& builder, const ptr< BasicBlock >& bb )

        for( auto&& instr : *bb )
            CfgViz( builder, instr );

        if( bb->terminator() )
            CfgViz( builder, *bb->terminator() );
    }

    void CfgViz( GraphVizBuilder& builder, const eir::Value& val )
    {
        GraphVizBuilder::Node n( builder, &val, "Value" );

        if( val.isConstant() )
        {
            GraphVizBuilder::Row row( builder );
            GraphVizBuilder::Cell cell( builder );
            GraphVizBuilder::Color col( builder );
            builder.output() << val;
            return;
        }

        CfgViz( builder, *val.cir() );
    }

    void CfgViz( GraphVizBuilder& builder, const Instruction& instr )
    {
        visit( [&]( auto&& ins )
        {
            CfgViz( builder, ins );

#ifndef GOOSE_CIR_CFGVIZ_H
#define GOOSE_CIR_CFGVIZ_H

namespace goose::cir
{
    template< typename T >
    void CfgViz( const char* pFilename, const T& x )
    {
        ofstream file( pFilename );
        GraphVizBuilder builder( file, true );
        CfgViz( builder, x );
    }

    extern void CfgViz( GraphVizBuilder& builder, const CFG& cfg );
    extern void CfgViz( GraphVizBuilder& builder, const ptr< BasicBlock >& bb );
    extern void CfgViz( GraphVizBuilder& builder, const eir::Value& val );

    extern void CfgViz( GraphVizBuilder& builder, const Instruction& instr );
    extern void CfgViz( GraphVizBuilder& builder, const Terminator& t );

    extern void CfgViz( GraphVizBuilder& builder, const Call& instr );
    extern void CfgViz( GraphVizBuilder& builder, const CalcAddress& instr );
    extern void CfgViz( GraphVizBuilder& builder, const CreateTemporary& instr );

#ifndef GOOSE_CIR_H
#define GOOSE_CIR_H

#include "util/util.h"
#include "eir/eir.h"

namespace goose::cir
{
    using namespace util;

    static constexpr uint32_t InvalidVarId = numeric_limits< uint32_t >::max();

    class CFG;
}

#ifndef GOOSE_CIR_COMPARISON_H
#define GOOSE_CIR_COMPARISON_H

namespace goose::cir
{
    class Eq : public BinaryOpSameTypes
    {
        public:
            template< typename L, typename R >
            Eq( L&& lhs, R&& rhs ) : BinaryOpSameTypes( forward< L >( lhs ), forward< R >( rhs ) ) {}
    };

#ifndef GOOSE_CIR_CONTINUE_H
#define GOOSE_CIR_CONTINUE_H

namespace goose::cir
{
    class Continue
    {
        public:
            Continue() {}

            Continue( uint32_t level ) :

#ifndef GOOSE_CIR_CREATETEMPORARY_H
#define GOOSE_CIR_CREATETEMPORARY_H

namespace goose::cir
{
    class CreateTemporary
    {
        public:
            template< typename V >
            CreateTemporary( uint32_t index, V&& val ) :
                m_index( index ),

            bool canBeEagerlyEvaluated() const
            {
                return CanValueBeEagerlyEvaluated( m_value );
            }

        private:
            uint32_t m_index = 0;
            eir::Value m_value;
    };
}

#endif

#include "cir.h"

using namespace goose;

// This is an almost verbatim transcription into C++ of the Lengauer-Tarjan algorithm,
// as listed in appendix B of the paper.
namespace
{

        {
            st.ancestor[s] = v;
            s = st.child[s];
        }
    }
}

namespace goose::cir
{
    void ComputeDominators( const ptr< CFG >& cfg )
    {
        // Check if this has already been computed.
        if( !cfg->idoms().empty() )
            return;

#include "cir/cir.h"

namespace goose::cir
{
    bool Func::canBeExecuted() const
    {
        return isValid() && m_body && m_body->canBeExecuted();
    }
}

#ifndef GOOSE_CIR_FUNC_H
#define GOOSE_CIR_FUNC_H

namespace goose::cir
{
    class Func
    {
        public:
            template< typename I >
            Func( I&& identity ) :
                m_identity( forward< I >( identity ) )

            bool canBeExecuted() const;

            bool isValid() const { return m_valid; }
            void setInvalid() { m_valid = false; }

        private:
            eir::Term m_identity;
            ptr< CFG > m_body;
            bool m_valid = true;
    };
}

#endif

#ifndef GOOSE_CIR_GETTEMPORARY_H
#define GOOSE_CIR_GETTEMPORARY_H

namespace goose::cir
{
    class GetTemporary
    {
        public:
            template< typename T >
            GetTemporary( T&& type, uint32_t index ) :
                m_type( forward< T >( type ) ),

            bool canBeEagerlyEvaluated() const
            {
                return false;
            }

        private:
            eir::Term m_type;
            uint32_t m_index = 0;
    };
}

#endif

#include "cir/cir.h"

namespace goose::cir
{
    bool IsValueConstantOrExecutable( const eir::Value& val )
    {
        if( val.isConstant() )
            return true;

        return val.cir()->canBeExecuted();
    }

    bool CanValueBeEagerlyEvaluated( const eir::Value& val )
    {
        if( val.isConstant() )
            return true;

        return val.cir()->canBeEagerlyEvaluated();
    }

    bool IsCompileTimeTempRef( const eir::Value& val )
    {
        if( !val.isConstant() )
            return false;

        const auto* pRefInst = get_if< CalcAddress >( &val.cir()->content() );
        return pRefInst && pRefInst->isTempRef();
    }
}

#ifndef GOOSE_CIR_HELPERS_H
#define GOOSE_CIR_HELPERS_H

namespace goose::cir
{
    class Instruction;

    bool IsValueConstantOrExecutable( const eir::Value& val );
    bool CanValueBeEagerlyEvaluated( const eir::Value& val );
    bool IsCompileTimeTempRef( const eir::Value& val );

    template< typename T, typename I >
    auto BuildComputedValue( T&& type, I&& instr )
    {
        return eir::Value( forward< T >( type ),
            make_shared< Instruction >( forward< I >( instr ) ) );
    }

    template< typename T >
    class TempStorage
    {
        public:

#include "cir/cir.h"

namespace goose::cir
{
    bool Instruction::canBeExecuted() const
    {
        return visit( []< typename ET >( const ET& e )
        {
            if constexpr( is_same_v< ET, ptr< CFG > > )
                return e->canBeExecuted();

#ifndef GOOSE_CIR_INSTRUCTION_H
#define GOOSE_CIR_INSTRUCTION_H

namespace goose::cir
{
    class CFG;

    class Instruction
    {
        public:
            Instruction( Call&& c ) :

#ifndef GOOSE_CIR_LOAD_H
#define GOOSE_CIR_LOAD_H

namespace goose::cir
{
    class Load
    {
        public:
            template< typename A, typename T >
            Load( A&& addr, T&& type ) :
                m_addr( forward< A >( addr ) ),
                m_type( forward< T >( type ) )
            {}

            const auto& addr() const { return m_addr; }
            const auto& type() const { return m_type; }

            bool canBeExecuted() const { return true; }
            bool canBeEagerlyEvaluated() const
            {
                return IsCompileTimeTempRef( m_addr );
            }

        private:
            eir::Value m_addr;
            eir::Term m_type;
    };
}

#endif

#ifndef GOOSE_CIR_LOADCONST_H
#define GOOSE_CIR_LOADCONST_H

namespace llvm
{
    class IntegerType;
}

namespace goose::cir
{
    class LoadConstStr
    {
        public:
            LoadConstStr( const string& str ) :
                m_str( str )
            {}

#ifndef GOOSE_CIR_LOGIC_H
#define GOOSE_CIR_LOGIC_H

namespace goose::cir
{
    class Not
    {
        public:
            template< typename T >
            Not( T&& operand ) :
                m_operand( forward< T >( operand ) )

            bool canBeEagerlyEvaluated() const
            {
                return CanValueBeEagerlyEvaluated( m_operand );
            }

        private:
            eir::Value m_operand;
    };
}

#endif

#include "cir.h"

namespace goose::cir
{
    void MarkAddrChangedByLoop( const ptr< CFG >& cfg, uint32_t loopId, const eir::Term& type, const CalcAddress& addr )
    {
        cfg->setAddressModifiedByLoop( loopId, type, addr );

        const auto& pHeader = cfg->getBB( loopId );

        if( pHeader->loopId() )
            MarkAddrChangedByLoop( cfg, pHeader->loopId(), type, addr );
    }

    void ComputeLoopModifiedAddrs( const ptr< CFG >& cfg )
    {
        cfg->forEachBB( [&]( auto&& bb )
        {
            for( auto&& instr : *bb )
            {
                auto st = get_if< Store >( &instr.content() );
                if( !st )
                    continue;

                auto cir = st->addr().cir();
                if( !cir )
                    continue;

                auto ref = get_if< CalcAddress >( &cir->content() );
                if( !ref )
                    continue;

                MarkAddrChangedByLoop( cfg, bb->index(), st->val().type(), *ref );
            }
        } );
    }
}

#include "cir.h"

// Note: we only handle reducible CFGs for now. The results are undefined (ie probably a clusterfuck) for
// irreducible CFGs. We'll have to handle irreducible CFGs when (if...) we implement goto.
namespace goose::cir
{
    void ComputeLoops( const ptr< CFG >& cfg, const ptr< BasicBlock >& bb );

    void MarkLoop( const ptr< CFG >& cfg, const ptr< BasicBlock >& bb, uint32_t loopHeaderId )
    {
        if( bb->index() == loopHeaderId )
            return;

goose_cir = library( 'goose-cir',
    'cfg.cpp',
    'dominators.cpp',
    'loops.cpp',
    'loopaddrs.cpp',
    'instruction.cpp',
    'binaryop.cpp',
    'terminator.cpp',

#ifndef GOOSE_CIR_PHI_H
#define GOOSE_CIR_PHI_H

namespace goose::cir
{
    class BasicBlock;

    class Phi
    {
        public:
            template< typename T >
            Phi( T&& type, uint32_t numIncomings, uint32_t destIndex ) :
                m_type( forward< T >( type ) ),
                m_destIndex( destIndex )
            {
                m_incomings.reserve( numIncomings );
            }

            const auto& type() const { return m_type; }
            const auto& destIndex() const { return m_destIndex; }

            void setIncoming( const ptr< BasicBlock >& bb, const eir::Value& val )
            {
                m_incomings.emplace_back( bb, val );
            }

            uint32_t numIncomings() const { return m_incomings.size(); }

            template< typename F >

            bool canBeEagerlyEvaluated() const
            {
                return true;
            }

        private:
            eir::Value m_type;
            uint32_t m_destIndex = 0;

            using incInfo = pair< wptr< BasicBlock >, eir::Value >;
            llvm::SmallVector< incInfo, 2 > m_incomings;

    };
}

#endif

#ifndef GOOSE_CIR_PLACEHOLDER_H
#define GOOSE_CIR_PLACEHOLDER_H

namespace goose::cir
{
    // A placeholder value with a name, to be replacedd with something else.
    // Intended to represent the @ return value paceholder in functions'
    // post conditions.
    class Placeholder
    {
        public:

            bool canBeEagerlyEvaluated() const
            {
                return false;
            }

        private:
            eir::Term    m_type;
            StringId    m_name;
    };
}

#endif

#ifndef GOOSE_CIR_RET_H
#define GOOSE_CIR_RET_H

namespace goose::cir
{
    class Ret
    {
        public:
            Ret() {}

            template< typename V >

            {
                return !m_value || CanValueBeEagerlyEvaluated( *m_value );
            }

            void addCFGEdges( const ptr< CFG >& cfg, uint32_t srcBBIndex )  {}

        private:
            optional< eir::Value > m_value;
    };
}

#endif

#ifndef GOOSE_CIR_STORE_H
#define GOOSE_CIR_STORE_H

namespace goose::cir
{
    class Store
    {
        public:
            template< typename A, typename V >
            Store( A&& addr, V&& val ) :
                m_addr( forward< A >( addr ) ),

            bool canBeEagerlyEvaluated() const
            {
                return IsCompileTimeTempRef( m_addr )
                    && CanValueBeEagerlyEvaluated( m_val );
            }

        private:
            eir::Value m_addr;
            eir::Value m_val;
    };
}

#endif

#include "cir/cir.h"

namespace goose::cir
{
    bool Terminator::canBeExecuted() const
    {
        return visit( []( auto&& e )
        {
            return e.canBeExecuted();
        }, m_content );

#ifndef GOOSE_CIR_TERMINATOR_H
#define GOOSE_CIR_TERMINATOR_H

namespace goose::cir
{
    class BasicBlock;

    class Terminator
    {
        public:
            Terminator() {}

#include <exception>
#define CATCH_CONFIG_MAIN
#include "catch2/catch.hpp"
#include "cir/cir.h"

using namespace std;
using namespace goose;
using namespace goose::eir;
using namespace goose::cir;

SCENARIO( "Dominators test 1", "[cir-dom-1]" )
{
    WHEN( "Computing the dominators of an arbitrary CFG" )
    {
        auto cfg = make_shared< CFG >( 0 );

        auto bb1 = cfg->createBB();
        auto bb2 = cfg->createBB();

#include <exception>
#define CATCH_CONFIG_MAIN
#include "catch2/catch.hpp"
#include "cir/cir.h"

using namespace std;
using namespace goose;
using namespace goose::eir;
using namespace goose::cir;

SCENARIO( "Dominators test 1", "[cir-dom-1]" )
{
    WHEN( "Computing the dominators of an arbitrary CFG" )
    {
        auto cfg = make_shared< CFG >( 0 );

        auto bb1 = cfg->createBB();
        auto bb2 = cfg->createBB();

tests = [
    'dom-1',
    'dom-2'
]

# We need to link thess low level test of the cir with the entire planet
# because my module dependencies are a clusterfuck.
foreach t : tests
    exe = executable( 'cir-' + t, t + '.cpp',
        link_with:
        [
            goose_util,
            goose_eir,
            goose_cir,
            goose_builtins,
            goose_sema,
            goose_lex,
            goose_parse,
            goose_diagnostics,
            goose_execute,
            goose_codegen,
            goose_verify,
            goose_compile
        ],
        include_directories: bsinc,
        dependencies: [catch2_dep, fmt_dep, llvm_dep, lld_deps]
    )
    test( 'cir-' + t, exe )
endforeach

#include "codegen.h"
#include "builtins/builtins.h"

using namespace goose;
using namespace goose::codegen;
using namespace goose::builtins;

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Add& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateAdd( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Sub& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateSub( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Mul& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateMul( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::UDiv& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateUDiv( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::SDiv& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateSDiv( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::URem& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateURem( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::SRem& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )

    if( !buildTerminator( inf, *pBB->terminator() ) )
        return nullptr;

    return pBB->llvmBB();
}

bool Module::buildTerminator( Infos& inf, const cir::Terminator& terminator )
{
    return visit( [&]( auto&& e )
    {
        return buildTerminator( inf, e );
    }, terminator.content() );
}

bool Module::buildTerminator( Infos& inf, const cir::Ret& r )
{
    if( !r.value() )
    {
        m_llvmBuilder.CreateRetVoid();
        return true;
    }

    auto* pRetVal = buildValue( inf, *r.value() );
    if( !pRetVal )
        return false;

    m_llvmBuilder.CreateRet( pRetVal );
    return true;
}

bool Module::buildTerminator( Infos& inf, const cir::Branch& b )
{
    m_llvmBuilder.CreateBr( b.dest().lock()->llvmBB() );

    llvm::IRBuilderBase::InsertPointGuard g( m_llvmBuilder );

    if( !buildBasicBlock( inf, b.dest().lock() ) )
        return false;

    return true;
}

bool Module::buildTerminator( Infos& inf, const cir::CondBranch& cb )
{
    auto* pCondVal = buildValue( inf, cb.cond() );
    if( !pCondVal )
        return false;

    m_llvmBuilder.CreateCondBr( pCondVal,
        cb.trueDest().lock()->llvmBB(), cb.falseDest().lock()->llvmBB() );

#ifndef GOOSE_CODEGEN_H
#define GOOSE_CODEGEN_H

#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Target/TargetMachine.h"

#include "cir/cir.h"
#include "sema/sema.h"

namespace goose::builtins
{
    class Func;
    class FuncType;
}

namespace goose::codegen
{
    using namespace eir;
    using namespace cir;
    using namespace sema;

    extern llvm::LLVMContext& GetLLVMContext();
    extern optional< string > Mangle( const Term& identity );
}

#include "module.h"

#include "codegen.h"
#include "builtins/builtins.h"

using namespace goose;
using namespace goose::codegen;
using namespace goose::builtins;

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Eq& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpEQ( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Neq& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpNE( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::UGT& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpUGT( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::UGE& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpUGE( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::ULT& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpULT( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::ULE& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpULE( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::SGT& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpSGT( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::SGE& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpSGE( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::SLT& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateICmpSLT( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::SLE& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )

}

llvm::Function* Module::getOrCreateFunc( const Context& c, const builtins::Func& func )
{
    if( func.isExternal() )
        return getOrCreateFunc( c, func, *func.symbol(), llvm::Function::ExternalLinkage );

    auto name = Mangle( func.cir()->identity() );
    if( !name )
        return nullptr;

    return getOrCreateFunc( c, func, *name, llvm::Function::PrivateLinkage );
}

llvm::Function* Module::getOrCreateFunc( const Context& c, const builtins::Func& func, const string& name,

    if( func.isExternal() )
        return pllvmFunc;

    Infos inf( c );

    // Generate allocas and stores for the args
    auto pEntryBB = func.cir()->body()->entryBB();
    if( !pEntryBB->llvmBB() )
        pEntryBB->setLLVMBB( llvm::BasicBlock::Create( GetLLVMContext(), "", pllvmFunc ) );

    inf.allocaBasicBlock = pEntryBB->llvmBB();
    m_llvmBuilder.SetInsertPoint( pEntryBB->llvmBB() );

    llvm::SmallVector< NullInit< llvm::Value* >, 8 > args;

    for( auto&& arg : pllvmFunc->args() )
    {
        m_llvmBuilder.CreateStore( &arg, args[i] );
        inf.temporaries->set( i, args[i] );
        ++i;
    }

    if( !buildCFG( inf, pllvmFunc, func.cir()->body() ) )
        return nullptr;

    llvm::verifyFunction( *pllvmFunc );
    return pllvmFunc;
}

llvm::BasicBlock* Module::buildCFG( Infos& inf, llvm::Function* llvmFunc, const ptr< cir::CFG >& pCFG )
{
    pCFG->forEachBB( [&]( auto&& pBB )
    {
        if( !pBB->llvmBB() )
            pBB->setLLVMBB( llvm::BasicBlock::Create( GetLLVMContext(), "", llvmFunc ) );
    } );

    return buildBasicBlock( inf, pCFG->entryBB() );
}

#include "codegen.h"
#include "builtins/builtins.h"

using namespace goose;
using namespace goose::codegen;
using namespace goose::builtins;

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Instruction& instr )
{
    return visit( [&]( auto&& e )
    {
        return buildInstruction( inf, e );
    }, instr.content() );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Call& call )
{
    const auto& callee = call.func();
    if( IsBuiltinFunc( callee ) || IsIntrinsicFunc( callee ) )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage(
            callee.locationId(), "builtin functions can't be called at runtime." );
    }

        args.emplace_back( parg );
    }

    return m_llvmBuilder.CreateCall( llvm::FunctionCallee( llvmCallee ), args );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::CreateTemporary& ct )
{
    return createTemporary( inf, ct.index(), buildValue( inf, ct.value() ) );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::GetTemporary& gt )
{
    auto* ppVal = inf.temporaries->get( gt.index() );
    assert( ppVal );
    if( !ppVal )
        return nullptr;
    return *ppVal;
}

        m_llvmBuilder.SetInsertPoint( inf.allocaBasicBlock, inf.allocaBasicBlock->begin() );

    inf.lastEmittedAlloca = m_llvmBuilder.CreateAlloca( type );

    return inf.lastEmittedAlloca;
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::AllocVar& av )
{
    auto type = LowerTypeForRuntime( inf.context, av.type() );
    if( !type )
        return nullptr;

    auto* pAlloca = buildAlloca( inf, GetLLVMType( *type ) );
    createTemporary( inf, av.index(), pAlloca );
    return pAlloca;
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Load& load )
{
    auto type = LowerTypeForRuntime( inf.context, *ValueFromIRExpr( load.type() ) );
    if( !type )
        return nullptr;

    auto* llvmType = GetLLVMType( *type );
    assert( llvmType );

    auto* ptrVal = buildValue(inf, load.addr() );//  buildAddress( inf, load.addr() );
    return m_llvmBuilder.CreateLoad( llvmType, ptrVal );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Store& store )
{
    auto* pValue = buildValue( inf, store.val() );
    if( !pValue )
        return nullptr;

    auto* ptrVal = buildValue(inf, store.addr() );

        return m_llvmBuilder.CreateMemCpy( ptrVal, llvm::None, pGlob, llvm::None,
            llvm::ConstantInt::get( llvm::Type::getInt32Ty( GetLLVMContext() ), size ) );
    }

    return m_llvmBuilder.CreateStore( pValue, ptrVal );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Phi& p )
{
    auto type = LowerTypeForRuntime( inf.context, p.type() );
    if( !type )
        return nullptr;

    auto* pPHI = m_llvmBuilder.CreatePHI( GetLLVMType( *type ), p.numIncomings() );
    if( !pPHI )

    if( !pPHI )
        return nullptr;

    return createTemporary( inf, p.destIndex(), pPHI );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::LoadConstStr& lcs )
{
    llvm::GlobalVariable* pGlob = nullptr;

    auto* arType = llvm::ArrayType::get( llvm::IntegerType::getInt8Ty( GetLLVMContext() ),
        lcs.str().size() + 1 );

    auto it = m_strings.find( lcs.str() );

        llvm::ConstantInt::get( llvm::Type::getInt8Ty( GetLLVMContext() ), 0 ),
        llvm::ConstantInt::get( llvm::Type::getInt8Ty( GetLLVMContext() ), 0 )
    };

    return m_llvmBuilder.CreateGEP( pGlob, idxs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Assert& ass )
{
    // We can't just return null as it is considered an error by the rest of the code.
    // Since the assert instruction will only appear in a cfg instruction list, this
    // will not actually be used anyway.
    return llvm::ConstantInt::getTrue( GetLLVMContext() );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Placeholder& ph )
{
    // Same as above.
    return llvm::ConstantInt::getTrue( GetLLVMContext() );
}

#include "codegen.h"
#include "builtins/builtins.h"

using namespace goose;
using namespace goose::codegen;
using namespace goose::builtins;

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Not& uo )
{
    auto operand = buildValue( inf, uo.operand() );
    if( !operand )
        return nullptr;

    return m_llvmBuilder.CreateXor( operand, llvm::ConstantInt::getTrue( GetLLVMContext() ) );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::And& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateAnd( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Or& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateOr( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Xor& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateXor( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::Shl& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateShl( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::LShr& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )
        return nullptr;

    return m_llvmBuilder.CreateLShr( lhs, rhs );
}

llvm::Value* Module::buildInstruction( Infos& inf, const cir::AShr& bo )
{
    auto lhs = buildValue( inf, bo.lhs() );
    if( !lhs )
        return nullptr;

    auto rhs = buildValue( inf, bo.rhs() );
    if( !rhs )

#include "codegen.h"

using namespace goose;
using namespace goose::eir;

// Mangling scheme:
//
// Functions, types and everything are uniquely identified by IR expressions
// (built out of eir::Term objects) called Identities.
// The mangling scheme is therefore a lossless text serialization of such an identity,
// with a simple compression scheme to make it shorter.
//
// All integers serialized as part of this scheme are in hex.
//
// Each element is introduced by one character. Hex digits (0-9, a-f) can't be used as
// intro characters.
//
// Literal elements:
//   i: integer, followed by its value
//   S: string, followed by its length, followed by ':', followed by the string itself.
//   n: anonymous StringId, followed by its unique id
//   s: StringId, followed by its length, followed by ':', followed by the string itself.
//   _ followed by an hex number: vector, whose length is that number,
//     followed by its contained elements, serialized recursively.
//   @ same as above, but the vector is of variable length and is followed by the repetition element.
//   p, P: a void* or ptr< void > term (unfortunately they have legitimate uses in some type identitiers
//      that we do need to be able to mangle)
//   x: an eir term placeholder.
//
// $: compressed string id: it is followed by the 0 based index of a previously encountered
//   StringId literal, in the order they were encountered.
//
// The letters V, o, v, t, q, u, r:
//   respectively the StringIDs: Value, Constant, void, type,
//   quote, func, param.

            {
                Infos( const Context& c ) : context( c ) {}
                const Context& context;

                llvm::BasicBlock* allocaBasicBlock = nullptr;
                llvm::AllocaInst* lastEmittedAlloca = nullptr;

                using storage_type = cir::TempStorage< NullInit< llvm::Value* > >;
                ptr< storage_type > temporaries = make_shared< storage_type >();
            };

            llvm::Function* getCurrentFunction() const
            {
                return m_llvmBuilder.GetInsertBlock()->getParent();
            }

            llvm::BasicBlock* buildCFG( Infos& inf, llvm::Function* llvmFunc, const ptr< cir::CFG >& pCFG );
            llvm::BasicBlock* buildBasicBlock( Infos& inf, const ptr< cir::BasicBlock >& pBB );

            llvm::Value* buildValue( Infos& inf, const Value& val );
            llvm::Constant* buildConstant( Infos& inf, const Value& val );

            llvm::Value* buildInstruction( Infos& inf, const cir::Instruction& instr );
            llvm::Value* buildInstruction( Infos& inf, const cir::Call& call );
            llvm::Value* buildInstruction( Infos& inf, const cir::CalcAddress& ct );
            llvm::Value* buildInstruction( Infos& inf, const cir::CreateTemporary& ct );
            llvm::Value* buildInstruction( Infos& inf, const cir::GetTemporary& gt );
            llvm::Value* buildInstruction( Infos& inf, const cir::AllocVar& av );
            llvm::Value* buildInstruction( Infos& inf, const cir::Load& load );
            llvm::Value* buildInstruction( Infos& inf, const cir::Store& store );
            llvm::Value* buildInstruction( Infos& inf, const cir::Phi& p );
            llvm::Value* buildInstruction( Infos& inf, const cir::LoadConstStr& lcs );

            llvm::Value* buildInstruction( Infos& inf, const cir::Not& uo );
            llvm::Value* buildInstruction( Infos& inf, const cir::And& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::Or& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::Xor& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::Shl& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::LShr& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::AShr& bo );

            llvm::Value* buildInstruction( Infos& inf, const cir::Add& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::Sub& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::Mul& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::UDiv& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::SDiv& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::URem& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::SRem& bo );

            llvm::Value* buildInstruction( Infos& inf, const cir::Eq& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::Neq& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::UGT& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::UGE& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::ULT& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::ULE& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::SGT& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::SGE& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::SLT& bo );
            llvm::Value* buildInstruction( Infos& inf, const cir::SLE& bo );

            llvm::Value* buildInstruction( Infos& inf, const cir::Assert& ass );
            llvm::Value* buildInstruction( Infos& inf, const cir::Placeholder& ph );

            bool buildTerminator( Infos& inf, const cir::Terminator& terminator );
            bool buildTerminator( Infos& inf, const cir::Ret& r );
            bool buildTerminator( Infos& inf, const cir::Branch& b );
            bool buildTerminator( Infos& inf, const cir::CondBranch& cb );

            template< typename T >
            bool buildTerminator( Infos& inf, const T& t )
            {
                return false;
            }

{
    if( val.isPoison() )
        return nullptr;

    if( val.isConstant() )
        return buildConstant( inf, val );

    return buildInstruction( inf, *val.cir() );
}

llvm::Constant* Module::buildConstant( Infos& inf, const Value& v )
{
    assert( v.isConstant() );

    auto val = LowerConstantForRuntime( inf.context, v );

#include "llvm/Support/TargetSelect.h"

#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h"

using namespace goose;
using namespace goose::util;
using namespace goose::eir;
using namespace goose::sema;
using namespace goose::diagnostics;
using namespace goose::builtins;

namespace goose::compile
{
    Compiler::Compiler( int argc, char** argv ) :

            return PoisonValue();
        }

        execute::VM vm;
        return vm.execute( cfg->entryBB() );
    }

    ptr< cir::CFG > Compiler::LoadAndParseFile( const ptr< Env >& e, const string& filename, const Term& identity,
        const Term& returnType, optional< Value > defRetVal )
    {
        auto& dm = DiagnosticsManager::GetInstance();

        assert( returnType == GetValueType< void >() || defRetVal );

        ifstream sourcefile( filename.c_str() );
        if( !sourcefile.good() )
        {
            dm.emitErrorMessage( 0,
                format( "can't open '{}'.", filename ) );
            return nullptr;
        }

        sema::Context c( e, identity, returnType );
        DiagnosticsContext dc( 0, true );
        VerbosityContext vc( Verbosity::Normal, true );

        auto cfg = make_shared< cir::CFG >( 0 );
        cfg->createBB();
        cfg->setCurrentBB( cfg->entryBB() );

        auto cb = make_shared< CodeBuilder >( cfg );
        c.setBuilder( cb );

        auto r = make_shared< parse::Resolver >(

        if( cfg->currentBB() && !cfg->currentBB()->terminator() )
        {
            p.flushValue();
            cb->destroyAllLiveValues( c );

            if( returnType == GetValueType< void >() )
               cb->emitTerminator( r->currentLocation(), cir::Ret() );
            else if( !defRetVal )
            {
                dm.emitSyntaxErrorMessage( r->currentLocation(), "missing return statement." );
                return nullptr;
            }
            else
            {

                            dm.emitErrorMessage( defRetVal->locationId(), "ambiguous default return value conversion." );
                            break;
                    }

                    return nullptr;
                }

                cb->emitTerminator( r->currentLocation(), cir::Ret( get< Value >( converted ) ) );
            }
        }

        verify::Func fv( c, cfg );
        if( !fv.verify() )
            return nullptr;

        return cfg;
    }
}

    class Compiler
    {
        public:
            Compiler( int argc, char** argv );
            uint32_t execute( const string& filename );

            static optional< eir::Value > LoadAndExecuteFile( const util::ptr< sema::Env >& e, const string& filename,
                const eir::Term& identity, const eir::Term& returnType, optional< eir::Value > defRetVal );

            static util::ptr< cir::CFG > LoadAndParseFile( const util::ptr< sema::Env >& e, const string& filename,
                const eir::Term& identity, const eir::Term& returnType, optional< eir::Value > defRetVal );

        private:
            util::ptr< sema::Env > m_pEnv;
    };
}

#endif

#ifndef GOOSE_DIAGNOSTICS_H
#define GOOSE_DIAGNOSTICS_H

#include "eir/eir.h"

namespace goose::diagnostics
{
    using namespace eir;
}

#include "location.h"
#include "renderer.h"
#include "diagnosticsmanager.h"
#include "diagnosticscontext.h"
#include "verbositycontext.h"

#ifndef GOOSE_EIR_ANYTERM_H
#define GOOSE_EIR_ANYTERM_H

namespace goose::eir
{
    class AnyTerm
    {
        public:
            template< typename S >
            AnyTerm( S&& varName ) :
                m_varName( varName )

        private:
            StringId m_varName;
    };
}

namespace std
{
    template<> struct hash< goose::eir::AnyTerm >
    {
        size_t operator()( const goose::eir::AnyTerm& x ) const
        {
            return hash< goose::util::StringId >()( x.varName() );
        }
    };
}

#endif

#ifndef GOOSE_EIR_BRIDGE_H
#define GOOSE_EIR_BRIDGE_H

namespace goose::eir
{
    template< typename T >
    struct Bridge
    {};

    template< typename T, typename... P >
    auto GetValueType( P&&... params )

#include "eir.h"

namespace goose::eir
{
    bool Compare( const Trie<>& lhs, const Trie<>& rhs )
    {
        return Compare<>( lhs, rhs, []( auto&&, auto&& ){ return true; } );
    }

    bool operator==( const Term& lhs, const Term& rhs )

#ifndef GOOSE_EIR_COMPARE_H
#define GOOSE_EIR_COMPARE_H

namespace goose::eir
{
    template< typename U, typename F >
    static bool Compare( const Trie< U >& lhs, const Trie< U >& rhs, F&& next );

    extern bool Compare( const Trie<>& lhs, const Trie<>& rhs );

    extern bool operator==( const Term& lhs, const Term& rhs );

#ifndef GOOSE_EIR_COMPARE_INL
#define GOOSE_EIR_COMPARE_INL

namespace goose::eir
{
    //--------------------------------------------------------------------------------------------
    // Primitive types
    //--------------------------------------------------------------------------------------------
    template< typename T, typename U, typename F >
    static bool Compare( const ValueTrieNode< T, U >& lhs, const ValueTrieNode< T, U >& rhs, F&& next )
    {

#ifndef GOOSE_EIR_DECOMPOSE_H
#define GOOSE_EIR_DECOMPOSE_H

namespace goose::eir
{
    template< typename T >
    struct LiteralSpec
    {
        using return_type = bool;

        template< typename TT >

#ifndef GOOSE_EIR_DECOMPOSE_INL
#define GOOSE_EIR_DECOMPOSE_INL

namespace goose::eir
{
    template< typename T >
    auto Lit( T&& val )
    {
        return LiteralSpec< T >( forward< T >( val ) );
    }

#ifndef GOOSE_EIR_H
#define GOOSE_EIR_H

#include "util/util.h"

namespace goose::eir
{
    using namespace util;

    struct EmptyPayload {};

    template< typename U = EmptyPayload >
    class Trie;

#include "eir.h"

namespace goose::eir
{
    Generator< Term > Enumerate( const Trie<>& trie )
    {
        for( auto&& [t,p] : Enumerate<>( trie ) )
            co_yield move( t );
    }
}

#ifndef GOOSE_EIR_ENUMERATE_H
#define GOOSE_EIR_ENUMERATE_H

namespace goose::eir
{
    template< typename U >
    static Generator< pair< Term, const U& > > Enumerate( const Trie< U >& trie );

    extern Generator< Term > Enumerate( const Trie<>& trie );
}

#ifndef GOOSE_EIR_ENUMERATE_INL
#define GOOSE_EIR_ENUMERATE_INL

namespace goose::eir
{
    //--------------------------------------------------------------------------------------------
    // Primitive types
    //--------------------------------------------------------------------------------------------
    template< typename T, typename U >
    static Generator< pair< Term, const U& > > Enumerate( const ValueTrieNode< T, U >& trie )
    {

#include "eir.h"

namespace goose::eir
{
    void GraphVizDump( const char* pFilename, const Trie<>& trie )
    {
        GraphVizDump<>( pFilename, trie );
    }
}

#ifndef GOOSE_EIR_GRAPHVIZ_H
#define GOOSE_EIR_GRAPHVIZ_H

namespace goose::eir
{
    template< typename U >
    static void GraphVizDump( const char* pFilename, const Trie< U >& trie );

    extern void GraphVizDump( const char* pFilename, const Trie<>& trie );
}

#ifndef GOOSE_EIR_GRAPHVIZ_INL
#define GOOSE_EIR_GRAPHVIZ_INL

namespace goose::eir
{
    template< typename U, typename F >
    static void GraphVizDump( GraphVizBuilder& builder, const Trie< U >& trie, F&& next );

    //--------------------------------------------------------------------------------------------
    // Primitive types
    //--------------------------------------------------------------------------------------------

#include "eir.h"

namespace goose::eir
{
    Term ConcatenateVectorTerms( const Term& vector1, const Term& vector2 )
    {
        const auto& vec1 = *get< pvec >( vector1 );
        const auto& vec2 = *get< pvec >( vector2 );
        auto newVec = Vector::MakeConcat( vec1, vec2 );
        return TERM( make_shared< Vector >( move( newVec ) ) );

#ifndef GOOSE_EIR_HELPERS_H
#define GOOSE_EIR_HELPERS_H

namespace goose::eir
{
    static inline auto VecSize( const Term& vectorTerm )
    {
        return get< pvec >( vectorTerm )->terms().size();
    }

    template< typename... T >

#ifndef GOOSE_EIR_HELPERS_INL
#define GOOSE_EIR_HELPERS_INL

namespace goose::eir
{
    template< typename... T >
    Term AppendToVectorTerm( const Term& vectorTerm, T&&... t )
    {
        const auto& vec = *get< pvec >( vectorTerm );
        auto newVec = Vector::MakeAppend( vec, forward< T >( t )... );
        return TERM( make_shared< Vector >( move( newVec ) ) );

#include "eir.h"

namespace goose::eir
{
    size_t MatchSolution::numVars() const
    {
        if( !m_pVars )
            return 0;

        return m_pVars->size();

#ifndef GOOSE_EIR_MATCH_H
#define GOOSE_EIR_MATCH_H

namespace goose::eir
{
    class MatchSolution
    {
        public:
            size_t complexity() const { return m_complexity; }
            size_t numVars() const;

#ifndef GOOSE_EIR_MATCH_INL
#define GOOSE_EIR_MATCH_INL

namespace goose::eir
{
    template< typename U >
    static Generator< pair< MatchSolution, const U& > > Match( MatchSolution&& s, const Term& expression, const Trie< U >& patterns );

    template< size_t I = 0, typename U, typename V >
    static Generator< tuple< MatchSolution, const U&, const V& > > Match( MatchSolution&& s, const Trie< U >& expressions, const Trie< V >& patterns );

#include "eir.h"

namespace goose::eir
{
    Trie<> Merge( const Trie<>& trie, const Term& term )
    {
        return Merge( trie, term, []( auto&& ){ return EmptyPayload(); } );
    }
}

#ifndef GOOSE_EIR_MERGE_H
#define GOOSE_EIR_MERGE_H

namespace goose::eir
{
    template< typename U, typename F >
    static Trie< U > Merge( const Trie< U >& trie, const Term& term, F&& func );

    extern Trie<> Merge( const Trie<>& trie, const Term& term );
}

#ifndef GOOSE_EIR_MERGE_INL
#define GOOSE_EIR_MERGE_INL

namespace goose::eir
{
    //--------------------------------------------------------------------------------------------
    // Primitive types
    //--------------------------------------------------------------------------------------------
    template< typename T, typename U, typename F >
    static ptr< TrieNode< T, U > > Merge( const ptr< TrieNode< T, U > >& lhs, const T& rhs, F&& next )
    {

goose_eir = library( 'goose-eir',
    'tostring.cpp',
    'merge.cpp',
    'compare.cpp',
    'enumerate.cpp',
    'match.cpp',
    'graphviz.cpp',
    'value.cpp',

#ifndef GOOSE_EIR_TERM_H
#define GOOSE_EIR_TERM_H

namespace goose::eir
{
    class Vector;
    using pvec = ptr< Vector >;

    // We use a distinct type to store locations so that we can handle it differently
    // in the pattern matching algorithms. We consider all LocationId to be equal to one another
    // regardless of their value. This way we can keep it around in IR expessions without having

    static inline ostream& operator<<( ostream& out, const Term& t )
    {
       return ToString( out, t );
    }

    // A term associated with a location id.
    // Used to represent tokens and tokens/values coming out of the resolver.
    using TermLoc = pair< eir::Term, uint32_t >;
}

namespace std
{
    template<> struct hash< goose::eir::Hole >
    {
        size_t operator()( const goose::eir::Hole& x ) const
        {
            return hash< goose::util::StringId >()( x.name );
        }
    };
}

#define TERM( x )           eir::Term( x )
#define TSTR( x )           TERM( string( x ) )
#define TSID( x )           TERM( #x##_sid )
#define HOLE( x )           TERM( eir::Hole{ x } )
#define ANYTERM( x )        TERM( eir::AnyTerm( #x##_sid ) )
#define VECOFLENGTH( x )    TERM( eir::VecOfLength( #x##_sid ) )
#define VEC( ... )          TERM( eir::Vector::Make( __VA_ARGS__ ) )
#define REPEAT( x )         eir::Repetition( x )

#endif

#define CATCH_CONFIG_MAIN
#include "catch2/catch.hpp"
#include "eir/eir.h"

using namespace std;
using namespace goose;
using namespace goose::eir;

SCENARIO( "Match works", "[match]" )
{
    WHEN( "Matching various expressions against various patterns stored in a trie" )
    {
        auto pat0 = ANYTERM( a );