Goose  Check-in [0db147f117]

AccessModifierOffset: -2
AlignAfterOpenBracket: false
AlignArrayOfStructures: Right
AlignConsecutiveAssignments:
  Enabled: false
  AcrossEmptyLines: true
  AcrossComments: false
AlignConsecutiveBitFields:
  Enabled: false
  AcrossEmptyLines: true
  AcrossComments: false
AlignConsecutiveDeclarations:
  Enabled: false
  AcrossEmptyLines: true
  AcrossComments: false
AlignConsecutiveMacros:
  Enabled: false
  AcrossEmptyLines: true
  AcrossComments: false
AlignConsecutiveShortCaseStatements:
  Enabled: false
  AcrossEmptyLines: true
  AcrossComments: true
  AlignCaseColons: false
AlignEscapedNewlines: DontAlign
AlignOperands: DontAlign
AlignTrailingComments:
  Kind: Never
  OverEmptyLines: 2
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowBreakBeforeNoexceptSpecifier: OnlyWithParen
AllowShortBlocksOnASingleLine: Empty
AllowShortCaseLabelsOnASingleLine: false
AllowShortCompoundRequirementOnASingleLine: true
AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: false
AllowShortLambdasOnASingleLine: true
AllowShortLoopsOnASingleLine: false
AlwaysBreakBeforeMultilineStrings: true
BinPackArguments: true
BinPackParameters: true
BitFieldColonSpacing: After
BracedInitializerIndentWidth: 4
BreakAdjacentStringLiterals: true
BreakAfterAttributes: Always
BreakAfterReturnType: Automatic
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Allman
BreakBeforeConceptDeclarations: Always
BreakBeforeTernaryOperators: false
BreakBinaryOperations: Never
BreakConstructorInitializers: AfterColon
BreakFunctionDefinitionParameters: false
BreakInheritanceList: AfterComma
BreakStringLiterals: true
BreakTemplateDeclarations: Yes
CompactNamespaces: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
ColumnLimit: 100
Cpp11BracedListStyle: false
DerivePointerAlignment: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: Always
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
IncludeBlocks: Regroup
IndentAccessModifiers: false
IndentCaseBlocks: false
IndentCaseLabels: true
IndentExternBlock: true
IndentGotoLabels: false
IndentPPDirectives: BeforeHash
IndentRequiresClause: true
IndentWidth: 4
IndentWrappedFunctionNames: false
InsertBraces: false
InsertNewlineAtEOF: true
InsertTrailingCommas: None
IntegerLiteralSeparator:
  Binary: 4
  Decimal: 3
  DecimalMinDigits: 5
  Hex: 4
  HexMinDigits: 6
KeepEmptyLines:
  AtEndOfFile: false
  AtStartOfBlock: false
  AtStartOfFile: false
LambdaBodyIndentation: Signature
MainIncludeChar: Any
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
PPIndentWidth: 4
PackConstructorInitializers: Never
PointerAlignment: Left
QualifierAlignment: Left
QualifierOrder: [static, inline, const, type, volatile]
ReferenceAlignment: Left
ReflowComments: true
RemoveBracesLLVM: true
RemoveParentheses: ReturnStatement
RemoveSemicolon: true
RequiresClausePosition: WithPreceding
RequiresExpressionIndentation: OuterScope
SeparateDefinitionBlocks: Always
ShortNamespaceLines: 2
SkipMacroDefinitionBody: false
SortIncludes: Never
SortUsingDeclarations: LexicographicNumeric
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: false
SpaceAroundPointerQualifiers: After
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: false
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: Always
SpacesInContainerLiterals: false
SpacesInLineCommentPrefix:
  Minimum: 1
  Maximum: -1
SpacesInParens: Custom
SpacesInParensOptions:
  ExceptDoubleParentheses: false
  InConditionalStatements: true
  InEmptyParentheses: false
  Other: true
SpacesInSquareBrackets: false
Standard: c++20
TabWidth: 4
UseTab: Never

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "type": "lldb",
            "request": "launch",
            "name": "Launch",
            "program": "${workspaceFolder}/../dbuild/goose",
            "args": [],
            "cwd": "${workspaceFolder}/../dbuild/"
        }

    ]
}

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

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

namespace goose::builtins
{
    void SetupCodeBuilderInterface( Env& e )
    {
        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extPoisonBuilder(),
            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { cb->poison(); } );



        RegisterBuiltinFunc< Eager< bool >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extBuilderAllowsOverloading(),
            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { return true; } );




        RegisterBuiltinFunc< Eager< TypeWrapper< ptr< cir::CFG > > >(
            TypeWrapper< ptr< CodeBuilder > > ) >( e, e.extGetCFG(),

            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { return cb->cfg(); } );


        RegisterBuiltinFunc< Eager< uint32_t >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extGetBreakableScopeLevels(), []( const TypeWrapper< ptr< CodeBuilder > >& cb )

            { return cb->breakableScopeLevels(); } );


        RegisterBuiltinFunc< Eager< uint32_t >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extGetContinuableScopeLevels(), []( const TypeWrapper< ptr< CodeBuilder > >& cb )

            { return cb->continuableScopeLevels(); } );


        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extBeginLifetimeScope(),
            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { cb->beginLifetimeScope(); } );



        RegisterBuiltinFunc< Intrinsic< void( TypeWrapper< ptr< CodeBuilder > > ) > >( e,
            e.extEndLifetimeScope(),
            []( auto&& c, const Value& b )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( b );
                cb->endLifetimeScope( c );
            } );

        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extBeginBreakableScope(),
            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { cb->beginBreakableScope(); } );



        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extEndBreakableScope(),
            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { cb->endBreakableScope(); } );



        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extBeginContinuableScope(),
            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { cb->beginContinuableScope(); } );



        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< CodeBuilder > > ) >( e,
            e.extEndContinuableScope(),
            []( const TypeWrapper< ptr< CodeBuilder > >& cb ) { cb->endContinuableScope(); } );



        RegisterBuiltinFunc<
            Intrinsic< void( TypeWrapper< ptr< CodeBuilder > >, Value, uint32_t ) > >( e,
            e.extDeclareValue(),
            []( auto&& c, const Value& cbv, const Value& v, const Value& index )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( cbv );
                cb->declareValue( c, v, *FromValue< uint32_t >( index ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< CodeBuilder > >, Value ) > >( e,
            e.extDestroyLiveValue(),
            []( auto&& c, const Value& cbv, const Value& val )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( cbv );
                return ToValue( cb->destroyLiveValue( c, val ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< CodeBuilder > > ) > >( e,
            e.extDestroyAllLiveValues(),
            []( auto&& c, const Value& cbv )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( cbv );
                return ToValue( cb->destroyAllLiveValues( c ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< CodeBuilder > >, uint32_t ) > >( e,
            e.extDestroyAllLiveValuesFromBreakScope(),
            []( auto&& c, const Value& cbv, const Value& index )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( cbv );
                return ToValue(
                    cb->destroyAllLiveValuesFromBreakScope( c, *FromValue< uint32_t >( index ) ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< CodeBuilder > >, uint32_t ) > >( e,
            e.extDestroyAllLiveValuesFromContinueScope(),
            []( auto&& c, const Value& cbv, const Value& index )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( cbv );
                return ToValue( cb->destroyAllLiveValuesFromContinueScope(
                    c, *FromValue< uint32_t >( index ) ) );
            } );
    }

} // namespace goose::builtins

#ifndef GOOSE_BUILTINS_BUILDERS_CODEBUILDER_H
#define GOOSE_BUILTINS_BUILDERS_CODEBUILDER_H

namespace goose::builtins
{
    class CodeBuilder : public LifeCycleManager< CodeBuilder >
    {
      public:
        template< typename C >
        CodeBuilder( C&& cfg ) :
            m_cfg( forward< C >( cfg ) )

        {
        }

        const auto& cfg() const { return m_cfg; }

        void poison()
        {
            if( m_cfg )
                m_cfg->poison();
        }

        template< typename V > void append( V&& v )

        {
            cfg()->currentBB()->append( forward< V >( v ) );
        }

      private:
        ptr< cir::CFG > m_cfg;
    };
} // namespace goose::builtins

#endif

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

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

namespace goose::builtins
{
    // Default builder behavior, for cases where we don't want a builder at all, or for simple
    // builders that need to overload only a few builder operations.
    void SetupDefaultBuilderInterface( Env& e )
    {
        RegisterBuiltinFunc< Eager< void >( Value ) >(
            e, e.extPoisonBuilder(), []( const Value& b ) {} );


        RegisterBuiltinFunc< Eager< bool >( Value ) >(
            e, e.extBuilderAllowsOverloading(), []( const Value& b ) { return false; } );




        RegisterBuiltinFunc< Eager< TypeWrapper< ptr< cir::CFG > > >( Value ) >(
            e, e.extGetCFG(), []( const Value& b ) { return nullptr; } );




        RegisterBuiltinFunc< Eager< uint32_t >( Value ) >(
            e, e.extGetBreakableScopeLevels(), []( const Value& b ) { return 0; } );




        RegisterBuiltinFunc< Eager< uint32_t >( Value ) >(
            e, e.extGetContinuableScopeLevels(), []( const Value& b ) { return 0; } );




        RegisterBuiltinFunc< Intrinsic< void( Value ) > >( e, e.extBeginVisibilityScope(),
            []( auto&& c, const Value& b ) { c.beginVisibilityScope(); } );




        RegisterBuiltinFunc< Eager< void >( Value ) >(
            e, e.extBeginLifetimeScope(), []( const Value& b ) {} );


        RegisterBuiltinFunc< Eager< void >( Value ) >(
            e, e.extEndLifetimeScope(), []( const Value& b ) {} );


        RegisterBuiltinFunc< Eager< void >( Value ) >(
            e, e.extBeginBreakableScope(), []( const Value& b ) {} );


        RegisterBuiltinFunc< Eager< void >( Value ) >(
            e, e.extEndBreakableScope(), []( const Value& b ) {} );


        RegisterBuiltinFunc< Eager< void >( Value ) >(
            e, e.extBeginContinuableScope(), []( const Value& b ) {} );


        RegisterBuiltinFunc< Eager< void >( Value ) >(
            e, e.extEndContinuableScope(), []( const Value& b ) {} );


        RegisterBuiltinFunc< Intrinsic< void( Value, Value, uint32_t ) > >( e, e.extDeclareValue(),
            []( auto&& c, const Value& b, const Value& v, const Value& index ) {} );


        RegisterBuiltinFunc< Intrinsic< void( Value, Value, uint32_t ) > >( e,
            e.extOnValueDeclared(),
            []( auto&& c, const Value& b, const Value& v, const Value& index ) {} );


        RegisterBuiltinFunc< Eager< bool >( Value ) >(
            e, e.extDestroyLiveValue(), []( const Value& b ) { return true; } );




        RegisterBuiltinFunc< Eager< bool >( Value ) >(
            e, e.extDestroyAllLiveValues(), []( const Value& b ) { return true; } );




        RegisterBuiltinFunc< Eager< bool >( Value, uint32_t ) >( e,
            e.extDestroyAllLiveValuesFromBreakScope(),
            []( const Value& b, uint32_t index ) { return true; } );



        RegisterBuiltinFunc< Eager< bool >( Value, uint32_t ) >( e,
            e.extDestroyAllLiveValuesFromContinueScope(),
            []( const Value& b, uint32_t index ) { return true; } );




        RegisterBuiltinFunc< Eager< bool >( Value ) >(
            e, e.extInVerificationCode(), []( const Value& b ) { return false; } );




        RegisterBuiltinFunc< Eager< bool >( Value ) >(
            e, e.extIsBranchingAllowed(), []( const Value& b ) { return true; } );



    }

} // namespace goose::builtins

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

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

namespace goose::builtins
{
    void SetupGhostCodeBuilderInterface( Env& e )
    {
        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< GhostCode > > ) >( e,
            e.extPoisonBuilder(),
            []( const TypeWrapper< ptr< GhostCode > >& gcb ) { gcb->poison(); } );



        RegisterBuiltinFunc< Eager< bool >( TypeWrapper< ptr< GhostCode > > ) >( e,
            e.extInVerificationCode(),
            []( const TypeWrapper< ptr< GhostCode > >& gcb ) { return true; } );



        RegisterBuiltinFunc< Eager< bool >( TypeWrapper< ptr< GhostCode > > ) >( e,
            e.extIsBranchingAllowed(),
            []( const TypeWrapper< ptr< GhostCode > >& gcb ) { return gcb->branchingAllowed(); } );




        RegisterBuiltinFunc< Eager< TypeWrapper< ptr< cir::CFG > > >(
            TypeWrapper< ptr< GhostCode > > ) >( e, e.extGetCFG(),
            []( const TypeWrapper< ptr< GhostCode > >& gcb ) { return gcb->cfg(); } );



        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< GhostCode > > ) >( e,
            e.extBeginLifetimeScope(),
            []( const TypeWrapper< ptr< GhostCode > >& gcb ) { gcb->beginLifetimeScope(); } );



        RegisterBuiltinFunc< Intrinsic< void( TypeWrapper< ptr< GhostCode > > ) > >( e,
            e.extEndLifetimeScope(),
            []( auto&& c, const Value& b )
            {
                auto gcb = *FromValue< TypeWrapper< ptr< GhostCode > > >( b );
                gcb->endLifetimeScope( c );
            } );

        RegisterBuiltinFunc<
            Intrinsic< void( TypeWrapper< ptr< GhostCode > >, Value, uint32_t ) > >( e,
            e.extDeclareValue(),
            []( auto&& c, const Value& cbv, const Value& v, const Value& index )
            {
                auto gcb = *FromValue< TypeWrapper< ptr< GhostCode > > >( cbv );
                gcb->declareValue( c, v, *FromValue< uint32_t >( index ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< GhostCode > >, Value ) > >( e,
            e.extDestroyLiveValue(),
            []( auto&& c, const Value& cbv, const Value& val )
            {
                auto gcb = *FromValue< TypeWrapper< ptr< GhostCode > > >( cbv );
                return ToValue( gcb->destroyLiveValue( c, val ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< GhostCode > > ) > >( e,
            e.extDestroyAllLiveValues(),
            []( auto&& c, const Value& cbv )
            {
                auto gcb = *FromValue< TypeWrapper< ptr< GhostCode > > >( cbv );
                return ToValue( gcb->destroyAllLiveValues( c ) );
            } );
    }
} // namespace goose::builtins

#ifndef GOOSE_BUILTINS_BUILDERS_LIFECYCLE_MANAGER_H
#define GOOSE_BUILTINS_BUILDERS_LIFECYCLE_MANAGER_H

namespace goose::builtins
{
    template< class C > class LifeCycleManager

    {
      public:
        void beginLifetimeScope() { ++m_lifetimeScopeLevels; }

        void endLifetimeScope( Context& c );

        void beginBreakableScope() { ++m_breakableScopeLevels; }

        void endBreakableScope() { --m_breakableScopeLevels; }

        void beginContinuableScope() { ++m_continuableScopeLevels; }

        void endContinuableScope() { --m_continuableScopeLevels; }

        uint32_t lifetimeScopeLevels() const { return m_lifetimeScopeLevels; }

        uint32_t breakableScopeLevels() const { return m_breakableScopeLevels; }

        uint32_t continuableScopeLevels() const { return m_continuableScopeLevels; }


        template< typename T > void declareValue( const Context& c, T&& v, uint32_t index )
        {
            OnValueDeclared( c, v, index );

            m_liveValuesList.emplace_front( forward< T >( v ), index, m_lifetimeScopeLevels,


                m_breakableScopeLevels, m_continuableScopeLevels );


        }

        // Extend the life duration of a live value to the current lifetime scope.
        void extendValueLifetime( uint32_t index );

        // Destruction
        // Destroys an individual value by invoking _DestroyValue, appends any resulting cir
        // to the current basic block if necessary.
        bool destroyLiveValue( const Context& c, const Value& v, CURRENT_LOC );

        // Invoke the destroy extension point for every live variable, but leave them on the
        // stack. To be called before emitting a return terminator.
        bool destroyAllLiveValues( const Context& c );

        // Invoke the destroy extension point for every live variable that belong in the
        // specified break scope and every child scope, but leave them on the stack. To be
        // called before emitting a break terminator.
        bool destroyAllLiveValuesFromBreakScope( const Context& c, uint32_t breakScopeLevel );

        // Invoke the destroy extension point for every live variable that belong in the
        // specified continue scope and every child scope, but leave them on the stack. To be
        // called before emitting a continue terminator.
        bool destroyAllLiveValuesFromContinueScope( const Context& c, uint32_t continueScopeLevel );

      private:
        C& crtp() { return static_cast< C& >( *this ); }

        // Invoke the destroy extension point for every live variable from the current
        // lifetime scope, and pops off the stack. To be called when exiting a lifetime scope.
        // Returns false if something goes wrong, in which case the cfg will also be marked
        // as poisoned.
        // Note: it is called automatically by LifetimeScopeGuard.
        void destroyCurrentLifetimeScopeValues( const Context& c );

        // The number of nested lifetime scopes.
        uint32_t m_lifetimeScopeLevels = 0;

        // The number of nested breakable scopes.
        uint32_t m_breakableScopeLevels = 0;

        // The number of nested continuable scopes.
        uint32_t m_continuableScopeLevels = 0;

        // The live values stack, used to track when
        // to destroy values (such as local variables going out of scope)
        struct LiveValue
        {
            LiveValue() {}

            template< typename T >
            LiveValue( T&& v, uint32_t index, uint32_t lt, uint32_t b, uint32_t c ) :
                m_value( forward< T >( v ) ),
                m_index( index ),
                m_lifetimeScopeLevel( lt ),
                m_breakableScopeLevel( b ),
                m_continuableScopeLevel( c )

            {
            }

            Value m_value;
            uint32_t m_index = 0;

            // We keep track of those to determine which values to
            // destroy when exiting a scope, emitting a break terminator,
            // and emitting a continue terminator, respectively.
            uint32_t m_lifetimeScopeLevel = 0;
            uint32_t m_breakableScopeLevel = 0;
            uint32_t m_continuableScopeLevel = 0;
        };

        list< LiveValue > m_liveValuesList;
    };

} // namespace goose::builtins

#endif

#ifndef GOOSE_BUILTINS_BUILDERS_LIFECYCLE_MANAGER_INL
#define GOOSE_BUILTINS_BUILDERS_LIFECYCLE_MANAGER_INL

namespace goose::builtins
{

    template< class C > void LifeCycleManager< C >::endLifetimeScope( Context& c )
    {
        destroyCurrentLifetimeScopeValues( c );
        --m_lifetimeScopeLevels;
    }

    template< class C >
    void LifeCycleManager< C >::destroyCurrentLifetimeScopeValues( const Context& c )

                return;
            }

            it = m_liveValuesList.erase( it );
        }
    }


    template< class C > bool LifeCycleManager< C >::destroyAllLiveValues( const Context& c )
    {
        for( auto it = m_liveValuesList.begin(); it != m_liveValuesList.end(); ++it )
        {
            if( !destroyLiveValue( c, it->m_value ) )
            {
                m_liveValuesList.clear();
                crtp().poison();
                return false;
            }
        }

        return true;
    }

    template< class C >
    bool LifeCycleManager< C >::destroyAllLiveValuesFromBreakScope(
        const Context& c, uint32_t breakScopeLevel )
    {
        for( auto it = m_liveValuesList.begin(); it != m_liveValuesList.end(); ++it )
        {
            if( it->m_breakableScopeLevel < breakScopeLevel )
                return true;

            if( !destroyLiveValue( c, it->m_value ) )
            {
                m_liveValuesList.clear();
                crtp().poison();
                return false;
            }
        }

        return true;
    }

    template< class C >
    bool LifeCycleManager< C >::destroyAllLiveValuesFromContinueScope(
        const Context& c, uint32_t continueScopeLevel )
    {
        for( auto it = m_liveValuesList.begin(); it != m_liveValuesList.end(); ++it )
        {
            if( it->m_continuableScopeLevel < continueScopeLevel )
                return true;

            if( !destroyLiveValue( c, it->m_value ) )
            {
                m_liveValuesList.clear();
                crtp().poison();
                return false;
            }
        }

        return true;
    }

    template< class C >
    bool LifeCycleManager< C >::destroyLiveValue(
        const Context& c, const Value& v, source_location sloc )
    {
        if( v.isPoison() )
        {
            crtp().poison();
            return false;
        }

        DiagnosticsContext dc( v.locationId(), "When invoking _DestroyValue." );
        auto result = InvokeOverloadSet(
            c, c.env()->extDestroyValue(), MakeClosedTuple( v ), Location::Create( sloc ) );

        if( result.isPoison() )
        {
            crtp().poison();
            return false;
        }

        if( !result.isConstant() )
            crtp().append( move( result ) );

        return true;
    }


    template< class C > void LifeCycleManager< C >::extendValueLifetime( uint32_t index )
    {
        // Find the live value.
        auto it = find_if( m_liveValuesList.begin(), m_liveValuesList.end(),
            [&]( auto&& lv ) { return lv.m_index == index; } );




        if( it == m_liveValuesList.end() )
            return;

        --it->m_lifetimeScopeLevel;

        // Look for the last value that belongs to the parent lifetime scope, if any.
        auto last = find_if( it, m_liveValuesList.end(),


            [&]( auto&& lv ) { return lv.m_lifetimeScopeLevel < it->m_lifetimeScopeLevel; } );


        // Reinsert the value just after the last value of the parent scope (the one we
        // just found), like it would be if it was inserted in that lifetime scope in the first
        // place.
        auto lvToExtend = move( *it );
        m_liveValuesList.erase( it );

        m_liveValuesList.emplace( last, move( lvToExtend ) );
    }
} // namespace goose::builtins

#endif

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

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

namespace goose::builtins
{
    void SetupPropositionsBuilderInterface( Env& e )
    {
        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< Propositions > > ) >( e,
            e.extPoisonBuilder(),
            []( const TypeWrapper< ptr< Propositions > >& pb ) { pb->poison(); } );



        RegisterBuiltinFunc< Eager< bool >( TypeWrapper< ptr< Propositions > > ) >( e,
            e.extInVerificationCode(),
            []( const TypeWrapper< ptr< Propositions > >& pb ) { return true; } );



        RegisterBuiltinFunc< Eager< void >( TypeWrapper< ptr< Propositions > > ) >( e,
            e.extBeginLifetimeScope(),
            []( const TypeWrapper< ptr< Propositions > >& pb ) { pb->beginLifetimeScope(); } );



        RegisterBuiltinFunc< Intrinsic< void( TypeWrapper< ptr< Propositions > > ) > >( e,
            e.extEndLifetimeScope(),
            []( auto&& c, const Value& b )
            {
                auto pb = *FromValue< TypeWrapper< ptr< Propositions > > >( b );
                pb->endLifetimeScope( c );
            } );

        RegisterBuiltinFunc<
            Intrinsic< void( TypeWrapper< ptr< Propositions > >, Value, uint32_t ) > >( e,
            e.extDeclareValue(),
            []( auto&& c, const Value& cbv, const Value& v, const Value& index )
            {
                auto pb = *FromValue< TypeWrapper< ptr< Propositions > > >( cbv );
                pb->declareValue( c, v, *FromValue< uint32_t >( index ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< Propositions > >, Value ) > >( e,
            e.extDestroyLiveValue(),
            []( auto&& c, const Value& cbv, const Value& val )
            {
                auto pb = *FromValue< TypeWrapper< ptr< Propositions > > >( cbv );
                return ToValue( pb->destroyLiveValue( c, val ) );
            } );

        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< Propositions > > ) > >( e,
            e.extDestroyAllLiveValues(),
            []( auto&& c, const Value& cbv )
            {
                auto pb = *FromValue< TypeWrapper< ptr< Propositions > > >( cbv );
                return ToValue( pb->destroyAllLiveValues( c ) );
            } );
    }
} // namespace goose::builtins

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

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

namespace goose::builtins
{
    void SetupStructBuilderInterface( Env& e )
    {
        RegisterBuiltinFunc< Eager< TypeWrapper< ptr< cir::CFG > > >(
            TypeWrapper< ptr< StructBuilder > > ) >( e, e.extGetCFG(),

            []( const TypeWrapper< ptr< StructBuilder > >& sb ) { return sb->defaultCtorCFG(); } );


        // Default implementation for dropvalue inside a struct builder:
        // Append side effects of computed void values to the current CFG (needed by member
        // initialisers), otherwise error out. The things that we handle differently inside of
        // structs (such as decls) will have struct specific implementations of dropValue().
        RegisterBuiltinFunc< Intrinsic< void( TypeWrapper< ptr< StructBuilder > >, Value ) > >( e,
            e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                if( v.isConstant() || v.type() != GetValueType< void >()
                    || !DoesInstrSeqHaveSideEffects( *v.cir() ) )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                        v.locationId(), "this is not allowed here.", 0 );
                    PoisonBuilder( c );
                    return;
                }

                auto cfg = GetCFG( c );
                if( !cfg )
                    return;

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

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

        // DropValue for Decl inside a struct: declare a member value.
        RegisterBuiltinFunc<
            Intrinsic< void( TypeWrapper< ptr< StructBuilder > >, AnyDeclType ) > >( e,
            e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                auto sb = *FromValue< TypeWrapper< ptr< StructBuilder > > >( b );
                auto decl = *FromValue< Decl >( v );

                sb->declareMemberVar( c, decl.name(), move( decl.type() ), v.locationId() );
            } );

        // DropValue for DeclWithInit inside a struct: declare a member value with initialization.
        // TODO: TNamedDecls
        RegisterBuiltinFunc<
            Intrinsic< void( TypeWrapper< ptr< StructBuilder > >, AnyDeclWithInitType ) > >( e,
            e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                auto sb = *FromValue< TypeWrapper< ptr< StructBuilder > > >( b );
                auto decl = *FromValue< DeclWithInit >( v );

                sb->declareMemberVar(
                    c, decl.name(), move( decl.type() ), v.locationId(), move( decl.init() ) );
            } );

        // Finalize for structs: call the builder's finalize method, which will use all the
        // collected members to actually create the struct
        RegisterBuiltinFunc< Intrinsic< bool( TypeWrapper< ptr< StructBuilder > >,
            TypePatternParam< StructType, StructType::Pattern > ) > >( e, e.extFinalize(),
            []( const Context& c, const Value& b, const Value& st )
            {
                auto sb = *FromValue< TypeWrapper< ptr< StructBuilder > > >( b );
                return ToValue( sb->finalize( c, st ) );
            } );
    }
} // namespace goose::builtins

        e.extEndContinuableScope() = CreateOverloadSet( e, "_EndContinuableScope"_sid );

        e.extDeclareValue() = CreateOverloadSet( e, "_DeclareValue"_sid );
        e.extOnValueDeclared() = CreateOverloadSet( e, "_OnValueDeclared"_sid );

        e.extDestroyLiveValue() = CreateOverloadSet( e, "_DestroyLiveValue"_sid );
        e.extDestroyAllLiveValues() = CreateOverloadSet( e, "_DestroyAllLiveValues"_sid );
        e.extDestroyAllLiveValuesFromBreakScope() =
            CreateOverloadSet( e, "_DestroyAllLiveValuesFromBreakScope"_sid );
        e.extDestroyAllLiveValuesFromContinueScope() =
            CreateOverloadSet( e, "_DestroyAllLiveValuesFromContinueScope"_sid );

        e.extInVerificationCode() = CreateOverloadSet( e, "_InVerificationCode"_sid );
        e.extIsBranchingAllowed() = CreateOverloadSet( e, "_IsBranchingAllowed"_sid );

        e.extCTForEach() = CreateOverloadSet( e, "_CTForEach"_sid );

        SetupBuiltinTypes( e );

    }

    const Term& RootG0Identity()
    {
        static auto identity = VEC( TSID( g0 ) );
        return identity;
    }
} // namespace goose::builtins

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

    extern const Term& RootG0Identity();
} // namespace goose::builtins

#include "codegen/codegen.h"

#include "helpers.h"
#include "builders/builders.h"
#include "types/types.h"
#include "operators/operators.h"
#include "statements/statements.h"
#include "exprhelpers.h"

#include "builders/lifecycle_manager.inl"

namespace goose::builtins
{
    extern void SetupDefaultBuilderInterface( Env& e );
    extern void SetupCodeBuilderInterface( Env& e );
    extern void SetupPropositionsBuilderInterface( Env& e );
    extern void SetupGhostCodeBuilderInterface( Env& e );
    extern void SetupStructBuilderInterface( Env& e );
    extern void SetupBuiltins( Env& e );
} // namespace goose::builtins

#endif

#ifndef GOOSE_BUILTINS_EXPRHELPERS_H
#define GOOSE_BUILTINS_EXPRHELPERS_H

#include "parse/parse.h"

namespace goose::builtins::exprhelpers
{
    template< typename V > Value Not( V&& val )

    {
        auto locId = val.locationId();
        return BuildComputedValue( GetValueType< bool >(), forward< V >( val ), cir::Not( locId ) )
            .setLocationId( locId );
    }

    template< typename L, typename R > Value Or( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value And( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value Eq( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value Neq( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value UGT( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value UGE( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value ULT( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value ULE( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value SGT( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value SGE( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value SLT( L&& lhs, R&& rhs )

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

    template< typename L, typename R > Value SLE( L&& lhs, R&& rhs )

    {
        auto locId = max( lhs.locationId(), rhs.locationId() );
        return BuildComputedValue(
            GetValueType< bool >(), forward< L >( lhs ), forward< R >( rhs ), cir::SLE( locId ) )
            .setLocationId( locId );
    }
} // namespace goose::builtins::exprhelpers

#endif

#include "builtins/builtins.h"

using namespace goose::parse;

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

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

        else if( !np.parseExpression( precedence ) )
            return nullptr;

        np.flushValue();
        return bb;
    }

    variant< Value, ValUnifyError > ConvertValueToType(
        const Context& c, const Value& val, const Term& type )
    {
        auto valTerm = ValueToEIR( val );
        auto paramPat = ParamPat( type );

        auto us = FindBestTyping( paramPat, valTerm, c );

        if( holds_alternative< NoUnification >( us ) )
            return ValUnifyError::NoSolution;

        if( holds_alternative< AmbiguousTypeCheck >( us ) )
            return ValUnifyError::Ambiguous;

        auto&& [s, _] = get< TCSol >( us );
        return *EIRToValue( s );
    }

    void PoisonBuilder( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _PoisonBuilder." );
        InvokeOverloadSet( c, c.env()->extPoisonBuilder(), MakeClosedTuple( c.builder() ), loc );

    }

    bool BuilderAllowsOverloading( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _BuilderAllowsOverloading." );
        auto result = InvokeOverloadSet(
            c, c.env()->extBuilderAllowsOverloading(), MakeClosedTuple( c.builder() ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }

    ptr< cir::CFG > GetCFG( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _GetCFG." );
        auto result =
            InvokeOverloadSet( c, c.env()->extGetCFG(), MakeClosedTuple( c.builder() ), loc );

        if( result.isPoison() )
            return {};

        auto cfg = FromValue< TypeWrapper< ptr< cir::CFG > > >( result );
        if( !cfg )
            return {};

        return *cfg;
    }

    uint32_t GetBreakableScopeLevels( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _GetBreakableScopeLevels." );
        auto result = InvokeOverloadSet(
            c, c.env()->extGetBreakableScopeLevels(), MakeClosedTuple( c.builder() ), loc );

        if( result.isPoison() )
            return 0;

        auto levels = FromValue< uint32_t >( result );
        if( !levels )
            return 0;

        return *levels;
    }

    uint32_t GetContinuableScopeLevels( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _GetContinuableScopeLevels." );
        auto result = InvokeOverloadSet(
            c, c.env()->extGetContinuableScopeLevels(), MakeClosedTuple( c.builder() ), loc );

        if( result.isPoison() )
            return 0;

        auto levels = FromValue< uint32_t >( result );
        if( !levels )
            return 0;

        return *levels;
    }

    void BeginVisibilityScope( Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _BeginVisibilityScope." );
        InvokeOverloadSet(
            c, c.env()->extBeginVisibilityScope(), MakeClosedTuple( c.builder() ), loc );
    }

    void BeginLifetimeScope( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _BeginLifetimeScope." );
        InvokeOverloadSet(
            c, c.env()->extBeginLifetimeScope(), MakeClosedTuple( c.builder() ), loc );
    }

    void EndLifetimeScope( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _EndLifetimeScope." );
        InvokeOverloadSet( c, c.env()->extEndLifetimeScope(), MakeClosedTuple( c.builder() ), loc );

    }

    void BeginBreakableScope( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _BeginBreakableScope." );
        InvokeOverloadSet(
            c, c.env()->extBeginBreakableScope(), MakeClosedTuple( c.builder() ), loc );
    }

    void EndBreakableScope( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _EndBreakableScope." );
        InvokeOverloadSet(
            c, c.env()->extEndBreakableScope(), MakeClosedTuple( c.builder() ), loc );
    }

    void BeginContinuableScope( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _BeginContinuableScope." );
        InvokeOverloadSet(
            c, c.env()->extBeginContinuableScope(), MakeClosedTuple( c.builder() ), loc );
    }

    void EndContinuableScope( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _EndContinuableScope." );
        InvokeOverloadSet(
            c, c.env()->extEndContinuableScope(), MakeClosedTuple( c.builder() ), loc );
    }

    void DeclareValue( const Context& c, const Value& val, uint32_t index, source_location sloc )
    {
        DiagnosticsContext dc( val.locationId(), "When invoking _DeclareValue." );
        InvokeOverloadSet( c, c.env()->extDeclareValue(),
            MakeClosedTuple( c.builder(), val, ToValue( index ) ), Location::Create( sloc ) );
    }

    void OnValueDeclared( const Context& c, const Value& val, uint32_t index, source_location sloc )
    {
        DiagnosticsContext dc( val.locationId(), "When invoking _OnValueDeclared." );
        InvokeOverloadSet( c, c.env()->extOnValueDeclared(),
            MakeClosedTuple( c.builder(), val, ToValue( index ) ), Location::Create( sloc ) );
    }

    bool DestroyLiveValue( const Context& c, const Value& val, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _DestroyLiveValue." );
        auto result = InvokeOverloadSet(
            c, c.env()->extDestroyLiveValue(), MakeClosedTuple( c.builder(), val ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }

    bool DestroyAllLiveValues( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _DestroyAllLiveValues." );
        auto result = InvokeOverloadSet(
            c, c.env()->extDestroyAllLiveValues(), MakeClosedTuple( c.builder() ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }

    bool DestroyAllLiveValuesFromBreakScope(
        const Context& c, uint32_t breakScopeLevel, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _DestroyAllLiveValuesFromBreakScope." );
        auto result = InvokeOverloadSet( c, c.env()->extDestroyAllLiveValuesFromBreakScope(),
            MakeClosedTuple( c.builder(), ToValue( breakScopeLevel ) ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }

    bool DestroyAllLiveValuesFromContinueScope(
        const Context& c, uint32_t continueScopeLevel, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _DestroyAllLiveValuesFromContinueScope." );
        auto result = InvokeOverloadSet( c, c.env()->extDestroyAllLiveValuesFromContinueScope(),
            MakeClosedTuple( c.builder(), ToValue( continueScopeLevel ) ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }

    bool InVerificationCode( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _InVerificationCode." );
        auto result = InvokeOverloadSet(
            c, c.env()->extInVerificationCode(), MakeClosedTuple( c.builder() ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }

    bool IsBranchingAllowed( const Context& c, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _IsBranchingAllowed." );
        auto result = InvokeOverloadSet(
            c, c.env()->extIsBranchingAllowed(), MakeClosedTuple( c.builder() ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }

    void CTForEach( const Context& c, const Value& decl, const Value& container,
        const ptr< vector< TermLoc > >& body, source_location sloc )
    {
        DiagnosticsContext dc( decl.locationId(), "When invoking _CTForEach." );
        InvokeOverloadSet( c, c.env()->extCTForEach(),
            MakeClosedTuple( decl, container, Wrap( body ) ), Location::Create( sloc ) );
    }

    bool IsTrivialInitialization(
        const Context& c, const Value& lhsType, const Value& rhsType, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _IsTrivialInitialization." );
        auto result = InvokeOverloadSet(
            c, c.env()->extIsTrivialInitialization(), MakeClosedTuple( lhsType, rhsType ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }







    bool IsTrivialAssignment(
        const Context& c, const Value& lhsType, const Value& rhsType, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        DiagnosticsContext dc( loc, "When invoking _IsTrivialAssignment." );
        auto result = InvokeOverloadSet(
            c, c.env()->extIsTrivialAssignment(), MakeClosedTuple( lhsType, rhsType ), loc );

        if( result.isPoison() )
            return false;

        auto success = FromValue< bool >( result );
        if( !success )
            return false;

        return *success;
    }
} // namespace goose::builtins

namespace goose::builtins
{
    class Propositions;

    extern const Term& EmptyPredicates();


    template< typename T > void DefineConstant( sema::Env& env, StringId name, T&& val )
    {
        env.storeValue( AppendToVectorTerm( RootG0Identity(), TERM( name ) ), ANYTERM( _ ),
            forward< T >( val ) );
    }

    extern void RegisterRule( sema::Env& env, 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
    };

    // Typecheck the provided value with a value placeholder of the specified type,
    // and return the result or an error code.
    variant< Value, ValUnifyError > ConvertValueToType(
        const Context& c, const Value& val, const Term& type );

    // Helpers to create a standard type construction, as a vector starting with an identity,
    // followed by an optional pointer to predicates and an optional pointer to a llvm type.
    template< typename I, typename... T > auto MkStdType( I&& identity, T&&... extra )

    {
        return VEC( forward< I >( identity ), EmptyPredicates(), TERM( (void*)nullptr ),
            forward< T >( extra )... );
    }

    template< typename I > auto MkStdType( I&& identity )

    {
        return VEC( forward< I >( identity ), EmptyPredicates(), TERM( (void*)nullptr ) );
    }

    // Same as above, but directly specify the llvm type pointer.
    template< typename I, typename... T >
    auto MkStdRTType( I&& identity, const void* cgType, T&&... extra )
    {
        return VEC( forward< I >( identity ), EmptyPredicates(), const_cast< void* >( cgType ),
            forward< T >( extra )... );
    }


    template< typename I > auto MkStdRTType( I&& identity, const void* cgType )
    {
        return VEC( forward< I >( identity ), EmptyPredicates(), const_cast< void* >( cgType ) );
    }

    extern void PoisonBuilder( const Context& c, CURRENT_LOC );

    extern bool BuilderAllowsOverloading( const Context& c, CURRENT_LOC );

    extern void EndContinuableScope( const Context& c, CURRENT_LOC );

    extern void DeclareValue( const Context& c, const Value& val, uint32_t index, CURRENT_LOC );
    extern void OnValueDeclared( const Context& c, const Value& val, uint32_t index, CURRENT_LOC );

    extern bool DestroyLiveValue( const Context& c, const Value& val, CURRENT_LOC );
    extern bool DestroyAllLiveValues( const Context& c, CURRENT_LOC );
    extern bool DestroyAllLiveValuesFromBreakScope(
        const Context& c, uint32_t breakScopeLevel, CURRENT_LOC );
    extern bool DestroyAllLiveValuesFromContinueScope(
        const Context& c, uint32_t continueScopeLevel, CURRENT_LOC );

    extern bool InVerificationCode( const Context& c, CURRENT_LOC );

    extern bool IsBranchingAllowed( const Context& c, CURRENT_LOC );

    extern void CTForEach( const Context& c, const Value& decl, const Value& container,
        const ptr< vector< TermLoc > >& body, CURRENT_LOC );

    extern bool IsTrivialInitialization(
        const Context& c, const Value& lhsType, const Value& rhsType, CURRENT_LOC );
    extern bool IsTrivialAssignment(
        const Context& c, const Value& lhsType, const Value& rhsType, CURRENT_LOC );

    struct TypeTypePattern
    {
        static const Term& GetPattern()
        {
            static auto pat = TypeType();
            return pat;
        }
    };

    struct CTTypePattern
    {
        static const Term& GetPattern()
        {
            static auto pat = ValueToEIR(
                Value( TypeType(), VEC( TSID( ct_type ), REPEAT( HOLE( "_"_sid ) ) ) ) );
            return pat;
        }
    };

    struct RTTypePattern
    {
        static const Term& GetPattern()
        {
            static auto pat = ValueToEIR(
                Value( TypeType(), VEC( TSID( rt_type ), REPEAT( HOLE( "_"_sid ) ) ) ) );
            return pat;
        }
    };
} // namespace goose::builtins

#endif

namespace goose::builtins
{
    void SetupApostropheOp( Env& e )
    {
        Rule r;

        MakeLeftAssInfixOp( e, r, "'"_sid, precedence::ApostropheOp,
            []( auto&& p, auto&& lhs, auto&& rhs )
            {
                bool isTVarAS = lhs.type() != GetValueType< AccessSpecifier >();
                bool isTVarLT = rhs.type() != GetValueType< Lifetime >();

                if( isTVarAS && !IsTVar( lhs ) )
                {
                    DiagnosticsManager::GetInstance().emitErrorMessage( lhs.locationId(),
                        "expected an access specifier or a template variable before the ' "
                        "operator." );
                    return PoisonValue();
                }

                if( isTVarLT && !IsTVar( rhs ) )
                {
                    DiagnosticsManager::GetInstance().emitErrorMessage( rhs.locationId(),
                        "expected an lifetime or a template variable after the ' operator." );
                    return PoisonValue();
                }

                // If the lifetime is a TVar, wrap it into a TDecl constrained to the lifetime type.
                if( isTVarLT )
                {
                    auto tv = *FromValue< TVar >( rhs );
                    rhs = ToValue( TDecl( GetValueType< Lifetime >(), tv.name() ) )
                              .setLocationId( rhs.locationId() );
                }

                // Likewise for the access specifier.
                if( isTVarAS )
                {
                    auto tv = *FromValue< TVar >( lhs );
                    lhs = ToValue( TDecl( GetValueType< AccessSpecifier >(), tv.name() ) )
                              .setLocationId( lhs.locationId() );

                    return ToValue( AccessSpecifier{ ValueToEIR( lhs ), ValueToEIR( rhs ) } );
                }

                auto as = *FromValue< AccessSpecifier >( lhs );

                if( as.lifetime() != Lifetime::Unspecified() )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( lhs.locationId(),
                        "a lifetime has already been attached to this access specifier." );
                    return PoisonValue();
                }

                as.lifetime() = ValueToEIR( rhs );
                return ToValue( as );
            } );
    }
} // namespace goose::builtins

using namespace goose::parse;

namespace goose::builtins
{
    void SetupArithOps( Env& e )
    {
        BuildParseRule( e, "+"_sid,
            PrefixOp( "operator_unary_plus"_sid, precedence::UnaryOps, BuildGenericTupleOperator(),

                ForType< BigInt >( []< typename O >( auto&& c, O&& operand ) -> Value

                    { return forward< O >( operand ); } ),

                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value

                    { return forward< O >( operand ); } ) ),


            LeftAssInfixOp( "operator_add"_sid, precedence::AddSubOp, BuildGenericTupleOperator(),

                ForType< BigInt, Add >(),
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue( lhs.type(), lhs, rhs, Add( c.locationId() ) );

                    } ) ) );



        BuildParseRule( e, "-"_sid,
            PrefixOp( "operator_unary_minus"_sid, precedence::UnaryOps, BuildGenericTupleOperator(),

                ForType< BigInt >(
                    []( auto&& c, auto&& operand ) -> Value
                    {
                        return BuildComputedValue( GetValueType< BigInt >(), ToValue( BigInt() ),
                            operand, Sub( c.locationId() ) );
                    } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                    []( auto&& c, auto&& operand ) -> Value
                    {
                        auto opTypeVal = *EIRToValue( operand.type() );
                        auto opType = *FromValue< IntegerType >( opTypeVal );
                        return BuildComputedValue( operand.type(),
                            Value( operand.type(), APSInt( opType.m_numBits, false ) ), operand,
                            Sub( c.locationId() ) );
                    } ) ),

            LeftAssInfixOp( "operator_sub"_sid, precedence::AddSubOp, BuildGenericTupleOperator(),

                ForType< BigInt, Sub >(),
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue( lhs.type(), lhs, rhs, Sub( c.locationId() ) );

                    } ) ) );



        BuildParseRule( e, "*"_sid,
            LeftAssInfixOp( "operator_multiply"_sid, precedence::MulDivOp,
                BuildGenericTupleOperator(), ForType< BigInt, Mul >(),

                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue( lhs.type(), lhs, rhs, Mul( c.locationId() ) );

                    } ) ) );



        BuildParseRule( e, "/"_sid,
            LeftAssInfixOp( "operator_divide"_sid, precedence::MulDivOp,
                BuildGenericTupleOperator(), ForType< BigInt, SDiv >(),

                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        using namespace goose::builtins::exprhelpers;

                        auto cfg = GetCFG( c );
                        assert( cfg );

                        // Build a zero constant of the same type as the denominator
                        // to construct the assertion expression.
                        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()->append( move( cond ), cir::Assert( rhs.locationId() ) );


                        return BuildComputedValue( lhs.type(), lhs, rhs, SDiv( c.locationId() ) );

                    } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        using namespace goose::builtins::exprhelpers;

                        auto cfg = GetCFG( c );
                        assert( cfg );

                        // Build a zero constant of the same type as the denominator
                        // to construct the assertion expression.
                        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()->append( move( cond ), cir::Assert( rhs.locationId() ) );


                        return BuildComputedValue( lhs.type(), lhs, rhs, UDiv( c.locationId() ) );

                    } ) ) );



        BuildParseRule( e, "%"_sid,
            LeftAssInfixOp( "operator_modulo"_sid, precedence::MulDivOp,
                BuildGenericTupleOperator(), ForType< BigInt, SRem >(),

                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        using namespace goose::builtins::exprhelpers;

                        auto cfg = GetCFG( c );
                        assert( cfg );

                        // Build a zero constant of the same type as the denominator
                        // to construct the assertion expression.
                        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()->append( move( cond ), cir::Assert( rhs.locationId() ) );


                        return BuildComputedValue( lhs.type(), lhs, rhs, SRem( c.locationId() ) );

                    } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        using namespace goose::builtins::exprhelpers;

                        auto cfg = GetCFG( c );
                        assert( cfg );

                        // Build a zero constant of the same type as the denominator
                        // to construct the assertion expression.
                        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()->append( move( cond ), cir::Assert( rhs.locationId() ) );


                        return BuildComputedValue( lhs.type(), lhs, rhs, URem( c.locationId() ) );

                    } ) ) );


    }

} // namespace goose::builtins

#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
{
    extern Value NonRefTupleAssignment(
        const ptr< OverloadSet >& assOp, Context& c, const Value& lhs, const Value& rhs );
    extern Value MutRefTupleAssignment(
        const ptr< OverloadSet >& assOp, Context& c, const Value& lhs, const Value& rhs );

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

        // Generic function to perform the assignation of a builtin type
        // to a mutable reference of that same type.
        auto BuiltinTypeAssignment = []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
        {
            G_VAL_ASSERT( lhs, !lhs.isConstant() );

            auto refType = *FromValue< ReferenceType >( *EIRToValue( lhs.type() ) );

            if( !ParseTypePredicates( c, *EIRToValue( refType.type() ) ) )
                return PoisonValue();

            auto cfg = GetCFG( c );
            if( !cfg )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    0, "assignments are not allowed here." );
                return PoisonValue();
            }
            else if( auto bb = cfg->currentBB() )
                bb->append( rhs, lhs, Store( refType.type(), rhs.locationId(), lhs.locationId() ) );

            // Return the ref to support chained assignments, like in c++.
            return Value( lhs );
        };

        // Generic function to assign a value to a decl: create a DeclWithInit
        auto DeclAssignment = []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
        {
            auto decl = *FromValue< Decl >( lhs );
            return ToValue( DeclWithInit( decl.type(), decl.name(), rhs, lhs.locationId() ) );
        };

        // Generic function to assign a value to a template named decl (local variable declaration
        // with local type inference)
        auto TNamedDeclAssignment = []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
        {
            auto tndecl = *FromValue< TNamedDecl >( lhs );
            return ToValue(
                TNamedDeclWithInit( tndecl.type(), tndecl.name(), rhs, lhs.locationId() ) );
        };

        BuildParseRule( e, "="_sid,
            RightAssInfixOp( "operator_assign"_sid, precedence::AssignmentOp,
                // Assignment with a decl of type $T to the left and a value of type $T to the
                // right: Local variable declaration and initialization.
                ForTypes< CustomPattern< Decl, Decl::Pattern >,
                    CustomPattern< Value, ForwarderPattern > >( DeclAssignment ),

                // Assignment with a tnameddecl to the left and a value to the right:
                // Local variable declaration and initialization with type inference.
                ForTypes< CustomPattern< TNamedDecl, TNamedDecl::Pattern >,
                    CustomPattern< Value, ForwarderPattern > >( TNamedDeclAssignment ),

                // Compilation time tuple from compilation time tuple
                ForTypes< CustomConstantPattern< Value, TuplePattern >,
                    CustomConstantPattern< Value, TuplePattern > >(
                    [assOp]( auto&& c, auto&& lhs, auto&& rhs )
                    { return NonRefTupleAssignment( assOp, c, lhs, rhs ); } ),

                // Compilation time tuple from tuple reference
                ForTypes< CustomConstantPattern< Value, TuplePattern >,
                    CustomPattern< Value, ReferenceType::PatternAnyOf< TuplePattern > > >(
                    [assOp]( auto&& c, auto&& lhs, auto&& rhs )
                    { return NonRefTupleAssignment( assOp, c, lhs, rhs ); } ),

                // Mutable tuple ref from compilation time tuple
                ForTypes< CustomPattern< Value, ReferenceType::PatternMutableOf< TuplePattern > >,
                    CustomConstantPattern< Value, TuplePattern > >(
                    [assOp]( auto&& c, auto&& lhs, auto&& rhs )
                    { return MutRefTupleAssignment( assOp, c, lhs, rhs ); } ),

                // Mutable tuple ref from tuple reference
                ForTypes< CustomPattern< Value, ReferenceType::PatternMutableOf< TuplePattern > >,
                    CustomPattern< Value, ReferenceType::PatternAnyOf< TuplePattern > > >(
                    [assOp]( auto&& c, auto&& lhs, auto&& rhs )
                    { return MutRefTupleAssignment( assOp, c, lhs, rhs ); } ),

                // Mutable ref assignment for compile time builtin types
                ForTypes< CustomPattern< Value, ReferenceType::PatternMutableOf< CTTypePattern > >,
                    CustomPattern< Value, ValuePatternT > >( BuiltinTypeAssignment ),

                // Mutable ref assignment for run time builtin types
                ForTypes< CustomPattern< Value, ReferenceType::PatternMutableOf< RTTypePattern > >,
                    CustomPattern< Value, ValuePatternT > >( BuiltinTypeAssignment ),

                // Explicit overload for assigning an rt_int to an rt_int reference:
                // We need this to be able to assign a ct_int to a rt_int: the generic version
                // above can't perform the necessary implicit conversion.
                ForTypes<
                    CustomPattern< Value, ReferenceType::PatternMutableOf< IntegerType::Pattern > >,
                    CustomPattern< Value, IntegerType::Pattern > >( BuiltinTypeAssignment ) ) );



    }

} // namespace goose::builtins

#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 RefOfAnyType = CustomPattern< Value, ReferenceType::PatternAny >;

        BuildParseRule( e, ","_sid,
            LeftAssInfixOp( "operator_comma"_sid, precedence::CommaOp,

                // Overload: open tuple, open tuple
                ForTypes< CustomPattern< Value, TupleOpenPattern >,
                    CustomConstantPattern< Value, TupleOpenPattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return ConcatenateTuples( lhs, rhs ); } ),


                // Overload: open tuple, anything
                ForTypes< CustomConstantPattern< Value, TupleOpenPattern >, Value >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return AppendToTuple( lhs, rhs ); } ),


                // Overload: anything, open tuple
                ForTypes< Value, CustomConstantPattern< Value, TupleOpenPattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return PrependToTuple( lhs, rhs ); } ),


                // Overloads for computed tuples
                ForTypes< CustomPattern< Value, TupleOpenPattern >,
                    CustomPattern< Value, TupleOpenPattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        G_ERROR( "concatenation of computed tuples is not yet implemented." );
                        return PoisonValue();
                    } ),

                // Overload: open tuple, anything
                ForTypes< CustomPattern< Value, TupleOpenPattern >, Value >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        G_ERROR( "appending to a computed tuple is not yet implemented." );
                        return PoisonValue();
                    } ),

                // Overload: anything, open tuple
                ForTypes< Value, CustomPattern< Value, TupleOpenPattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        G_ERROR( "prepending to a computed tuple is not yet implemented." );
                        return PoisonValue();
                    } ),

                // Overload: anything, anything

                ForType< Value >( []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return AppendToTuple( AppendToTuple( EmptyOpenTuple(), lhs ), rhs ); } ),


                // We want to be able to put references in tuples without them getting
                // automatically dereferenced, so we have specific overloads that treat
                // them explicitely.

                ForType< RefOfAnyType >( []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return AppendToTuple( AppendToTuple( EmptyOpenTuple(), lhs ), rhs ); } ),


                ForTypes< Value, RefOfAnyType >( []( auto&& c, auto&& lhs, auto&& rhs ) -> Value


                    { return AppendToTuple( AppendToTuple( EmptyOpenTuple(), lhs ), rhs ); } ),


                ForTypes< RefOfAnyType, Value >( []( auto&& c, auto&& lhs, auto&& rhs ) -> Value


                    { return AppendToTuple( AppendToTuple( EmptyOpenTuple(), lhs ), rhs ); } ),


                ForTypes< CustomConstantPattern< Value, TupleOpenPattern >, RefOfAnyType >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return AppendToTuple( lhs, rhs ); } ),


                ForTypes< RefOfAnyType, CustomConstantPattern< Value, TupleOpenPattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return PrependToTuple( lhs, rhs ); } ) ) );



    }

} // namespace goose::builtins

#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 )
    {
        BuildParseRule( e, "=="_sid,
            LeftAssInfixOp( "operator_equals"_sid, precedence::EqualityOp,
                ForType< bool, Eq, bool >(), ForType< BigInt, Eq, bool >(),

                ForType< char32_t, Eq, bool >(), ForType< string, Eq, bool >(),

                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, Eq( c.locationId() ) );
                    } ),
                ForType< CustomPattern< Value, TypeTypePattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return ToValue( lhs == rhs ); } ) ) );




        BuildParseRule( e, "!="_sid,
            LeftAssInfixOp( "operator_not_equals"_sid, precedence::EqualityOp,
                ForType< bool, Neq, bool >(), ForType< BigInt, Neq, bool >(),

                ForType< char32_t, Neq, bool >(), ForType< string, Neq, bool >(),

                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, Neq( c.locationId() ) );
                    } ),
                ForType< CustomPattern< Value, TypeTypePattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return ToValue( lhs != rhs ); } ) ) );




        BuildParseRule( e, ">"_sid,
            LeftAssInfixOp( "operator_greater"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SGT, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, SGT( c.locationId() ) );
                    } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, UGT( c.locationId() ) );
                    } ) ) );



        BuildParseRule( e, ">="_sid,
            LeftAssInfixOp( "operator_greater_or_equals"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SGE, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, SGE( c.locationId() ) );
                    } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, UGE( c.locationId() ) );
                    } ) ) );



        BuildParseRule( e, "<"_sid,
            LeftAssInfixOp( "operator_lesser"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SLT, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, SLT( c.locationId() ) );
                    } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, ULT( c.locationId() ) );
                    } ) ) );



        BuildParseRule( e, "<="_sid,
            LeftAssInfixOp( "operator_lesser_or_equals"_sid, precedence::GreaterLesserOp,
                ForType< BigInt, SLE, bool >(),
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, SLE( c.locationId() ) );
                    } ),
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), lhs, rhs, ULE( c.locationId() ) );
                    } ) ) );


    }

} // namespace goose::builtins

#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 )

    {
        auto assOp = GetOverloadSet( e, "operator_assign"_sid );
        auto opOvlSet = GetOverloadSet( e, opName );

        return ForTypes< L, R >(
            [=]( auto&& c, auto&& lhs, auto&& rhs ) -> Value
            {
                // Resolve the wanted operator call.
                auto newVal = PoisonValue();

                {
                    DiagnosticsContext dc( 0, format( "When invoking {}.", opName.str() ) );

                    newVal = InvokeOverloadSet( c, opOvlSet, MakeClosedTuple( lhs, rhs ) );

                }

                if( newVal.isPoison() )
                    return newVal;

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

                // Resolve the assignment operator call.
                return InvokeOverloadSet( c, assOp, MakeClosedTuple( lhs, newVal ) );

            } );

    }

    void SetupCompoundAssOps( Env& e )
    {
        auto CompoundAssOp = [&]( StringId opName )
        {
            auto opOvlSet = GetOverloadSet( e, opName );
            return MakeCompoundAssOpFunc< CustomPattern< Value, ReferenceType::PatternAnyMutable >,
                Value >( e, opName );
        };

        // The reason we don't use BuildGenericTupleOperator() for the tuple version is to that we
        // go through the tuple assignment operator, which will take care of building the result in
        // temporaries before performong the assignment, avoiding tuple values clobbering each other
        // before we are done with the original values.

        auto TupleCompoundAssOp = [&]( StringId opName )
        {
            auto opOvlSet = GetOverloadSet( e, opName );
            return MakeCompoundAssOpFunc< CustomPattern< Value, TuplePattern >,
                CustomPattern< Value, TuplePattern > >( e, opName );
        };

        BuildParseRule( e, "+="_sid,
            RightAssInfixOp( "operator_compound_add"_sid, precedence::AssignmentOp,
                TupleCompoundAssOp( "operator_add"_sid ), CompoundAssOp( "operator_add"_sid ) ) );


        BuildParseRule( e, "-="_sid,
            RightAssInfixOp( "operator_compound_sub"_sid, precedence::AssignmentOp,
                TupleCompoundAssOp( "operator_sub"_sid ), CompoundAssOp( "operator_sub"_sid ) ) );


        BuildParseRule( e, "*="_sid,
            RightAssInfixOp( "operator_compound_multiply"_sid, precedence::AssignmentOp,
                TupleCompoundAssOp( "operator_multiply"_sid ),
                CompoundAssOp( "operator_multiply"_sid ) ) );

        BuildParseRule( e, "/="_sid,

        BuildParseRule( e, ">>="_sid,
            RightAssInfixOp( "operator_compound_shift_right"_sid, precedence::AssignmentOp,
                TupleCompoundAssOp( "operator_shift_right"_sid ),
                CompoundAssOp( "operator_shift_right"_sid ) ) );

        BuildParseRule( e, "&="_sid,
            RightAssInfixOp( "operator_compound_and"_sid, precedence::AssignmentOp,
                TupleCompoundAssOp( "operator_and"_sid ), CompoundAssOp( "operator_and"_sid ) ) );


        BuildParseRule( e, "|="_sid,
            RightAssInfixOp( "operator_compound_or"_sid, precedence::AssignmentOp,
                TupleCompoundAssOp( "operator_or"_sid ), CompoundAssOp( "operator_or"_sid ) ) );


        BuildParseRule( e, "^="_sid,
            RightAssInfixOp( "operator_compound_xor"_sid, precedence::AssignmentOp,
                TupleCompoundAssOp( "operator_xor"_sid ), CompoundAssOp( "operator_xor"_sid ) ) );

    }

} // namespace goose::builtins

namespace goose::builtins
{
    void SetupComptimeOp( Env& e )
    {
        // TODO error out if function is not regular or already set as comptime
        BuildParseRule( e, "comptime"_sid,
            PrefixOp( "operator_comptime"_sid, precedence::FuncQualifier,
                ForType< TypePatternParam< FuncType, FuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto ft = *FromValue< FuncType >( operand );
                        ft.setKind( FuncType::Kind::Comptime );
                        return ToValue( ft );
                    } ),
                ForType< TypePatternParam< TFuncType, TFuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tft = *FromValue< TFuncType >( operand );
                        tft.setKind( FuncType::Kind::Comptime );
                        return ToValue( tft );
                    } ),
                ForType< FuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto fd = *FromValue< FuncDecl >( operand );
                        fd.func().type().setKind( FuncType::Kind::Comptime );
                        return ToValue( fd );
                    } ),
                ForType< TFuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tfd = *FromValue< TFuncDecl >( operand );
                        tfd.tFunc().type().setKind( FuncType::Kind::Comptime );
                        return ToValue( tfd );
                    } ) ) );


    }

} // namespace goose::builtins

        auto type = p.peekLastValue();
        if( !type )
            return false;

        auto delim = p.resolver()->lookAheadUnresolved();
        if( !delim )
        {
            dm.emitSyntaxErrorMessage(
                p.resolver()->currentLocation(), format( "'[' expected after '{}'.", name ), 0 );
            return false;
        }

        auto decomp = Decompose( delim->first, Val< Delimiter >() );
        if( !decomp || *decomp != Delimiter::OpenBracket )
        {
            dm.emitSyntaxErrorMessage(
                p.resolver()->currentLocation(), format( "'[' expected after '{}'.", name ), 0 );
            return false;
        }

        UnparsedPropositions* unparsedProps = nullptr;

        if( auto ft = FromValue< FuncType >( *type ) )
            unparsedProps = func( *ft );

        toks.resize( toks.size() - 1 );

        return true;
    }

    bool ParseRequiresOp( Parser& p, LocationId locationId, uint32_t prec )
    {
        return ParseVerifOp( p, locationId, prec, "requires",
            [&]< typename FT >( FT& ft )
            {
                if constexpr( is_same_v< FT, FuncType > )

                    return &ft.verifInfos()->preConds()->unparsed();

                else

                    return &ft.preConds()->unparsed();

            } );
    }

    bool ParseEnsuresOp( Parser& p, LocationId locationId, uint32_t prec )
    {
        return ParseVerifOp( p, locationId, prec, "ensures",
            [&]< typename FT >( FT& ft )
            {
                if constexpr( is_same_v< FT, FuncType > )

                    return &ft.verifInfos()->postConds()->unparsed();

                else

                    return &ft.postConds()->unparsed();

            } );
    }
} // namespace

namespace goose::builtins
{
    void SetupContractOps( Env& e )
    {
        RegisterRule( e, "requires"_sid, Rule( ContractOpPrecedence, ParseRequiresOp ) );
        RegisterRule( e, "ensures"_sid, Rule( ContractOpPrecedence, ParseEnsuresOp ) );
    }
} // namespace goose::builtins

//
// 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
{
    Value BuildOrRetrieveTVar(
        const Context& c, LocationId locationId, StringId name, bool forwarding )
    {
        if( name == "_"_sid )
            return forwarding ? ToValue( TTVar( "_"_sid ) ) : ToValue( TVar( "_"_sid ) );

        // Template name bindings are stored with a "$$" prefix so they don't
        // collide with regular names.
        auto captureIdentity = AppendToVectorTerm( c.identity(),

    }

    bool ParsePrefixDollarOperator( Parser& p, LocationId locationId, uint32_t prec )
    {
        auto nameTerm = p.resolver()->consumeUnresolved();
        if( !nameTerm )
        {
            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                locationId, "expected an identifier after '$'.", 0 );
            return false;
        }

        const auto* name = get_if< StringId >( &nameTerm->first );
        if( !name )
        {
            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                locationId, "expected an identifier after '$'.", 0 );
            return false;
        }

        const auto& c = p.context();
        auto val = BuildOrRetrieveTVar( c, nameTerm->second, *name, false );

        auto loc = Location::CreateSpanningLocation( locationId, nameTerm->second );
        val.setLocationId( loc );
        p.pushValue( move( val ) );
        return true;
    }

    bool ParsePrefixDollarDollarOperator( Parser& p, LocationId locationId, uint32_t prec )
    {
        auto nameTerm = p.resolver()->consumeUnresolved();
        if( !nameTerm )
        {
            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                locationId, "expected an identifier after '$$'.", 0 );
            return false;
        }

        const auto* name = get_if< StringId >( &nameTerm->first );
        if( !name )
        {
            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                locationId, "expected an identifier after '$$'.", 0 );
            return false;
        }

        const auto& c = p.context();
        auto val = BuildOrRetrieveTVar( c, nameTerm->second, *name, true );

        p.pushValue( move( val ) );

    bool ParseInfixDollarOperator( Parser& p, LocationId locationId, uint32_t prec )
    {
        const auto& leftVal = p.peekLastValue();
        if( !leftVal )
            return false;

        if( !builtins::IsType( p.context(), *leftVal ) && !IsTExpr( *leftVal ) )
            return false;

        auto nameTerm = p.resolver()->consumeUnresolved();
        const auto* name = get_if< StringId >( &nameTerm->first );
        const auto& c = p.context();

        auto val = BuildOrRetrieveTVar( c, nameTerm->second, *name, false );

        // If the TVar was already bound, we may end up with something in val
        // that isn't a TVar, which is an error.
        if( !IsTVar( val ) )
        {
            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                nameTerm->second, "expected an unbound identifier after '$'." );
            return false;
        }

        auto loc = Location::CreateSpanningLocation( leftVal->locationId(), nameTerm->second );

        auto typeOrTExpr = ValueToEIR( *p.popValue() );
        auto tdecl = TDecl( move( typeOrTExpr ), *name );

        p.pushValue( ToValue( move( tdecl ) ).setLocationId( loc ) );
        return true;
    }
} // namespace

namespace goose::builtins
{
    void SetupDollarOp( Env& e )
    {
        Rule r( ParsePrefixDollarOperator, InfixDollarPrecedence, ParseInfixDollarOperator );
        RegisterRule( e, "$"_sid, move( r ) );

        Rule r2( ParsePrefixDollarDollarOperator );
        RegisterRule( e, "$$"_sid, move( r2 ) );
    }
} // namespace goose::builtins

        BuildParseRule( e, "."_sid,
            LeftAssInfixOp( "operator_dot"_sid, precedence::DotOp,
                // dot operator for a tuple reference:
                // returns a reference to the specified member.
                ForTypes< CustomPattern< Value, ReferenceType::PatternAnyOf< TuplePattern > >,
                    CustomPattern< IntegerType, IntegerType::PatternUnsigned32 > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        G_VAL_ASSERT( lhs, !lhs.isConstant() );

                        if( !rhs.isConstant() )
                        {
                            DiagnosticsManager::GetInstance().emitErrorMessage( rhs.locationId(),
                                "the right operand for the dot operator needs to be a constant." );
                            return PoisonValue();
                        }

                        auto refType = *FromValue< ReferenceType >( *EIRToValue( lhs.type() ) );
                        auto tupType = *EIRToValue( refType.type() );

                        uint32_t index = *FromValue< uint32_t >( rhs );
                        if( index >= TupleTypeSize( tupType ) )
                        {
                            DiagnosticsManager::GetInstance().emitErrorMessage(
                                rhs.locationId(), "the index is out of range." );
                            return PoisonValue();
                        }

                        auto rt = ValueToEIR( ToValue( ReferenceType(
                            GetTupleTypeElement( tupType, index ), refType.accessSpec() ) ) );
                        return BuildComputedValue( rt, lhs, Select( index, c.locationId() ) );
                    } ),

                // Overload for constant tuples: directly return the wanted element
                ForTypes< CustomConstantPattern< Value, TuplePattern >,
                    CustomPattern< IntegerType, IntegerType::PatternUnsigned32 > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        G_VAL_ASSERT( lhs, lhs.isConstant() );

                        if( !rhs.isConstant() )
                        {
                            DiagnosticsManager::GetInstance().emitErrorMessage( rhs.locationId(),
                                "the right operand for the dot operator needs to be a constant." );
                            return PoisonValue();
                        }

                        uint32_t index = *FromValue< uint32_t >( rhs );
                        if( index >= TupleSize( lhs ) )
                        {
                            DiagnosticsManager::GetInstance().emitErrorMessage(
                                rhs.locationId(), "the index is out of range." );
                            return PoisonValue();
                        }

                        return *EIRToValue( GetConstantTupleElement( lhs, index ) );
                    } ),

                // For structs: look up the member name, get its index, and call the dot operator on
                // the underlying tuple
                ForTypes<
                    CustomPattern< Value, ReferenceType::PatternAnyOf< StructType::Pattern > >,
                    StringId >(
                    [dotOp]( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        // Extract the struct type form the ref type
                        auto refType = *FromValue< ReferenceType >( *EIRToValue( lhs.type() ) );
                        auto st = *EIRToValue( refType.type() );
                        auto structType = *FromValue< StructType >( st );

                        if( !structType.parse( c.env() ) )
                            return PoisonValue();

                        auto memberName = *FromValue< StringId >( rhs );

                        auto memberIdentity =
                            AppendToVectorTerm( structType.identity(), TERM( memberName ) );
                        Term result;

                        switch( c.env()->retrieveValue( memberIdentity, c.identity(), result ) )
                        {
                            case sema::Env::Status::Success:
                                break;

                            case sema::Env::Status::AmbiguousMatch:
                                DiagnosticsManager::GetInstance().emitErrorMessage( st.locationId(),
                                    "unexpected ambiguous match when resolving the member name." );
                                return PoisonValue();

                            default:
                                DiagnosticsManager::GetInstance().emitErrorMessage(
                                    st.locationId(), "unknown member name." );
                                return PoisonValue();
                        }

                        auto tupType = c.env()->retrieveValue( TSID( underlying_type ),
                            AppendToVectorTerm( structType.identity(), TERM( 0U ) ) );
                        G_VAL_ASSERT( lhs, tupType );

                        refType.type() = move( *tupType );
                        Value newRef(
                            ValueToEIR( ToValue( refType ) ), lhs.cir(), lhs.locationId() );
                        return InvokeOverloadSet( c, dotOp,
                            MakeClosedTuple(
                                newRef, EIRToValue( result )->setLocationId( rhs.locationId() ) ) );
                    } ) ) );


    }

} // namespace goose::builtins

namespace goose::builtins
{
    void SetupEllipsisOp( Env& e )
    {
        BuildParseRule( e, "..."_sid,
            PostfixOp( "operator_ellipsis"_sid, precedence::EllipsisOp,
                // default ellipsis operator: wrap whatever was given as parameter into a pack
                // TExpr. Complain if the operand isn't a constant.
                //
                // Unpack overloads will be more specific so they will take precedence where
                // applicable.
                ForType< Value >(
                    []( auto&& c, auto&& pattern ) -> Value
                    {
                        if( !pattern.isConstant() )
                        {
                            DiagnosticsManager::GetInstance().emitErrorMessage(
                                pattern.locationId(),
                                "pack expressions must be types, constants or template "
                                "expressions." );
                            return PoisonValue();
                        }
                        return ToValue( TPack( ValueToEIR( pattern ) ) );
                    } ) ) );


    }

} // namespace goose::builtins

namespace goose::builtins
{
    void SetupGhostOp( Env& e )
    {
        // TODO error out if function isn't a regular function or if its already ghost
        BuildParseRule( e, "ghost"_sid,
            PrefixOp( "operator_ghost"_sid, precedence::FuncQualifier,
                ForType< TypePatternParam< FuncType, FuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto ft = *FromValue< FuncType >( operand );
                        ft.setKind( FuncType::Kind::Ghost );
                        return ToValue( ft );
                    } ),
                ForType< TypePatternParam< TFuncType, TFuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tft = *FromValue< TFuncType >( operand );
                        tft.setKind( FuncType::Kind::Ghost );
                        return ToValue( tft );
                    } ),
                ForType< FuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto fd = *FromValue< FuncDecl >( operand );
                        fd.func().type().setKind( FuncType::Kind::Ghost );
                        return ToValue( fd );
                    } ),
                ForType< TFuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tfd = *FromValue< TFuncDecl >( operand );
                        tfd.tFunc().type().setKind( FuncType::Kind::Ghost );
                        return ToValue( tfd );
                    } ) ) );


    }

} // namespace goose::builtins

    template< typename... R >
    void BuildParseRule( sema::Env& env, StringId name, R&&... ruleBuilders )
    {
        parse::BuildParseRule( env, name, AppendToVectorTerm( RootG0Identity(), TERM( name ) ),
            forward< R >( ruleBuilders )... );
    }

    struct UnaryOpTag
    {
    };

    struct BinaryOpTag
    {
    };

    template< typename... R > auto PrefixOp( StringId funcName, uint32_t precedence, R&&... rules )
    {
        return [&, precedence, funcName]( auto&& e, auto&& r, auto&& name )
        {
            MakePrefixOp( e, r, name, precedence,
                BuildOpFunc< UnaryOpTag >( e, funcName, forward< R >( rules )... ) );
        };
    }


    template< typename... R > auto PostfixOp( StringId funcName, uint32_t precedence, R&&... rules )
    {
        return [&, precedence, funcName]( auto&& e, auto&& r, auto&& name )
        {
            MakePostfixOp( e, r, name, precedence,
                BuildOpFunc< UnaryOpTag >( e, funcName, forward< R >( rules )... ) );
        };
    }

    template< typename... R >
    auto LeftAssInfixOp( StringId funcName, uint32_t precedence, R&&... rules )
    {
        return [&, precedence, funcName]( auto&& e, auto&& r, auto&& name )
        {
            MakeLeftAssInfixOp( e, r, name, precedence,
                BuildOpFunc< BinaryOpTag >( e, funcName, forward< R >( rules )... ) );
        };
    }

    template< typename... R >
    auto RightAssInfixOp( StringId funcName, uint32_t precedence, R&&... rules )
    {
        return [&, precedence, funcName]( auto&& e, auto&& r, auto&& name )
        {
            MakeRightAssInfixOp( e, r, name, precedence,
                BuildOpFunc< BinaryOpTag >( e, funcName, forward< R >( rules )... ) );
        };
    }

    template< typename tag, typename... R >
    auto BuildOpFunc( Env& e, StringId funcName, R&&... ruleBuilders )
    {
        auto pOvlSet = GetOrCreateOverloadSet( e, funcName );
        ( ( ruleBuilders( e, pOvlSet, tag() ) ), ... );

        return [pOvlSet, funcName]< typename... O >( Parser& p, O&&... operands )
        {
            DiagnosticsContext dc( 0, format( "When invoking {}.", funcName.str() ) );
            return InvokeOverloadSet( p.context(), pOvlSet,
                MakeClosedTuple( forward< O >( operands )... ), p.context().locationId() );
        };
    }

    template< typename T, typename I, typename RT = T > auto ForType( CURRENT_LOC )

    {
        return [sloc]< typename tag >( auto&& e, auto&& pOvlSet, tag t )
        {
            using intrinsicType = Intrinsic< Value( T, T ) >;
            auto intrinsicFunc = []( const Context& c, const Value& lhs, const Value& rhs )

            { return BuildComputedValue( GetValueType< RT >(), lhs, rhs, I( c.locationId() ) ); };


            auto loc = Location::Create( sloc );
            pOvlSet->add( e, ToValue< intrinsicType >( move( intrinsicFunc ) ).setLocationId( loc ),
                GetBuiltinIntrinsicFuncInvocationRule() );
        };
    }

    template< typename T, typename F > auto ForType( F&& func, CURRENT_LOC )

    {
        return [&, sloc]< typename tag >( auto&& e, auto&& pOvlSet, tag t )
        {
            auto loc = Location::Create( sloc );
            if constexpr( is_same_v< tag, UnaryOpTag > )
            {
                using intrinsicType = Intrinsic< Value( T ) >;
                pOvlSet->add( e,
                    ToValue< intrinsicType >( forward< F >( func ) ).setLocationId( loc ),
                    GetBuiltinIntrinsicFuncInvocationRule() );
            }
            else
            {
                using intrinsicType = Intrinsic< Value( T, T ) >;
                pOvlSet->add( e,
                    ToValue< intrinsicType >( forward< F >( func ) ).setLocationId( loc ),
                    GetBuiltinIntrinsicFuncInvocationRule() );
            }
        };
    }

    template< typename T1, typename T2, typename F > auto ForTypes( F&& func, CURRENT_LOC )

    {
        return [=]< typename tag >( auto&& e, auto&& pOvlSet, tag t )
        {
            using intrinsicType = Intrinsic< Value( T1, T2 ) >;
            auto loc = Location::Create( sloc );
            pOvlSet->add( e, ToValue< intrinsicType >( func ).setLocationId( loc ),
                GetBuiltinIntrinsicFuncInvocationRule() );
        };
    }
} // namespace goose::builtins

#endif

namespace goose::builtins
{
    void SetupInlineOp( Env& e )
    {
        // TODO error out if function is not regular or already set as inline
        BuildParseRule( e, "inline"_sid,
            PrefixOp( "operator_inline"_sid, precedence::FuncQualifier,
                ForType< TypePatternParam< FuncType, FuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto ft = *FromValue< FuncType >( operand );
                        ft.setKind( FuncType::Kind::Inline );
                        return ToValue( ft );
                    } ),
                ForType< TypePatternParam< TFuncType, TFuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tft = *FromValue< TFuncType >( operand );
                        tft.setKind( FuncType::Kind::Inline );
                        return ToValue( tft );
                    } ),
                ForType< FuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto fd = *FromValue< FuncDecl >( operand );
                        fd.func().type().setKind( FuncType::Kind::Inline );
                        return ToValue( fd );
                    } ),
                ForType< TFuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tfd = *FromValue< TFuncDecl >( operand );
                        tfd.tFunc().type().setKind( FuncType::Kind::Inline );
                        return ToValue( tfd );
                    } ) ) );


    }

} // namespace goose::builtins

namespace goose::builtins
{
    void SetupIntrinsicOp( Env& e )
    {
        // TODO error out if function is not regular or already set as intrinsic
        BuildParseRule( e, "intrinsic"_sid,
            PrefixOp( "operator_intrinsic"_sid, precedence::FuncQualifier,
                ForType< TypePatternParam< FuncType, FuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto ft = *FromValue< FuncType >( operand );
                        ft.setKind( FuncType::Kind::Intrinsic );
                        return ToValue( ft );
                    } ),
                ForType< TypePatternParam< TFuncType, TFuncPattern > >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tft = *FromValue< TFuncType >( operand );
                        tft.setKind( FuncType::Kind::Intrinsic );
                        return ToValue( tft );
                    } ),
                ForType< FuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto fd = *FromValue< FuncDecl >( operand );
                        fd.func().type().setKind( FuncType::Kind::Intrinsic );
                        return ToValue( fd );
                    } ),
                ForType< TFuncDecl >(
                    []< typename O >( auto&& c, O&& operand ) -> Value
                    {
                        auto tfd = *FromValue< TFuncDecl >( operand );
                        tfd.tFunc().type().setKind( FuncType::Kind::Intrinsic );
                        return ToValue( tfd );
                    } ) ) );


    }

} // namespace goose::builtins

{
    void SetupLogicOps( Env& e )
    {
        auto orOp = GetOrCreateOverloadSet( e, "operator_or"_sid );
        auto andOp = GetOrCreateOverloadSet( e, "operator_and"_sid );

        BuildParseRule( e, "!"_sid,
            PrefixOp( "operator_logical_not"_sid, precedence::UnaryOps, BuildGenericTupleOperator(),


                ForType< bool >(
                    []( auto&& c, auto&& operand ) -> Value {

                        return BuildComputedValue(
                            GetValueType< bool >(), operand, cir::Not( c.locationId() ) );
                    } ) ) );



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


                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& operand ) -> Value
                    {
                        auto opTypeVal = *EIRToValue( operand.type() );
                        auto opType = *FromValue< IntegerType >( opTypeVal );
                        return BuildComputedValue( operand.type(), operand,
                            Value( operand.type(), APSInt::getMaxValue( opType.m_numBits, true ) ),
                            Xor( c.locationId() ) );

                    } ) ) );



        BuildParseRule( e, "^"_sid,
            LeftAssInfixOp( "operator_xor"_sid, precedence::OrOp, BuildGenericTupleOperator(),


                // Logical xor
                ForType< bool, Xor >(),

                // ct_int xor
                ForType< BigInt >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        if( !lhs.isConstant() || !rhs.isConstant() )
                        {
                            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                                c.locationId(),
                                "bitwise operations between ct_int values are only allowed on "
                                "constants." );
                            return PoisonValue();
                        }

                        return BuildComputedValue( lhs.type(), lhs, rhs, Xor( c.locationId() ) );

                    } ),

                // runtime integer xor, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value {

                        return BuildComputedValue( lhs.type(), lhs, rhs, Xor( c.locationId() ) );

                    } ) ) );



        BuildParseRule( e, "|"_sid,
            LeftAssInfixOp( "operator_or"_sid, precedence::OrOp, BuildGenericTupleOperator(),


                // ct_int or
                ForType< BigInt >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        if( !lhs.isConstant() || !rhs.isConstant() )
                        {
                            auto loc = Location::CreateSpanningLocation(
                                lhs.locationId(), rhs.locationId() );
                            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( loc,
                                "bitwise operations between ct_int values are only allowed on "
                                "constants." );
                            return PoisonValue();
                        }

                        return BuildComputedValue( lhs.type(), lhs, rhs, Or( c.locationId() ) );

                    } ),

                // runtime integer or, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return BuildComputedValue( lhs.type(), lhs, rhs, Or( c.locationId() ) ); } ),



                // bool or
                ForType< bool >(
                    [orOp]< typename L, typename R >( auto&& c, L&& lhs, R&& rhs ) -> Value
                    {
                        // Handle the case where lhs is constant, so that the result gets properly
                        // eagerly evaluated (in case we are using the expression as a compile time
                        // constant)
                        if( lhs.isConstant() )
                        {
                            if( *FromValue< bool >( lhs ) )
                                return forward< L >( lhs );

                            return forward< R >( rhs );
                        }

                        // This operator have different behaviors depending on the context: in
                        // normal code, we want to generate shortcut evaluation. But in propositions
                        // and ghost code, we want to simply generate a Or instruction with both
                        // operands always evaluated. So we delegate the work to another overload of
                        // operator_or that takes the builder as its first param and is overloaded
                        // according to it.
                        return InvokeOverloadSet( c, orOp,
                            MakeClosedTuple(
                                c.builder(), forward< L >( lhs ), forward< R >( rhs ) ) );
                    } ) ) );



        RegisterBuiltinFunc< Intrinsic< bool( Value, bool, bool ) > >( e, orOp,
            []( auto&& c, auto&& b, auto&& lhs, auto&& rhs ) {

                return BuildComputedValue( GetValueType< bool >(), lhs, rhs, Or( c.locationId() ) );
            } );

        // TODO_SSA: revise this
        /*RegisterBuiltinFunc< Intrinsic< bool ( TypeWrapper< ptr< CodeBuilder > >, bool, bool ) >
           >( e, orOp,
            []( auto&& c, auto&& b, auto&& lhs, auto&& rhs )
            {
                auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( b );
                const auto& cfg = cb->cfg();

                // Build the control flow for shortcut evaluation.
                const auto& predBB = cfg->currentBB();

                // Build the result val which pulls the temporary created above.
                return BuildComputedValue( GetValueType< bool >(),
                    GetTemporary( GetValueType< bool >(), resultIndex, c.locationId() ) );
            } );*/

        BuildParseRule( e, "&"_sid,
            LeftAssInfixOp( "operator_and"_sid, precedence::AndOp, BuildGenericTupleOperator(),


                // ct_int and
                ForType< BigInt >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        if( !lhs.isConstant() || !rhs.isConstant() )
                        {
                            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                                c.locationId(),
                                "bitwise operations between ct_int values are only allowed on "
                                "constants." );
                            return PoisonValue();
                        }

                        return BuildComputedValue( lhs.type(), lhs, rhs, And( c.locationId() ) );

                    } ),

                // runtime integer and, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value

                    { return BuildComputedValue( lhs.type(), lhs, rhs, And( c.locationId() ) ); } ),



                // bool and
                ForType< bool >(
                    [andOp]< typename L, typename R >( auto&& c, L&& lhs, R&& rhs ) -> Value
                    {
                        // Handle the case where lhs is constant, so that
                        // the result gets properly eagerly evaluated (in case
                        // we are using the expression as a compile time constant)
                        if( lhs.isConstant() )
                        {
                            if( *FromValue< bool >( lhs ) )
                                return forward< R >( rhs );

                            return forward< L >( lhs );
                        }

                        // This operator have different behaviors depending on the context: in
                        // normal code, we want to generate shortcut evaluation. But in propositions
                        // and ghost code, we want to simply generate a And instruction with both
                        // operands always evaluated. So we delegate the work to another overload of
                        // operator_and that takes the builder as its first param and is overloaded
                        // according to it.
                        return InvokeOverloadSet( c, andOp,
                            MakeClosedTuple(
                                c.builder(), forward< L >( lhs ), forward< R >( rhs ) ) );
                    } ) ) );



        RegisterBuiltinFunc< Intrinsic< bool( Value, bool, bool ) > >( e, andOp,
            []( auto&& c, auto&& b, auto&& lhs, auto&& rhs ) {

                return BuildComputedValue(
                    GetValueType< bool >(), lhs, rhs, And( c.locationId() ) );
            } );

        // TODO_SSA revise this
        /*        RegisterBuiltinFunc< Intrinsic< bool ( TypeWrapper< ptr< CodeBuilder > >, bool,
           bool ) > >( e, andOp,
                    []( auto&& c, auto&& b, auto&& lhs, auto&& rhs )
                    {
                        auto cb = *FromValue< TypeWrapper< ptr< CodeBuilder > > >( b );
                        const auto& cfg = cb->cfg();

                        // Build the control flow for shortcut evaluation.
                        const auto& predBB = cfg->currentBB();

                        auto pRhsBB = cfg->createBB();
                        auto pSuccBB = cfg->createBB();

                        // If the lhs is false, skip to the end directly.
                        // Otherwise, jump to the BB that computes rhs.
                        predBB->append( lhs );
                        predBB->setTerminator( CondBranch( pRhsBB, pSuccBB ) );

                        auto rhsIndex = util::GenerateNewUID();
                        pRhsBB->append( rhs, CreateTemporary( rhsIndex, false, c.locationId() ) );
                        pRhsBB->setTerminator( Branch( pSuccBB ) );

                        auto resultIndex = util::GenerateNewUID();

                        // Build the Phi instruction that will collect the final result.
                        auto phi = Phi( GetValueType< bool >(), 2,
                            resultIndex, c.locationId() );

                        // If coming directly from the lhs BB, we know the result is false.
                        phi.setIncoming( predBB, ToValue( false ) );

                        // Otherwise, the result is whatever was computed by the rhs block.
                        phi.setIncoming( pRhsBB, BuildComputedValue( GetValueType< bool >(),
                            GetTemporary( GetValueType< bool >(), rhsIndex, c.locationId() ) ) );

                        pSuccBB->append( move( phi ) );
                        cfg->setCurrentBB( pSuccBB );

                        // Build the result val which pulls the temporary created above.
                        return BuildComputedValue( GetValueType< bool >(),
                            GetTemporary( GetValueType< bool >(), resultIndex, c.locationId() ) );
                    } );*/

        BuildParseRule( e, "<<"_sid,
            LeftAssInfixOp( "operator_shift_left"_sid, precedence::BitShiftOp,
                BuildGenericTupleOperator(),

                // ct_int left shift
                ForTypes< BigInt, uint32_t >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        if( !lhs.isConstant() || !rhs.isConstant() )
                        {
                            auto loc = Location::CreateSpanningLocation(
                                lhs.locationId(), rhs.locationId() );
                            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( loc,
                                "bitwise operations between ct_int values are only allowed on "
                                "constants." );
                            return PoisonValue();
                        }

                        return BuildComputedValue( lhs.type(), lhs, rhs, Shl( c.locationId() ) );

                    } ),

                // runtime integer left shift.
                ForTypes< CustomPattern< IntegerType, IntegerType::Pattern >,
                    CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        using namespace goose::builtins::exprhelpers;

                        auto cfg = GetCFG( c );
                        assert( cfg );

                        // Shifting for a number of bits equal or larger than the bitsize
                        // of lhs is an undefined behavior, so we require verification that
                        // it won't happen.
                        // Extract the integer type of lhs to retrieve its bit size.
                        auto lhsType = *FromValue< IntegerType >( *EIRToValue( lhs.type() ) );
                        auto bitSizeValue = Value( rhs.type(), APSInt::get( lhsType.m_numBits ) );

                        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()->append( move( cond ), cir::Assert( rhs.locationId() ) );


                        return BuildComputedValue( lhs.type(), lhs, rhs, Shl( c.locationId() ) );

                    } ) ) );



        BuildParseRule( e, ">>"_sid,
            LeftAssInfixOp( "operator_shift_right"_sid, precedence::BitShiftOp,
                BuildGenericTupleOperator(),

                // ct_int right shift
                ForTypes< BigInt, uint32_t >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        if( !lhs.isConstant() || !rhs.isConstant() )
                        {
                            DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                                c.locationId(),
                                "bitwise operations between ct_int values are only allowed on "
                                "constants." );
                            return PoisonValue();
                        }

                        return BuildComputedValue( lhs.type(), lhs, rhs, AShr( c.locationId() ) );

                    } ),

                // runtime signed integer right shift, defined to work for any two integers of same
                // bit size.
                ForTypes< CustomPattern< IntegerType, IntegerType::PatternSigned >,
                    CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        using namespace goose::builtins::exprhelpers;

                        auto cfg = GetCFG( c );
                        assert( cfg );

                        // Shifting for a number of bits equal or larger than the bitsize
                        // of lhs is an undefined behavior, so we require verification that
                        // it won't happen.
                        // Extract the integer type of lhs to retreieve its bit size.
                        auto lhsType = *FromValue< IntegerType >( *EIRToValue( lhs.type() ) );
                        auto bitSizeValue = Value( rhs.type(), APSInt::get( lhsType.m_numBits ) );

                        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()->append( move( cond ), cir::Assert( rhs.locationId() ) );


                        return BuildComputedValue( lhs.type(), lhs, rhs, AShr( c.locationId() ) );

                    } ),

                // runtime unsigned integer right shift, defined to work for any two integers of
                // same bit size.
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                    []( auto&& c, auto&& lhs, auto&& rhs ) -> Value
                    {
                        using namespace goose::builtins::exprhelpers;

                        auto cfg = GetCFG( c );
                        assert( cfg );

                        // Shifting for a number of bits equal or larger than the bitsize
                        // of lhs is an undefined behavior, so we require verification that
                        // it won't happen.
                        // Extract the integer type of lhs to retreieve its bit size.
                        auto lhsType = *FromValue< IntegerType >( *EIRToValue( lhs.type() ) );
                        auto bitSizeValue = Value( rhs.type(), APSInt::get( lhsType.m_numBits ) );

                        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()->append( move( cond ), cir::Assert( rhs.locationId() ) );


                        return BuildComputedValue( lhs.type(), lhs, rhs, LShr( c.locationId() ) );

                    } ) ) );


    }

} // namespace goose::builtins

        SetupDollarOp( e );
        SetupApostropheOp( e );
        SetupLogicOps( e );
        SetupArithOps( e );
        SetupComparisonOps( e );
        SetupAssignmentOps( e );

        // Must be last since it needs to retrieve the overload sets of some previously defined

        // operators
        SetupCompoundAssOps( e );

        SetupDotOp( e );

        SetupIntrinsicOp( e );
        SetupInlineOp( e );
        SetupComptimeOp( e );
        SetupGhostOp( e );
        SetupContractOps( e );
        SetupEllipsisOp( e );
    }
} // namespace goose::builtins

#endif

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

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

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

    }
} // namespace

namespace goose::builtins
{
    void SetupSemicolonOp( Env& e )
    {
        // Semicolon is not a real operator: it just consumes itself and do nothing as a prefix
        // operator, and it pushes the result of evaluating its rhs as an infix operator (if there
        // is any).
        Rule r(

            parseSemicolon, []( const Parser& p ) { return precedence::StmtSeparator; },
            parseSemicolon );

        RegisterRule( e, ";"_sid, move( r ) );
    }
} // namespace goose::builtins

#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
{
    Generator< Value > GenerateRHSValuesFromTupleRef(
        const ptr< OverloadSet >& assOp, const Context& c, const Value& tup )
    {
        auto cfg = GetCFG( c );
        if( !cfg )
            co_yield Value( PoisonValue() );

        auto tupRefType = *FromValue< ReferenceType >( *EIRToValue( tup.type() ) );

        // Store the source tuple as a temporary, otherwise we're going to recompute rhs
        // for each member assigned (which is bad)
        // TODO_SSA rewrite this (since CreateTemporary makes no sense anymore)
        co_return;
        /*    auto index = util::GenerateNewUID();
            cfg->currentBB()->append( tup, CreateTemporary( index, false, tup.locationId() ) );
            auto srcTup = BuildComputedValue( tupRefType.type(), GetTemporary( tupRefType.type(),
           index, tup.locationId() ) );

            auto anonVarDecl = ToValue( TNamedDecl( ValueToEIR( ToValue( TVar( "_"_sid ) ) ), ""_sid
           ) ); co_yield GenerateValuesFromComputedTuple( srcTup );*/

    }

    // Assignment of a compile time tuple or tuple reference to another compile time tuple,
    // directly. Most tuple assignment will go through one of the other overload that takes a mutref
    // to a tuple on the lhs, but sometimes we have compilation time tuples of objects that can
    // directly be assigned such as decls or refs.
    //
    // So this overload is for all these cases, which encompass initializing multiple comma
    // separated decls from a tuple, as well as variable swapping/shuffling. To make sure that the
    // later works properly, we store all the rhs values into temporary variables first, before
    // assigning them to the lhs values.
    Value NonRefTupleAssignment(
        const ptr< OverloadSet >& assOp, Context& c, const Value& lhs, const Value& rhs )
    {
        auto tupSize = TupleSize( lhs );

        // Load the values from the rhs tuple into temporary vars.
        vector< Value > tempVars;
        tempVars.reserve( tupSize );

        Generator< Value > gen;
        if( rhs.isConstant() )
            gen = GenerateValuesFromConstantTuple( rhs );
        else
            gen = GenerateRHSValuesFromTupleRef( assOp, c, rhs );

        for( auto&& srcVal : gen )
        {
            // We go at very high level to construct the temporary variables by resolving an
            // invocation of the assignment of the rhs value to a TNamedDecl with an empty name. The
            // reason we need to work at such high level is so that the initializer value gets
            // resolved exactly like if it was a regular assignment. In particular, if the value in
            // question is a locvar, we want it to go through the type checking process to be
            // replaced with its content. This is the simplest and most robust way to achieve this,
            // which should honor every relevant extension point.
            auto tmpVar = DeclareLocalVarWithTypeInference(
                c, ValueToEIR( ToValue( TVar( "_"_sid ) ) ), ""_sid, srcVal, srcVal.locationId() );

            if( tmpVar.isPoison() )
                return PoisonValue();

            tmpVar.setLocationId( srcVal.locationId() );
            tempVars.emplace_back( move( tmpVar ) );
        }

        if( tupSize != tempVars.size() )
        {
            DiagnosticsManager::GetInstance().emitErrorMessage( 0, "incompatible tuple sizes." );
            return PoisonValue();
        }

        auto result = EmptyOpenTuple();

        size_t i = 0;
        bool success = true;
        ForEachInTuple( lhs,
            [&]( auto&& destVal )
            {
                auto r = InvokeOverloadSet( c, assOp, MakeClosedTuple( destVal, tempVars[i++] ) );


                if( r.isPoison() )
                {
                    success = false;
                    return false;
                }

                result = AppendToTuple( result, move( r ) );
                return true;
            } );

        if( !success )
            return PoisonValue();

        return result;

    }

    Value MutRefTupleAssignment(
        const ptr< OverloadSet >& assOp, Context& c, const Value& lhs, const Value& rhs )
    {
        auto lhsRefType = *FromValue< ReferenceType >( *EIRToValue( lhs.type() ) );
        auto lhsTupType = *EIRToValue( lhsRefType.type() );

        auto rhsTupTypeEIR = rhs.type();
        if( !rhs.isConstant() )
        {
            auto rhsRefType = *FromValue< ReferenceType >( *EIRToValue( lhs.type() ) );
            rhsTupTypeEIR = rhsRefType.type();
        }

        auto rhsTupType = *EIRToValue( rhsTupTypeEIR );

        if( IsTrivialTupleAssignment( c, lhsTupType, rhsTupType ) )
        {
            auto cfg = GetCFG( c );
            if( !cfg )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    0, "assignments are not allowed here." );
                return PoisonValue();
            }
            else if( auto bb = cfg->currentBB() )
            {
                bb->append( rhs );
                if( !rhs.isConstant() )
                    bb->append( Load( rhsTupTypeEIR, rhs.locationId() ) );

        if( rhs.isConstant() )
            gen = GenerateValuesFromConstantTuple( rhs );
        else
            gen = GenerateRHSValuesFromTupleRef( assOp, c, rhs );

        uint32_t index = 0;
        bool success = true;
        ForEachInTupleType( lhsTupType,
            [&]( auto&& t )
            {
                if( gen.finished() )
                {
                    DiagnosticsManager::GetInstance().emitErrorMessage(
                        0, "incompatible tuple sizes." );
                    success = false;
                    return false;
                }

                auto srcVal = gen.consume();
                auto rt = ValueToEIR( ToValue( ReferenceType( t, MutAccessSpecifier() ) ) );
                auto destVal =
                    BuildComputedValue( rt, lhs, cir::Select( index++, lhs.locationId() ) );

                auto r = InvokeOverloadSet( c, assOp, MakeClosedTuple( destVal, srcVal ) );


                success = !r.isPoison();
                return success;
            } );

        if( !success )
            return PoisonValue();

        if( !gen.finished() )
        {
            DiagnosticsManager::GetInstance().emitErrorMessage( 0, "incompatible tuple sizes." );
            return PoisonValue();
        }

        return lhs;

    }
} // namespace goose::builtins

#ifndef GOOSE_BUILTINS_OPERATORS_TUPLE_H
#define GOOSE_BUILTINS_OPERATORS_TUPLE_H

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

    static inline auto BuildGenericTupleOperator()
    {
        return []< typename tag >( auto&& e, auto&& pOvlSet, tag t )
        {
            if constexpr( is_same_v< tag, UnaryOpTag > )
            {
                using intrinsicType = Intrinsic< Value( CustomPattern< Value, TuplePattern > ) >;
                auto intrinsicFunc = [pOvlSet]( const Context& c, const Value& operand )
                {
                    auto result = EmptyOpenTuple();

                    ForEachInTuple( operand,
                        [&]( auto&& operand )
                        {
                            auto r = InvokeOverloadSet( c, pOvlSet, MakeClosedTuple( operand ) );

                            result = AppendToTuple( result, r );
                            return true;
                        } );

                    return result;
                };

                pOvlSet->add( e, ToValue< intrinsicType >( move( intrinsicFunc ) ),
                    GetBuiltinIntrinsicFuncInvocationRule() );
            }
            else
            {
                using intrinsicType = Intrinsic< Value(
                    CustomPattern< Value, TuplePattern >, CustomPattern< Value, TuplePattern > ) >;
                auto intrinsicFunc = [pOvlSet](
                                         const Context& c, const Value& lhs, const Value& rhs )
                {
                    if( TupleSize( lhs ) != TupleSize( rhs ) )
                    {
                        DiagnosticsManager::GetInstance().emitErrorMessage(
                            0, "Incompatible tuple sizes." );
                        return PoisonValue();
                    }

                    auto result = EmptyOpenTuple();

                    ForEachInTuples( lhs, rhs,
                        [&]( auto&& lhs, auto&& rhs )
                        {
                            auto r = InvokeOverloadSet( c, pOvlSet, MakeClosedTuple( lhs, rhs ) );


                            // Super inefficient, but that's far from the biggest such problem.
                            // This is just the bootstrap compiler anyway. Should hopefully be able
                            // to easily make more optimized stuff when rewriting the self hosted
                            // compiler, some day far away in the future.
                            result = AppendToTuple( result, r );
                            return true;
                        } );

                    return result;
                };

                pOvlSet->add( e, ToValue< intrinsicType >( move( intrinsicFunc ) ),
                    GetBuiltinIntrinsicFuncInvocationRule() );
            }
        };
    }
} // namespace goose::builtins

#endif

        {
            auto& dm = DiagnosticsManager::GetInstance();

            auto level = GetBreakableScopeLevels( p.context() );

            if( p.isInParenExpr() || !level )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "the break statement is not allowed here.", 0 );
                return false;
            }

            auto cfg = GetCFG( p.context() );

            if( !cfg->currentBB() || cfg->currentBB()->terminator() )
            {

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

        RegisterRule( e, "break"_sid, Rule( handleBreak ) );
    }
} // namespace goose::builtins

        {
            auto& dm = DiagnosticsManager::GetInstance();

            auto level = GetContinuableScopeLevels( p.context() );

            if( p.isInParenExpr() || !level )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "the continue statement is not allowed here.", 0 );
                return false;
            }

            auto cfg = GetCFG( p.context() );

            if( !cfg->currentBB() || cfg->currentBB()->terminator() )
            {

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

        RegisterRule( e, "continue"_sid, Rule( handleContinue ) );
    }
} // namespace goose::builtins

        auto handleCTFor = []( Parser& p, LocationId locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::ForStmt ) )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected a declaration following the #for statement.", 0 );
                return false;
            }

            auto decl = np.popValue();
            if( !decl )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected a declaration following the #for statement.", 0 );
                return false;
            }

            bool isDecl = IsDecl( *decl );
            bool isTNamedDecl = IsTNamedDecl( *decl );
            bool isTDecl = IsTDecl( *decl );

            // TODO also allow a TVar or TTVar, turn them into a TDecl, like for tfunc params?

            if( !isDecl && !isTNamedDecl && !isTDecl )
            {
                dm.emitSyntaxErrorMessage( decl->locationId(), "expected a declaration.", 0 );
                return false;
            }

            auto next = p.resolver()->consumeUnresolved();
            if( !next )
            {
                dm.emitSyntaxErrorMessage(
                    decl->locationId(), "expected 'in' after declaration.", 0 );
                return false;
            }

            const auto* nextSid = get_if< StringId >( &next->first );
            if( !nextSid )
            {
                dm.emitSyntaxErrorMessage(
                    decl->locationId(), "expected 'in' after declaration.", 0 );
                return false;
            }

            if( *nextSid != "in"_sid )
            {
                dm.emitSyntaxErrorMessage( next->second, "expected 'in'.", 0 );
                return false;
            }

            np = p.makeNestedParser();
            if( !np.parseExpression( precedence::ForStmt ) )
            {
                dm.emitSyntaxErrorMessage(
                    next->second, "expected an expression following 'in'.", 0 );
                return false;
            }

            auto container = np.popValue();
            if( !container )
            {
                dm.emitSyntaxErrorMessage(
                    next->second, "expected an expression following 'in'.", 0 );
                return false;
            }

            auto body = make_shared< vector< TermLoc > >();
            auto g = p.resolver()->consumeUnit();
            move( g.begin(), g.end(), back_inserter( *body ) );

            Value wrappedDecl;

            if( isDecl )
            {
                wrappedDecl = ToValue( Wrap( make_shared< Decl >( *FromValue< Decl >( *decl ) ) ) )
                                  .setLocationId( decl->locationId() );
            }
            else if( isTNamedDecl )
            {
                wrappedDecl = ToValue(
                    Wrap( make_shared< TNamedDecl >( *FromValue< TNamedDecl >( *decl ) ) ) )
                                  .setLocationId( decl->locationId() );
            }
            else if( isTDecl )
            {
                wrappedDecl =
                    ToValue( Wrap( make_shared< TDecl >( *FromValue< TDecl >( *decl ) ) ) )
                        .setLocationId( decl->locationId() );
            }

            CTForEach( p.context(), wrappedDecl, *container, body );
            return true;
        };

        RegisterRule( e, "#for"_sid, Rule( handleCTFor ) );

        RegisterRule( e, "in"_sid,
            Rule( []( auto&& ) -> optional< uint32_t > { return nullopt; },
                []( auto&&, auto&&, auto&& ) { return false; } ) );

    }

} // namespace goose::builtins

        auto handleCTIf = []( Parser& p, LocationId locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::IfStmt ) )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected an expression following the #if statement.", 0 );
                return false;
            }

            auto condVal = np.popValue();
            if( !condVal )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected an expression following the #if statement.", 0 );
                return false;
            }

            const auto& context = p.context();
            auto converted = ConvertValueToType( context, *condVal, GetValueType< bool >() );
            if( holds_alternative< ValUnifyError >( converted ) )
            {
                switch( get< ValUnifyError >( converted ) )
                {
                    case ValUnifyError::NoSolution:
                        dm.emitErrorMessage(
                            condVal->locationId(), "this doesn't evaluate to a bool constant." );
                        break;

                    case ValUnifyError::Ambiguous:
                        dm.emitErrorMessage( condVal->locationId(), "ambiguous bool conversion." );
                        break;
                }

                return false;
            }

            auto condBool = get< Value >( converted );

            if( !condBool.isConstant() )
            {
                dm.emitErrorMessage(
                    condVal->locationId(), "this doesn't evaluate to a bool constant." );
                return false;
            }

            auto cond = FromValue< bool >( condBool );

            // If the cond is invalid, both blocks will be excluded, but parsing will continue, to
            // give the best chance of a graceful recovery of the parsing and hopefully be able to
            // detect more legit errors before we bail out. We do mark the current diagnostics
            // context as busted, however, since what we're going to miss in the #if block that
            // should have been parsed is likey to cause cascading errors in the current scope.

            if( !cond )
                dm.emitSyntaxErrorMessage(
                    condVal->locationId(), "this doesn't evaluate to a bool constant." );

            auto next = p.resolver()->lookAheadUnresolved();
            if( !next )
            {
                dm.emitSyntaxErrorMessage(
                    p.resolver()->currentLocation(), "brace block expected.", 0 );
                return false;
            }

            auto decomp = Decompose( next->first, Val< Delimiter >() );
            if( !decomp || *decomp != Delimiter::OpenBrace )
            {
                dm.emitSyntaxErrorMessage(
                    p.resolver()->currentLocation(), "brace block expected.", 0 );
                return false;
            }

            // Deal with the then block.
            if( cond && *cond )
            {
                // Condition is true: parse the 'then' block.
                if( !p.parseBraceBlock() )
                    return false;
            }
            else
            {
                // Condition is false: skip the 'then' block.
                auto gen = p.resolver()->consumeUnit();
                for_each( gen.begin(), gen.end(), []( auto&& ) {} );
            }

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

                    auto next = p.resolver()->lookAheadUnresolved();
                    auto decomp = Decompose( next->first, Val< Delimiter >() );
                    if( !decomp || *decomp != Delimiter::OpenBrace )
                    {
                        dm.emitSyntaxErrorMessage(
                            p.resolver()->currentLocation(), "brace block expected.", 0 );
                        return false;
                    }

                    // Deal with the else block.
                    if( cond && !*cond )
                    {
                        // Condition is false: parse the 'else' block.
                        if( !p.parseBraceBlock() )
                            return false;
                    }
                    else
                    {
                        // Condition is true: skip the 'else' block.
                        auto gen = p.resolver()->consumeUnit();
                        for_each( gen.begin(), gen.end(), []( auto&& ) {} );
                    }
                }
            }

            return true;
        };

        RegisterRule( e, "#if"_sid, Rule( handleCTIf ) );
    }
} // namespace goose::builtins

        auto handleForAll = []( Parser& p, LocationId locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();
            auto& c = p.context();

            if( !InVerificationCode( c ) )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "the forall statement is not allowed here.", 0 );
                return false;
            }

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::IfStmt ) )
            {
                dm.emitSyntaxErrorMessage( locationId,
                    "expected a decl or a tuple of decls following the forall statement.", 0 );
                return false;
            }

            auto decls = np.popValue();
            if( !decls )
            {
                dm.emitSyntaxErrorMessage( locationId,
                    "expected a decl or a tuple of decls following the forall statement.", 0 );
                return false;
            }

            if( !IsTuple( *decls ) )
                decls = MakeOpenTuple( move( *decls ) );

            auto is = make_shared< InstrSeq >();

            auto identity =
                AppendToVectorTerm( c.identity(), TERM( StringId( Env::NewUniqueId() ) ) );
            c.env()->addVisibilityRule( c.identity(), identity );

            bool failed = false;
            uint32_t numArgs = 0;
            ForEachInTuple( *decls,
                [&]( auto&& d )
                {
                    auto decl = FromValue< Decl >( d );
                    if( !decl )
                    {
                        dm.emitErrorMessage( d.locationId(), "expected a decl." );
                        failed = true;
                        return false;
                    }

                    auto ph = BuildComputedValue(
                        decl->type(), Placeholder( decl->type(), decl->name(), d.locationId() ) );
                    c.env()->storeValue( AppendToVectorTerm( identity, decl->name() ), ANYTERM( _ ),
                        ValueToEIR( ph ) );


                    AppendToInstrSeq( *is, PushType( decl->type(), d.locationId() ),
                        PushStringId( decl->name(), d.locationId() ) );

                    ++numArgs;
                    return true;
                } );

            if( failed )
                return false;

            AppendToInstrSeq( *is, ForAllSetup( numArgs, locationId ) );

            auto delim = np.resolver()->lookAheadUnresolved();
            if( !delim )
            {
                dm.emitSyntaxErrorMessage(
                    np.resolver()->currentLocation(), format( "'[' expected." ), 0 );
                return false;
            }

            auto decomp = Decompose( delim->first, Val< Delimiter >() );
            if( !decomp || *decomp != Delimiter::OpenBracket )
            {
                dm.emitSyntaxErrorMessage(
                    np.resolver()->currentLocation(), format( "'[' expected." ), 0 );
                return false;
            }

            // Parse the propositions block.
            auto [props, ploc] = p.tokenizeBracketBlock();
            props->setIdentity( identity );

            if( !props->parse( c ) )
                return true;

            // Merge the propositions into a conjunction
            bool first = true;
            for( auto&& p : props->props() )
            {
                AppendToInstrSeq( *is, move( p ) );

                if( !first )
                    AppendToInstrSeq( *is, And( locationId ) );

                first = false;
            }

            AppendToInstrSeq( *is, ForAll( locationId ) );

            p.pushValue( BuildComputedValue( GetValueType< bool >(), move( is ) )
                             .setLocationId( locationId ) );
            return true;
        };

        RegisterRule( e, "forall"_sid, Rule( handleForAll ) );
    }
} // namespace goose::builtins

            // Create a scope for the entire if, so that any var declared
            // inside of the condition is alive and visible throughout the if.
            Scope s( p.context() );

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::IfStmt ) )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected an expression following the if statement.", 0 );
                return false;
            }

            auto condVal = np.popValue();
            if( !condVal )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected an expression following the if statement.", 0 );
                return false;
            }

            const auto& context = p.context();
            auto converted = ConvertValueToType( context, *condVal, GetValueType< bool >() );
            if( holds_alternative< ValUnifyError >( converted ) )
            {
                switch( get< ValUnifyError >( converted ) )
                {
                    // If the condition is invalid, bail out and mark the current
                    // diagnostics context as bust to avoid spamming cascading errors.
                    case ValUnifyError::NoSolution:
                        dm.emitSyntaxErrorMessage( condVal->locationId(),
                            "the if condition can't be converted to a bool." );
                        break;

                    case ValUnifyError::Ambiguous:
                        dm.emitSyntaxErrorMessage(
                            condVal->locationId(), "ambiguous if condition bool conversion." );
                        break;
                }

                return false;
            }

            if( get< Value >( converted ).isPoison() )
                PoisonBuilder( p.context() );

            // The condition may have emitted additional basic blocks, so get the current block
            // again.
            pPrecBB = cfg->currentBB();

            auto pThenBB = ParseSubStatement( p, precedence::IfStmt );
            if( !pThenBB )
            {
                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 )
                {
                    p.resolver()->consumeUnresolved();
                    pElseBB = ParseSubStatement( p, precedence::IfStmt );
                    if( !pElseBB )
                    {
                        dm.emitSyntaxErrorMessage( p.resolver()->currentLocation(),
                            "expected a statement after 'else'.", 0 );
                        return false;
                    }

                    // Retrieve the successor block of the else branch, if any
                    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 = cfg->createBB();

            pPrecBB->append( get< Value >( converted ) );
            pPrecBB->setTerminator( cir::CondBranch( 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;
        };

        RegisterRule( e, "if"_sid, Rule( handleIf ) );
    }
} // namespace goose::builtins

        auto handleReturn = []( Parser& p, LocationId locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();
            auto cfg = GetCFG( p.context() );

            if( p.isInParenExpr() || !cfg || !IsBranchingAllowed( p.context() ) )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "the return statement is not allowed here.", 0 );
                return false;
            }

            if( !cfg->currentBB() || cfg->currentBB()->terminator() )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    locationId, "unreachable code.", 0 );

                cfg->emitTerminator( locationId, cir::RetVoid( locationId ) );
                return true;
            }

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

            auto retVal = np.popValue();
            if( !retVal )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected an expression following the return statement.", 0 );
                cfg->currentBB()->append( PoisonValue() );
                cfg->emitTerminator( locationId, cir::Ret( locationId ) );
                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.
                cfg->currentBB()->append( PoisonValue() );
                cfg->emitTerminator( locationId, cir::Ret( locationId ) );
                PoisonBuilder( p.context() );
                return true;
            }

            cfg->currentBB()->append( get< Value >( converted ) );
            cfg->emitTerminator( locationId, cir::Ret( locationId ) );
            return true;
        };

        RegisterRule( e, "return"_sid, Rule( handleReturn ) );
    }
} // namespace goose::builtins

        SetupCTIfStmt( e );
        SetupWhileStmt( e );
        SetupCTForStmt( e );
        SetupBreakStmt( e );
        SetupContinueStmt( e );
        SetupForAllStmt( e );
    }
} // namespace goose::builtins

#endif

        auto handleUsing = []( Parser& p, LocationId locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();

            auto nameTerm = p.resolver()->consume();
            if( !nameTerm )
            {
                dm.emitSyntaxErrorMessage(
                    p.resolver()->currentLocation(), "expected an identifier.", 0 );
                return false;
            }

            const auto* name = get_if< StringId >( &nameTerm->first );
            if( !name )
            {
                dm.emitSyntaxErrorMessage( nameTerm->second, "expected an identifier.", 0 );
                return false;
            }

            sema::Context::CurrentContextGuard ccg( p.context() );

            auto& context = p.context();

            // we don't have a builder to parse using expresions. It disables
            // a number of things, in particular, the ability to overload functions.
            // This avoids unfortunate parsing ambiguiousness in some cases
            // (cf test g0/statements/e-using-2.g0)
            context.setBuilder( ToValue< void >() );

            // Create an identity to contain the visibility of any symbol defined inside of the
            // using statement. Since the current identity is that of the local variables of the
            // current function and those shouldn't be visible inside of the using statement, we
            // simply replace the last element of the identity by the name of the using definition,
            // so that its parent becomes the current function's identity.
            //
            // TODO: we'll probably need a more sophisticated scheme to be able to deal with lambda
            // captures where localvars from the parent(s) functions should be visible, but still
            // not visible inside of using statements. But one mess of a feature at a time.
            auto localIdentity =
                TakeVectorTerm( context.identity(), VecSize( context.identity() ) - 1 );
            get< pvec >( localIdentity )->terms().back() = nameTerm->first;

            // TODO this probably makes locvars visible from inside the using expression, which is
            // wrong see struct/parse.cpp for a better approach

            context.env()->addVisibilityRule( context.identity(), localIdentity );

            context.setIdentity( localIdentity );

            auto eqTerm = p.resolver()->consumeUnresolved();
            if( !eqTerm )
            {
                dm.emitSyntaxErrorMessage( p.resolver()->currentLocation(), "expected '='.", 0 );
                context.env()->storeValue(
                    localIdentity, ANYTERM( _ ), ValueToEIR( PoisonValue() ) );
                return true;
            }

            const auto* eq = get_if< StringId >( &eqTerm->first );
            if( !eq || *eq != "="_sid )
            {
                dm.emitSyntaxErrorMessage( eqTerm->second, "expected '='.", 0 );
                context.env()->storeValue(
                    localIdentity, ANYTERM( _ ), ValueToEIR( PoisonValue() ) );
                return true;
            }

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::UsingStmt ) )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    locationId, "expected an expression.", 0 );
                context.env()->storeValue(
                    localIdentity, ANYTERM( _ ), ValueToEIR( PoisonValue() ) );
                return true;
            }

            if( !np.peekLastValue() )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    locationId, "expected an expression.", 0 );
                context.env()->storeValue(
                    localIdentity, ANYTERM( _ ), ValueToEIR( PoisonValue() ) );
                return true;
            }

            auto val = np.popValue();
            if( !val->isConstant() )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    val->locationId(), "this expression is not a comptime constant.", 0 );
                context.env()->storeValue(
                    localIdentity, ANYTERM( _ ), ValueToEIR( PoisonValue() ) );
                return true;
            }

            context.env()->storeValue( localIdentity, ANYTERM( _ ), ValueToEIR( *val ) );
            return true;
        };

        RegisterRule( e, "using"_sid, Rule( handleUsing ) );
    }
} // namespace goose::builtins

        auto handleWhile = []( Parser& p, LocationId locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();
            auto cfg = GetCFG( p.context() );

            if( p.isInParenExpr() || !cfg || !IsBranchingAllowed( p.context() ) )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "the while statement is not allowed here.", 0 );
                return false;
            }

            auto pPrecBB = cfg->currentBB();

            if( !pPrecBB || pPrecBB->terminator() )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    locationId, "unreachable code.", 0 );
                cfg->poison();
            }

            // Create a scope for the entire while, so that any var declared
            // inside of the condition is alive and visible throughout the while.
            Scope s( p.context() );

            auto np = p.makeNestedParser();
            if( !np.parseExpression( precedence::IfStmt ) )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected an expression following the while statement.", 0 );
                return false;
            }

            auto condVal = np.popValue();
            if( !condVal )
            {
                dm.emitSyntaxErrorMessage(
                    locationId, "expected an expression following the while statement.", 0 );
                return false;
            }

            const auto& context = p.context();
            auto converted = ConvertValueToType( context, *condVal, GetValueType< bool >() );
            if( holds_alternative< ValUnifyError >( converted ) )
            {
                switch( get< ValUnifyError >( converted ) )
                {
                    // If the condition is invalid, bail out and mark the current
                    // diagnostics context as bust to avoid spamming cascading errors.
                    case ValUnifyError::NoSolution:
                        dm.emitSyntaxErrorMessage( condVal->locationId(),
                            "the while condition can't be converted to a bool." );
                        break;

                    case ValUnifyError::Ambiguous:
                        dm.emitSyntaxErrorMessage(
                            condVal->locationId(), "ambiguous while condition bool conversion." );
                        break;
                }

                return false;
            }

            if( get< Value >( converted ).isPoison() )
                PoisonBuilder( p.context() );

            // The condition may have emitted additional basic blocks, so get the current block
            // again.
            pPrecBB = cfg->currentBB();

            auto pHeaderBB = cfg->createBB();

            // Set the loop header's location to a span including the while keyword and the
            // condition
            pHeaderBB->setLocationId(
                Location::CreateSpanningLocation( locationId, condVal->locationId() ) );

            BreakableScopeGuard bsg( p.context() );
            ContinuableScopeGuard csg( p.context() );

            auto pBodyBB = ParseSubStatement( p, precedence::IfStmt );
            if( !pBodyBB )
            {
                dm.emitSyntaxErrorMessage( p.resolver()->currentLocation(),
                    "expected a statement after the while condition.", 0 );
                return false;
            }

            if( !pPrecBB )
                return true;

            // Retrieve the final block of the loop body, if any

            auto breakLevel = GetBreakableScopeLevels( p.context() );
            auto continueLevel = GetContinuableScopeLevels( p.context() );

            // 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->append( get< Value >( converted ) );
            pHeaderBB->setTerminator( cir::CondBranch( pBodyBB, pSuccBB ) );


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

        RegisterRule( e, "while"_sid, Rule( handleWhile ) );
    }
} // namespace goose::builtins

        DefineConstant( e, "type"_sid, TypeType() );
        DefineConstant( e, "void"_sid, GetValueType< void >() );
        DefineConstant( e, "bool"_sid, GetValueType< bool >() );
        DefineConstant( e, "ct_int"_sid, GetValueType< BigInt >() );
        DefineConstant( e, "ct_char"_sid, GetValueType< char32_t >() );
        DefineConstant( e, "ct_string"_sid, GetValueType< string >() );

        RegisterBuiltinFunc< Eager< Value >( Value ) >( e, "ct_sequence"_sid,
            []( const Value& containedType )

            { return ToValue( SequenceType( ValueToEIR( containedType ) ) ); } );


        // bool literals
        DefineConstant( e, "true"_sid, ValueToEIR( ToValue( true ) ) );
        DefineConstant( e, "false"_sid, ValueToEIR( ToValue( false ) ) );

        // _ and var are both aliases for an anonymous tvar ($_)
        DefineConstant( e, "_"_sid, ValueToEIR( ToValue( TVar( "_"_sid ) ) ) );

    bool IsSequenceType( const Value& v )
    {
        if( !v.isConstant() )
            return false;

        auto result = Decompose( v.val(),

            Vec( Lit( "ct_type"_sid ), SubTerm(), Val< void* >(), Lit( "sequence"_sid ),
                SubTerm() ) );






        return !!result;
    }

    Term GetSequenceSubType( const Value& v )
    {
        auto result = Decompose( v.val(),

            Vec( Lit( "ct_type"_sid ), SubTerm(), Val< void* >(), Lit( "sequence"_sid ),
                SubTerm() ) );






        auto&& [_, __, type] = *result;
        return type;
    }

} // namespace goose::builtins

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

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

    // identifier (StringId)
    const Term& Bridge< StringId >::Type()
    {
        static auto type =
            ValueToEIR( Value( TypeType(), MkStdType( TSID( ct_type ), TSID( identifier ) ) ) );
        return type;
    }

    Value Bridge< StringId >::ToValue( StringId x )
    {
        return Value( Type(), TERM( x ) );
    }

        return *pint;
    }

    // bool
    const Term& Bridge< bool >::Type()
    {
        static auto type =
            ValueToEIR( Value( TypeType(), MkStdType( TSID( rt_type ), TSID( bool ) ) ) );
        return type;
    }

    Value Bridge< bool >::ToValue( bool x )
    {
        return Value( Type(), TERM( x ? 1U : 0U ) );
    }

        return *pint;
    }

    // Integers
    const Term& Bridge< BigInt >::Type()
    {
        static auto type =
            ValueToEIR( Value( TypeType(), MkStdType( TSID( ct_type ), TSID( ct_int ) ) ) );
        return type;
    }

    const BigInt* Bridge< BigInt >::FromValue( const Value& v )
    {
        if( v.type() != Type() )
            return nullptr;

        return get_if< BigInt >( &v.val() );
    }

    // char
    const Term& Bridge< char32_t >::Type()
    {
        static auto type =
            ValueToEIR( Value( TypeType(), MkStdType( TSID( ct_type ), TSID( ct_char ) ) ) );
        return type;
    }

    Value Bridge< char32_t >::ToValue( char32_t x )
    {
        return Value( Type(), TERM( x ) );
    }

    optional< char32_t > Bridge< char32_t >::FromValue( const Value& v )
    {
        if( v.type() != Type() )
            return nullopt;

        return get< uint64_t >( v.val() );
    }

    // strings
    const Term& Bridge< string >::Type()
    {
        static auto type =
            ValueToEIR( Value( TypeType(), MkStdType( TSID( ct_type ), TSID( ct_string ) ) ) );
        return type;
    }

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

    const string* Bridge< string >::FromValue( const Value& v )
    {
        if( !v.isConstant() || v.type() != Type() )
            return nullptr;

        return get_if< string >( &v.val() );
    }

    // sequences
    Value Bridge< SequenceType >::ToValue( const SequenceType& st )
    {
        return Value( Type(), MkStdType( TSID( ct_type ), TSID( sequence ), st.m_containedType ) );

    }

    optional< SequenceType > Bridge< SequenceType >::FromValue( const Value& v )
    {
        auto result = Decompose( v.val(),

            Vec( Lit( "ct_type"_sid ), SubTerm(), Val< void* >(), Lit( "sequence"_sid ),
                SubTerm() ) );






        if( !result )
            return nullopt;

        auto&& [predicates, cgType, containedType] = *result;
        return SequenceType( containedType );
    }

    // Generic values
    const Term& Bridge< Value >::Type()
    {
        // This is a trick to get a generic signature for this type when creating a builtin
        // function. This way we can define a builtin function that take any value of any type as
        // is, without conversion.
        static auto type = HOLE( "_"_sid, "tvar"_sid );
        return type;
    }
} // namespace goose::eir

#ifndef GOOSE_BUILTINS_TYPES_BASIC_H
#define GOOSE_BUILTINS_TYPES_BASIC_H

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

    struct SequenceType
    {
        template< typename T >
        SequenceType( T&& containedType ) :
            m_containedType( forward< T >( containedType ) )

        {
        }

        Term m_containedType;
    };

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

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

    template< typename T > struct PatternValueTypeOf

    {
        static const Term& GetPattern()
        {
            static auto pat = GetValueType< T >();
            return pat;
        }
    };


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

    extern bool IsSequenceType( const Value& v );
    extern Term GetSequenceSubType( const Value& v );
} // namespace goose::builtins

namespace goose::eir
{

    template<> struct Bridge< void >
    {
        static const Term& Type();
        static const Value& ToValue();
    };


    template<> struct Bridge< StringId >
    {
        static const Term& Type();
        static Value ToValue( StringId x );
        static optional< StringId > FromValue( const Value& v );
    };


    template<> struct Bridge< bool >
    {
        static const Term& Type();
        static Value ToValue( bool x );
        static optional< bool > FromValue( const Value& v );
    };


    template<> struct Bridge< BigInt >
    {
        static const Term& Type();

        template< typename T > static Value ToValue( T&& x )

        {
            return Value( Type(), TERM( BigInt( forward< T >( x ) ) ) );
        }

        static const BigInt* FromValue( const Value& v );
    };


    template<> struct Bridge< char32_t >
    {
        static const Term& Type();
        static Value ToValue( char32_t x );
        static optional< char32_t > FromValue( const Value& v );
    };


    template<> struct Bridge< string >
    {
        static const Term& Type();
        static Value ToValue( const string& x );
        static const string* FromValue( const Value& v );
    };


    template<> struct Bridge< builtins::SequenceType >
    {
        static const Term& Type() { return TypeType(); }

        static Value ToValue( const builtins::SequenceType& st );
        static optional< builtins::SequenceType > FromValue( const Value& v );
    };

    template< typename T > struct Bridge< Sequence< T > >

    {
        static const Term& Type()
        {
            static auto type =
                ValueToEIR( goose::eir::ToValue( builtins::SequenceType{ GetValueType< T >() } ) );
            return type;
        }

        template< typename S > static Value ToValue( S&& s )

        {
            return Value( Type(), make_shared< Sequence< T > >( forward< S >( s ) ) );
        }

        static optional< Sequence< T > > FromValue( const Value& v )
        {
            auto result = Decompose( v.val(), Val< ptr< void > >() );



            if( !result )
                return nullopt;

            return *static_pointer_cast< Sequence< T > >( result->get() );
        }
    };


    template<> struct Bridge< Value >
    {
        static const Term& Type();

        static const Value& ToValue( const Value& v ) { return v; }

        static const Value* FromValue( const Value& v ) { return &v; }
    };
} // namespace goose::eir


#endif

#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 =
            ValueToEIR( Value( TypeType(), VEC( TSID( ct_type ), TSID( constrainedfunc ) ) ) );
        return type;
    }

    Value Bridge< builtins::ConstrainedFunc >::ToValue( const builtins::ConstrainedFunc& cf )
    {
        return Value( Type(),

            VEC( Quote( cf.constraintPat() ), TERM( static_pointer_cast< void >( cf.invRule() ) ),
                ValueToEIR( cf.func() ) ) );
    }

    optional< builtins::ConstrainedFunc > Bridge< builtins::ConstrainedFunc >::FromValue(
        const Value& v )
    {
        if( !IsConstrainedFunc( v ) )
            return nullopt;

        auto result = Decompose( v.val(),

            Vec( SubTerm(), // constraint pattern
                Val< ptr< void > >(), // pInvRule
                SubTerm() // func
                ) );

        if( !result )
            return nullopt;

        auto&& [constraintPat, pInvRule, func] = *result;
        return builtins::ConstrainedFunc( *Unquote( constraintPat ),

            static_pointer_cast< InvocationRule >( pInvRule ), *EIRToValue( func ) );

    }

} // namespace goose::eir

#ifndef GOOSE_BUILTINS_TYPES_CONSTRAINEDFUNC_H
#define GOOSE_BUILTINS_TYPES_CONSTRAINEDFUNC_H

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

    class ConstrainedFunc
    {
      public:
        template< typename P, typename IR, typename F >
        ConstrainedFunc( P&& constraintPat, IR&& pInvRule, F&& func ) :
            m_constraintPat( forward< P >( constraintPat ) ),
            m_pInvRule( forward< IR >( pInvRule ) ),
            m_func( forward< F >( func ) )

        {
        }

        const auto& constraintPat() const { return m_constraintPat; }

        const auto& invRule() const { return m_pInvRule; }

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

      private:
        Term m_constraintPat;
        ptr< InvocationRule > m_pInvRule;
        Value m_func;
    };

    extern bool IsConstrainedFunc( const Value& tcc );

} // namespace goose::builtins

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 );
    };
} // namespace goose::eir

#endif

#include "builtins/builtins.h"

using namespace goose::sema;

namespace goose::builtins
{
    class ConstrainedFuncInvocationRule : public InvocationRule
    {
      public:
        Value resolveInvocation(
            Context& c, LocationId loc, const Value& callee, const Term& args ) const final
        {
            auto callPat = PrependToVectorTerm( args, HOLE( "_"_sid, "fwd"_sid ) );

            // Unify with the constraint pattern. We only care that there is at least one
            // solution, and if so, we defer the actual call resolution to the contained
            // function.
            auto cfunc = FromValue< ConstrainedFunc >( callee );
            assert( cfunc );

            TypeCheckingContext tcc( c );
            for( auto&& [s, tcc] : TypeCheck( cfunc->constraintPat(), callPat, tcc ) )

                if( Postprocess( s, tcc ) )
                    return cfunc->invRule()->resolveInvocation( c, loc, cfunc->func(), args );


            // TODO display details
            DiagnosticsManager::GetInstance().emitErrorMessage(
                loc, "function arguments mismatch." );
            return PoisonValue();
        }
    };

    void SetupConstrainedFuncInvocationRule( Env& e )
    {
        e.invocationRuleSet()->addRule(

            ValueToEIR( Value( GetValueType< ConstrainedFunc >(), ANYTERM( _ ) ) ),

            make_shared< ConstrainedFuncInvocationRule >() );
    }

} // namespace goose::builtins

    {
        // func type param / constrainedfunc arg
        e.typeCheckingRuleSet()->addTypeCheckingRule(

            ParamPat( FuncTypePattern() ),

            ValueToEIR( ValuePattern(

                TSID( constant ), GetValueType< builtins::ConstrainedFunc >(), ANYTERM( _ ) ) ),


            []( const Term& lhs, const Term& rhs, const TypeCheckingContext& tcc ) -> TCGen
            {
                auto ldecomp = Decompose( lhs,

                    Vec( Lit( "value"_sid ), SubTerm(), SubTerm(), SubTerm(),



                        Val< LocationId >() ) );


                assert( ldecomp );

                auto&& [sort, type, val, locId] = *ldecomp;
                auto callPat = BuildCallPatternFromFuncType( *EIRToValue( type ) );

                auto rhsVal = *EIRToValue( rhs );
                auto cfunc = FromValue< ConstrainedFunc >( rhsVal );
                assert( cfunc );

                auto localC = tcc;
                for( auto&& [s, tcc] : TypeCheck( callPat, cfunc->constraintPat(), localC ) )
                {
                    if( Postprocess( s, tcc ) )
                    {
                        auto func = ValueToEIR( cfunc->func() );
                        co_yield TypeCheck( lhs, func, tcc );
                        co_return;
                    }
                }
            } );

        // tfunc type param / constrainedfunc arg
        e.typeCheckingRuleSet()->addTypeCheckingRule(

            ValueToEIR( ValuePattern(

                ANYTERM( _ ), TFuncTypeSigPattern( ANYTERM( _ ), ANYTERM( _ ) ), ANYTERM( _ ) ) ),


            ValueToEIR( ValuePattern(

                TSID( constant ), GetValueType< builtins::ConstrainedFunc >(), ANYTERM( _ ) ) ),


            []( const Term& lhs, const Term& rhs, const TypeCheckingContext& tcc ) -> TCGen
            {
                auto ldecomp = Decompose( lhs,

                    Vec( Lit( "value"_sid ), SubTerm(), SubTerm(), SubTerm(),



                        Val< LocationId >() ) );


                assert( ldecomp );

                auto&& [sort, type, val, locId] = *ldecomp;
                auto [tfType, _] = DecomposeTFTSig( type );
                auto callPat = BuildArgPatternFromTFuncType( tcc.context(), *EIRToValue( tfType ) );
                assert( callPat );

                auto rhsVal = *EIRToValue( rhs );
                auto cfunc = FromValue< ConstrainedFunc >( rhsVal );
                assert( cfunc );

                auto localC = tcc;
                for( auto&& [s, tcc] : TypeCheck( *callPat, cfunc->constraintPat(), localC ) )
                {
                    if( Postprocess( s, tcc ) )
                    {
                        auto func = ValueToEIR( cfunc->func() );
                        co_yield TypeCheck( lhs, func, tcc );
                        co_return;
                    }
                }
            } );

        // constrainedfunc param / any arg: just yield the constrained func.

        //
        // This is because when we monomorphize a function that takes a polymorphic function type,

        // we turn the later into a compile time constant. So it isn't really a parameter in the
        // resulting monomorphic function, and we just want to ignore whatever parameter is being
        // passed there
        e.typeCheckingRuleSet()->addTypeCheckingRule(

            ValueToEIR( ValuePattern(

                TSID( constant ), GetValueType< builtins::ConstrainedFunc >(), ANYTERM( _ ) ) ),


            ValueToEIR( ValuePattern( ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ) ) ),




            []( const Term& lhs, const Term& rhs, const TypeCheckingContext& tcc ) -> TCGen

            { co_yield { lhs, tcc }; } );

    }

} // namespace goose::builtins

{
    void SetupConvert( Env& e )
    {
        using FwdValue = CustomPattern< Value, ForwarderPattern >;

        // Default implementation of ConvertFuncParam():
        // return the param as is.
        RegisterBuiltinFunc< Intrinsic< Value( FwdValue ) > >(
            e, e.extConvertFuncParam(), []( const Context& c, const Value& p ) { return p; } );




        // Default implementation of ConvertFuncArgs():
        // return the args as is.
        // Use generic arguments so that the prelude can override it with a more specific
        // version that explicitely takes Vecs, while still letting us have this default
        // implementation for pre-prelude stuff to be able to work.
        RegisterBuiltinFunc< Intrinsic< Value( Value, Value ) > >( e, e.extConvertFuncArgs(),
            []( const Context& c, const Value& a, const Value& p ) { return a; } );



    }

} // namespace goose::builtins

#include "builtins/builtins.h"

using namespace goose::builtins;

namespace goose::builtins
{
    bool IsDecl( const Value& d )
    {
        auto typeVal = EIRToValue( d.type() );
        if( !typeVal )
            return false;

        auto result = Decompose( typeVal->val(), Vec( Lit( "decl"_sid ), SubTerm() ) );






        return !!result;
    }

    const Term& Decl::Pattern::GetPattern()
    {
        static auto pattern =
            ValueToEIR( Value( TypeType(), VEC( TSID( decl ), HOLE( "_"_sid ) ) ) );

        return pattern;
    }

    const Term& DeclWithInit::Pattern::GetPattern()
    {
        static auto pattern =
            ValueToEIR( Value( TypeType(), VEC( TSID( decl_with_init ), HOLE( "_"_sid ) ) ) );

        return pattern;
    }
} // namespace goose::builtins

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

    Value Bridge< Decl >::ToValue( const Decl& d )
    {
        return Value( Type( d.type() ), TERM( d.name() ) );
    }

    optional< Decl > Bridge< Decl >::FromValue( const Value& v )
    {
        auto typeVal = EIRToValue( v.type() );
        auto result = Decompose( typeVal->val(), Vec( Lit( "decl"_sid ), SubTerm() ) );






        if( !result )
            return nullopt;

        auto&& [type] = *result;

        const auto& name = get< StringId >( v.val() );

    {
        return Value( Type( d.type() ), VEC( d.name(), ValueToEIR( d.init() ), d.declLoc() ) );
    }

    optional< DeclWithInit > Bridge< DeclWithInit >::FromValue( const Value& v )
    {
        auto typeVal = EIRToValue( v.type() );
        auto result = Decompose( typeVal->val(), Vec( Lit( "decl_with_init"_sid ), SubTerm() ) );






        if( !result )
            return nullopt;

        auto result2 =



            Decompose( v.val(), Vec( Val< StringId >(), SubTerm(), Val< LocationId >() ) );



        if( !result2 )
            return nullopt;

        auto&& [type] = *result;
        auto&& [name, init, declLoc] = *result2;

        return DeclWithInit( move( type ), name, *EIRToValue( init ), declLoc );
    }
} // namespace goose::eir

#ifndef GOOSE_BUILTINS_TYPES_DECL_H
#define GOOSE_BUILTINS_TYPES_DECL_H

namespace goose::builtins
{
    class Decl
    {
      public:
        template< typename T >
        Decl( T&& type, StringId name ) :
            m_type( forward< T >( type ) ),
            m_name( name )

        {
        }

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

        const auto& name() const { return m_name; }

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

      private:
        Term m_type;
        StringId m_name;
    };

    class DeclWithInit
    {
      public:
        template< typename T, typename V >
        DeclWithInit( T&& type, StringId name, V&& init, LocationId declLoc ) :
            m_init( forward< V >( init ) ),
            m_type( forward< T >( type ) ),
            m_name( name ),
            m_declLoc( declLoc )

        {
        }

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

        const auto& name() const { return m_name; }

        const auto& init() const { return m_init; }

        auto declLoc() const { return m_declLoc; }

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

      private:
        Value m_init;
        Term m_type;
        StringId m_name;
        LocationId m_declLoc;
    };

    extern bool IsDecl( const Value& d );

} // namespace goose::builtins

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


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

#endif

#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.
        RegisterBuiltinFunc< Intrinsic< void( Value ) > >(
            e, e.extDestroyValue(), []( auto&& c, const Value& v ) {} );
    }
} // namespace goose::builtins

#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().
        // The cir of computed values with side effects is appended to the current BB of the current
        // parser, all other values are discarded and destroyed.
        RegisterBuiltinFunc< Intrinsic< void( Value, Value ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                if( v.isConstant() || !DoesInstrSeqHaveSideEffects( *v.cir() ) )
                {
                    DestroyLiveValue( c, v );
                    return;
                }

                auto cfg = GetCFG( c );
                if( !cfg )
                    return;

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

        // DropValue for identifier: emit an "undefined identifier" error.
        RegisterBuiltinFunc< Intrinsic< void( Value, StringId ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                    v.locationId(), "undefined identifier.", 0 );
                return PoisonValue();
            } );

        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
        // more specific such as "can't default-initialize a variable of type XXX"
        RegisterBuiltinFunc< Intrinsic< void( Value, AnyDeclType ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                if( !GetCFG( c ) )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                        0, "variable declarations are not allowed here." );
                    return PoisonValue();
                }

                auto decl = *FromValue< Decl >( v );
                return DeclareLocalVar( c, decl.type(), decl.name(), nullopt, v.locationId() );
            } );

        using AnyDeclWithInitType = CustomPattern< DeclWithInit, DeclWithInit::Pattern >;

        // DropValue for DeclWithInit: declare a local variable.
        RegisterBuiltinFunc< Intrinsic< void( Value, AnyDeclWithInitType ) > >( e, e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                if( !GetCFG( c ) )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                        0, "variable declarations are not allowed here." );
                    return PoisonValue();
                }

                auto decl = *FromValue< DeclWithInit >( v );
                return DeclareLocalVar( c, decl.type(), decl.name(), decl.init(), decl.declLoc() );
            } );

        using AnyTNamedDeclWithInitType =
            CustomPattern< TNamedDeclWithInit, TNamedDeclWithInit::Pattern >;

        // DropValue for TNamedDeclWithInit: declare a local variable with local type inference.
        RegisterBuiltinFunc< Intrinsic< void( Value, AnyTNamedDeclWithInitType ) > >( e,
            e.extDropValue(),
            []( const Context& c, const Value& b, const Value& v )
            {
                if( !GetCFG( c ) )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                        0, "variable declarations are not allowed here." );
                    return PoisonValue();
                }

                auto decl = *FromValue< TNamedDeclWithInit >( v );
                return DeclareLocalVarWithTypeInference(
                    c, decl.type(), decl.name(), decl.init(), decl.declLoc() );
            } );
    }

} // namespace goose::builtins

#include "builtins/builtins.h"

namespace goose::builtins
{
    bool IsBuiltinFunc( const Value& func )
    {
        auto funcType = EIRToValue( func.type() );
        assert( funcType );

        auto decomp = Decompose( funcType->val(),


            Vec( Lit( "func"_sid ), Lit( "builtin"_sid ),
                SubTerm(), // return type
                SubTerm(), // param types
                SubTerm(), // verif infos
                SubTerm() // Lowering infos
                ) );


        if( decomp )
            return true;

        decomp = Decompose( funcType->val(),


            Vec( Lit( "func"_sid ), Lit( "builtin_eager"_sid ),
                SubTerm(), // return type
                SubTerm(), // param types
                SubTerm(), // verif infos
                SubTerm() // Lowering infos
                ) );


        return !!decomp;
    }

    bool IsNonEagerBuiltinFunc( const Value& func )
    {
        auto funcType = EIRToValue( func.type() );
        assert( funcType );

        auto decomp = Decompose( funcType->val(),


            Vec( Lit( "func"_sid ), Lit( "builtin"_sid ),
                SubTerm(), // return type
                SubTerm(), // param types
                SubTerm(), // verif infos
                SubTerm() // Lowering infos
                ) );


        return !!decomp;
    }

    bool IsEagerBuiltinFunc( const Value& func )
    {
        auto funcType = EIRToValue( func.type() );
        assert( funcType );

        auto decomp = Decompose( funcType->val(),


            Vec( Lit( "func"_sid ), Lit( "builtin_eager"_sid ),
                SubTerm(), // return type
                SubTerm(), // param types
                SubTerm(), // verif infos
                SubTerm() // Lowering infos
                ) );


        return !!decomp;
    }

    const Term& BFuncTypePattern()
    {
        static auto BfuncTypePat = ValueToEIR( Value( TypeType(),
            VEC( TSID( func ), TSID( builtin ), ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ) ) ) );
        return BfuncTypePat;
    }

    const Term& EagerBFuncTypePattern()
    {
        static auto EagerBfuncTypePat = ValueToEIR( Value( TypeType(),
            VEC(
                TSID( func ), TSID( builtin_eager ), ANYTERM( _ ), ANYTERM( _ ), ANYTERM( _ ) ) ) );
        return EagerBfuncTypePat;
    }

    const BuiltinFuncWrapper& GetBuiltinFuncWrapper( const Value& func )
    {
        assert( IsBuiltinFunc( func ) );

        const auto& p = get< ptr< void > >( func.val() );
        return *static_pointer_cast< BuiltinFuncWrapper >( p );
    }
} // namespace goose::builtins

#ifndef GOOSE_BUILTINS_TYPES_BFUNC_H
#define GOOSE_BUILTINS_TYPES_BFUNC_H

namespace goose::builtins
{
    class FuncVerificationInfos;

    using BuiltinFuncWrapper = function< Value( const Term& argVec ) >;

    template< typename FT, typename F >
    void RegisterBuiltinFunc( Env& env, StringId name, F&& func, CURRENT_LOC );

    template< typename FT, typename F >
    void RegisterBuiltinFunc( Env& env, ptr< OverloadSet > pOvlSet, F&& func, CURRENT_LOC );

    extern bool IsBuiltinFunc( const Value& func );
    extern bool IsEagerBuiltinFunc( const Value& func );
    extern bool IsNonEagerBuiltinFunc( const Value& func );

    extern const Term& BFuncTypePattern();
    extern const Term& EagerBFuncTypePattern();

    extern const BuiltinFuncWrapper& GetBuiltinFuncWrapper( const Value& func );

    // If the return type of a builtin function is wrapped with this,
    // the function will be eargerly executed (if possible) if it is invoked
    // by the compiled code.
    template< typename T > struct Eager

    {
    };

    template< typename T > struct is_eager : public false_type

    {
    };


    template< typename T > struct is_eager< Eager< T > > : public true_type
    {
    };


    template< typename T > constexpr bool is_eager_v = is_eager< T >::value;

    template< typename T > struct remove_eager

    {
        using type = T;
    };

    template< typename T > struct remove_eager< Eager< T > >

    {
        using type = T;
    };


    template< typename T > using remove_eager_t = typename remove_eager< T >::type;

    // This wrapper provides a way to use a custom pattern
    // to match the type.
    template< typename T, typename PP > struct CustomPattern

    {
    };

    // This wrapper provides a way to use a custom pattern
    // to match the type, but only for a constant value.
    template< typename T, typename PP > struct CustomConstantPattern

    {
    };

    // This wrapper defines a builtin function param that takes
    // a type constant representing the given type.
    template< typename T > struct TypeParam


    {
    };

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

    {
    };

    // Wrapper to define a constant valued parameter
    template< typename T, T val > struct ConstantParam

    {
    };
} // namespace goose::builtins


namespace goose::eir
{
    template< typename R, typename... T > struct Bridge< R( T... ) >

    {
        using functype = function< R( T... ) >;

        static const Term& Type();




        template< typename F > static Value ToValue( F&& func );

        template< typename F > static auto WrapFunc( F&& func );
    };

    template< typename T, typename PP > struct Bridge< builtins::CustomPattern< T, PP > >

    {
        static auto Type() { 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 ); }



    };

} // namespace goose::eir

#endif

        return RegisterBuiltinFunc< FT >( env, pOvlSet, forward< F >( func ), sloc );
    }

    template< typename FT, typename F >
    void RegisterBuiltinFunc( Env& env, ptr< OverloadSet > pOvlSet, F&& func, source_location sloc )
    {
        auto loc = Location::Create( sloc );
        if( !pOvlSet->add( env, ToValue< FT >( forward< F >( func ) ).setLocationId( loc ),
                GetInvocationRule< FT >() ) )
            G_ERROR( "duplicate overload registered for builtin func." );
    }

} // namespace goose::builtins

namespace goose::eir
{
    template< typename T > struct BuildBuiltinFuncParamPat

    {
        static const auto& GetParamPattern()
        {
            static auto pat = builtins::ParamPat( GetValueType< T >() );
            return pat;
        }
    };

        static const auto& GetParamPattern()
        {
            static auto pat = ValueToEIR( Value( PP::GetPattern(), HOLE( "_"_sid ) ) );
            return pat;
        }
    };


    template< typename T > struct BuildBuiltinFuncParamPat< builtins::TypeParam< T > >
    {
        static const auto& GetParamPattern()
        {
            static auto pat = GetValueType< T >();
            return pat;
        }
    };

        static const auto& GetParamPattern()
        {
            static auto pat = ValueToEIR( ToValue( val ) );
            return pat;
        }
    };

    template< typename... T > Term BuildBuiltinFuncParamTypeList()

    {
        return VEC( BuildBuiltinFuncParamPat< T >::GetParamPattern()... );
    }

    template< typename R, typename... T > const Term& Bridge< R( T... ) >::Type()

    {
        static auto type = ValueToEIR( Value( TypeType(),
            VEC( TSID( func ), builtins::is_eager_v< R > ? TSID( builtin_eager ) : TSID( builtin ),
                GetValueType< builtins::remove_eager_t< R > >(),
                sema::Quote( BuildBuiltinFuncParamTypeList< T... >() ), ptr< void >(),
                ptr< void >() ) ) );

        return type;
    }

    template< typename R, typename... T >
    template< typename F >
    Value Bridge< R( T... ) >::ToValue( F&& func )
    {
        ptr< void > pWrapper =
            make_shared< builtins::BuiltinFuncWrapper >( WrapFunc( forward< F >( func ) ) );
        return Value( Type(), TERM( move( pWrapper ) ) );
    }

    template< typename T > struct StripCustomPattern

    {
        using type = T;
    };

    template< typename T, typename PP >
    struct StripCustomPattern< builtins::CustomPattern< T, PP > >
    {
        using type = T;
    };

    template< typename T, typename PP >
    struct StripCustomPattern< builtins::CustomConstantPattern< T, PP > >
    {
        using type = T;
    };


    template< typename T > struct StripCustomPattern< builtins::TypeParam< T > >
    {
        using type = Value;
    };

    template< typename T, typename PP >
    struct StripCustomPattern< builtins::TypePatternParam< T, PP > >
    {
        using type = T;
    };


    template< typename T, T val > struct StripCustomPattern< builtins::ConstantParam< T, val > >
    {
        using type = T;
    };

    template< typename R, typename... T >
    template< typename F >
    auto Bridge< R( T... ) >::WrapFunc( F&& func )
    {
        return [func]( const Term& argVec ) -> Value
        {
            auto params =
                Bridge< tuple< typename StripCustomPattern< T >::type... > >::FromVectorTerm(
                    argVec );
            if( !params )
                return PoisonValue();

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


#endif

#include "builtins/builtins.h"

namespace goose::builtins
{
    bool IsBuiltinIntrinsicFunc( const Value& func )
    {
        auto funcType = EIRToValue( func.type() );
        assert( funcType );

        auto decomp = Decompose( funcType->val(),


            Vec( Lit( "func"_sid ), Lit( "intrinsic_builtin"_sid ),
                SubTerm(), // return type
                SubTerm(), // param types
                SubTerm(), // verif infos
                SubTerm() // Lowering infos
                ) );


        return !!decomp;
    }

    const BuiltinIntrinsicFuncWrapper& GetBuiltinIntrinsicFuncWrapper( const Value& func )
    {
        assert( IsBuiltinIntrinsicFunc( func ) );

        const auto& p = get< ptr< void > >( func.val() );
        return *static_pointer_cast< BuiltinIntrinsicFuncWrapper >( p );
    }
} // namespace goose::builtins

#ifndef GOOSE_BUILTINS_TYPES_FUNC_BINTRINSIC_H
#define GOOSE_BUILTINS_TYPES_FUNC_BINTRINSIC_H

namespace goose::builtins
{
    extern bool IsBuiltinIntrinsicFunc( const Value& func );

    // A builtin intrinsic is defined on the C++ side by creating a builtin func
    // whose type is wrapped in the Intrinsic type.
    // The provided function should take and return only Values.
    template< typename F > struct Intrinsic

    {
    };

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

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 );

        template< typename F >
        static Value ToValue(
            F&& func, const ptr< builtins::FuncVerificationInfos >& fvi = nullptr );

        template< typename F > static auto WrapFunc( F&& func );

    };
} // namespace goose::eir

#endif

#ifndef GOOSE_BUILTINS_TYPES_FUNC_BINTRINSIC_INL
#define GOOSE_BUILTINS_TYPES_FUNC_BINTRINSIC_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 = ValueToEIR( Value( TypeType(),
            VEC( TSID( func ), TSID( intrinsic_builtin ), GetValueType< R >(),

                sema::Quote( BuildBuiltinFuncParamTypeList< T... >() ),
                static_pointer_cast< void >( fvi ), ptr< void >() ) ) );

        return type;
    }

    template< typename R, typename... T >
    template< typename F >
    Value Bridge< builtins::Intrinsic< R( T... ) > >::ToValue(
        F&& func, const ptr< builtins::FuncVerificationInfos >& fvi )
    {
        ptr< void > pWrapper = make_shared< builtins::BuiltinIntrinsicFuncWrapper >(
            WrapFunc( forward< F >( func ) ) );
        return Value( Type( fvi ), TERM( move( pWrapper ) ) );
    }

    template< typename T > using AsValue = Value;

    template< typename R, typename... T >
    template< typename F >
    auto Bridge< builtins::Intrinsic< R( T... ) > >::WrapFunc( F&& func )
    {
        return [func]( sema::Context& c, const Term& argVec ) -> Value
        {
            auto params = Bridge< tuple< AsValue< T >... > >::FromVectorTerm( argVec );
            assert( params );

            if constexpr( is_void_v< R > )
            {
                apply( func, tuple_cat( tuple< sema::Context& >( c ), *params ) );
                return Value( GetValueType< void >(), 0U );
            }
            else
                return apply( func, tuple_cat( make_tuple( c ), *params ) );
        };
    }
} // namespace goose::eir

#endif

#include "builtins/builtins.h"

namespace goose::builtins
{
    Term BuildParamPat( const Context& c, Value type, LocationId loc )
    {
        if( !type.isType() )
            type = ToType( c, type );

        return ValueToEIR( ValuePattern( TSID( param ), ValueToEIR( type ), HOLE( "_"_sid ) )
                               .setLocationId( loc ) );
    }

    optional< FuncType > BuildFuncType(
        const Context& c, const Value& returnType, const Value& params )
    {
        auto verificationIdentity = VEC( Env::NewUniqueId() );
        c.env()->addVisibilityRule( c.identity(), verificationIdentity );

        auto paramCount = TupleSize( params );

        auto tv = make_shared< Vector >();
        tv->reserve( paramCount );

        FuncLoweringInfos fli;
        fli.loweredParamTypes.reserve( paramCount );

        bool failed = false;

        uint32_t varId = 0;
        ForEachInTuple( params,
            [&]( auto&& param )
            {
                if( IsDecl( param ) )
                {
                    auto decl = *FromValue< Decl >( param );
                    auto declType = *EIRToValue( decl.type() );
                    auto loweredDeclType = LowerType( c, declType );
                    if( !loweredDeclType )
                    {
                        failed = true;
                        return false;
                    }

                    // Handle parameter packs (open tuples)
                    if( IsOpenTuple( declType ) )
                    {
                        ForEachInTuples( declType, *loweredDeclType,
                            [&]( auto&& type, auto&& loweredType )
                            {
                                fli.loweredParamTypes.emplace_back( loweredType );
                                tv->append( BuildParamPat( c, type, param.locationId() ) );
                                return true;
                            } );

                        if( failed )
                            return false;
                    }
                    else
                    {
                        fli.loweredParamTypes.emplace_back( *loweredDeclType );
                        tv->append( BuildParamPat( c, declType, param.locationId() ) );
                    }

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

                    c.env()->storeValue( paramVerificationIdentity, ANYTERM( _ ),
                        ValueToEIR( BuildComputedValue( decl.type(),
                            cir::DataPathOf( varId++, param.locationId() ),
                            cir::Load( ValueToEIR( *loweredDeclType ), param.locationId() ) ) ) );
                }
                else if( param.isConstant() )
                    tv->append( ValueToEIR( param ) );

                return true;
            } );

        if( failed )
            return nullopt;

        auto rtType = ToType( c, returnType );

        auto loweredRTType = LowerType( c, rtType );
        if( !loweredRTType )
            return nullopt;

        fli.loweredReturnType = move( *loweredRTType );

        // 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 = ValueToEIR( rtType );
        if( rtTerm != GetValueType< void >() )
        {
            auto name = "@result"_sid;
            auto retValVerificationIdentity =
                AppendToVectorTerm( verificationIdentity, TERM( name ) );

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

        auto pVerifInfos = make_shared< FuncVerificationInfos >( move( verificationIdentity ) );
        return FuncType(
            rtTerm, tv, move( pVerifInfos ), make_shared< FuncLoweringInfos >( move( fli ) ) );
    }

    Func BuildExternalFunc( FuncType funcType, const string& symbol, bool varArg )
    {
        if( varArg )
            funcType.setKind( FuncType::Kind::VarArg );
        return Func( funcType, symbol );
    }

    optional< Func > BuildFunc( const Context& c, const Term& parentIdentity,
        const Term& funcIdentity, const Value& returnType, const Value& paramsDecl,
        const ptr< void >& unparsedBody, Context& out_bodyContext )
    {
        auto funcType = BuildFuncType( c, returnType, paramsDecl );
        if( !funcType )
            return nullopt;
        return BuildFunc(
            c, *funcType, parentIdentity, funcIdentity, paramsDecl, unparsedBody, out_bodyContext );
    }

    Func BuildFunc( const Context& c, const FuncType& funcType, const Term& parentIdentity,
        const Term& funcIdentity, const Value& paramsDecl, const ptr< void >& unparsedBody,
        Context& out_bodyContext )
    {
        // TODO: instead of a normal import rule from the parent scope, we should use
        // a custom visibility rule that deals with variables from the parent context
        // in a special way:
        // If the function body tries to access variables from the parent function,
        // we should invoke an overridable global function that can transform both the
        // variable object and the function type. This way, we can implement/customize