Goose  Check-in [9d81e31cfe]

                parse::Parser p( r );

                auto cfg = make_shared< llr::CFG >();
                p.setCFG( cfg );
                p.setCurrentBB( cfg->entryBB() );

                p.parseSequence();

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

                if( !r->eos() )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
                        r->getCurrentLocation(), "syntax error." );
                    return 0;
                }

                auto cfg = make_shared< llr::CFG >();
                p.setCFG( cfg );
                p.setCurrentBB( cfg->entryBB() );

                p.parseSequence();

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

                if( !r->eos() )
                {
                    pFuncLLR->setInvalid();
                    DiagnosticsManager::GetInstance().emitErrorMessage(
                        r->getCurrentLocation(), "syntax error." );
                    return ToValue( func ).setPoison();
                }

{
    void SetupIfStmt( Env& e )
    {
        auto handleIf = []( Parser& p, uint32_t locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();

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

            auto pPrecBB = p.currentBB();

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

                return false;
            }

            if( get< Value >( converted ).isPoison() )
                p.cfg()->poison();

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

{
    void SetupReturnStmt( Env& e )
    {
        auto handleReturn = []( Parser& p, uint32_t locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();

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

            const auto& context = p.resolver()->context();

                        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.
                p.emitTerminator( llr::Ret( PoisonValue() ) );
                p.cfg()->poison();
                return true;
            }

            p.emitTerminator( llr::Ret( get< Value >( converted ) ) );
            return true;
        };

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

{
    void SetupWhileStmt( Env& e )
    {
        auto handleWhile = []( Parser& p, uint32_t locationId, uint32_t prec )
        {
            auto& dm = DiagnosticsManager::GetInstance();

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

            auto pPrecBB = p.currentBB();

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

                return false;
            }

            if( get< Value >( converted ).isPoison() )
                p.cfg()->poison();

            auto pHeaderBB = p.cfg()->createBB();

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

    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

    {
        static auto pattern = ValueToIRExpr(
            Value( TypeType(), VEC( TSID( func ), MkHole( "llvmType"_sid ),
            MkHole( "_"_sid ), MkHole( "_"_sid ), MkHole( "_"_sid ) ) ) );

        return pattern;
    }

    bool IsExternalFunc( const Value& f )
    {
        if( !f.isConstant() )
            return false;

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

        return !!result;
    }

    bool IsFuncType( const Value& t )
    {
        auto result = Decompose( t.val(),
            Vec(
                Lit( "func"_sid ),
                Val< void* >(),

        auto cfg = make_shared< llr::CFG >();
        p.setCFG( cfg );
        p.setCurrentBB( cfg->entryBB() );

        bool success = p.parseBraceBlock();
        p.flushValue();

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

        private:
            Term m_domain;
            Term m_returnType;
            Term m_params;
            llvm::FunctionType* m_pllvmType = nullptr;
    };

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

    class Func
    {
        public:
            template< typename T, typename B >
            Func( T&& funcType, B&& toks, llr::Func* llr ) :

            auto wrapped = WrapWithPostprocFunc( rhs, [rhsVal]( const Term& t, const UnificationContext& uc )
                -> optional< Term >
            {
                DiagnosticsContext dc( 0, true );
                VerbosityContext vc( Verbosity::Normal, true );

                auto func = CompileFunc( uc.context(), rhsVal );
                if( func.isPoison() )
                    return nullopt;

                return ValueToIRExpr( func );
            } );

            co_yield { move( wrapped ), uc };
        } );

        // tfunc type param / func arg

                auto wrapped = WrapWithPostprocFunc( s, [rhsVal]( const Term& t, const UnificationContext& uc )
                    -> optional< Term >
                {
                    DiagnosticsContext dc( 0, true );
                    VerbosityContext vc( Verbosity::Normal, true );

                    auto func = CompileFunc( uc.context(), rhsVal );
                    if( func.isPoison() )
                        return nullopt;

                    return ValueToIRExpr( func );
                } );

                co_yield { move( wrapped ), uc };
            }
        } );
    }
}

                auto overload = ovl;
                auto wrapped = WrapWithPostprocFunc( s,
                    [overload,localNSId,rhsLocId]( const Term& t, UnificationContext& uc ) -> optional< Term >
                    {
                        auto localC = uc;
                        localC.setRHSNamespaceIndex( localNSId );
                        auto func = overload.pInvRule->prepareFunc( uc.context(), rhsLocId, *overload.callee, t, localC.flip() );

                        if( func.isPoison() )
                            return nullopt;

                        return ValueToIRExpr( move( func ) );
                    } );

                co_yield { move( wrapped ), uc };
            }

            uc.flip();

                auto overload = ovl;
                auto wrapped = WrapWithPostprocFunc( s,
                    [overload,localNSId,rhsLocId]( const Term& t, UnificationContext& uc ) -> optional< Term >
                    {
                        auto localC = uc;
                        localC.setRHSNamespaceIndex( localNSId );
                        auto func = overload.pInvRule->prepareFunc( uc.context(), rhsLocId, *overload.callee, t, localC.flip() );

                        if( func.isPoison() )
                            return nullopt;

                        return ValueToIRExpr( move( func ) );
                    } );

                co_yield { move( wrapped ), uc };
            }

            uc.flip();
            uc.setRHSNamespaceIndex( savedRHSNamespaceIndex );
        } );
    }
}

                } );

                instanceFunc = ToValue( func );

                // TODO: better description including the function's name
                DiagnosticsContext dc( callee.locationId(), "In the template function declared here.", false );

                instanceFunc = CompileFunc( c, instanceFunc );
                c.env()->storeValue( instanceIdentity, ANYTERM( _ ), ValueToIRExpr( instanceFunc ) );
                break;
            }

            case Env::Status::AmbiguousMatch:
                DiagnosticsManager::GetInstance().emitErrorMessage( callee.locationId(),
                    "unexpected ambiguous match when looking up a template function instance." );
                return PoisonValue();

                {
                    auto localC = uc;
                    localC.setRHSNamespaceIndex( localNSId );

                    DiagnosticsContext dc( rhsVal.locationId(), rhsVal.locationId() ?  "Instantiated here." : "", false );

                    auto ifunc = InstantiateTFunc( uc.context(), rhsVal, t, localC.flip() );

                    if( ifunc.isPoison() )
                        return nullopt;

                    return ValueToIRExpr( ifunc );
                } );

                co_yield { move( wrapped ), uc };
            }

            uc.setRHSNamespaceIndex( savedRHSNamespaceIndex );

                {
                    auto localC = uc;
                    localC.setRHSNamespaceIndex( localNSId );

                    DiagnosticsContext dc( rhsVal.locationId(), rhsVal.locationId() ?  "Instantiated here." : "", false );

                    auto ifunc = InstantiateTFunc( uc.context(), rhsVal, t, localC.flip() );

                    if( ifunc.isPoison() )
                        return nullopt;

                    return ValueToIRExpr( ifunc );
                } );

                co_yield { move( wrapped ), uc };
            }

            uc.setRHSNamespaceIndex( savedRHSNamespaceIndex );
        } );
    }
}

    Value Bridge< tuple< T... > >::ToValue( const tuple< T... >& x )
    {
        auto val = BuildTupleValue( x, index_sequence_for< T... >() );
        return Value( Type(), move( val ) );
    }

    template< typename TT, size_t... I >
    optional< TT > BuildTupleFromValueVec( const Vector& vec, index_sequence< I... > )
    {
        if constexpr( sizeof... ( I ) == 0 )
            return TT();
        else
        {
            auto values = make_tuple( ValueFromIRExpr( vec[I] )... );
            if( ( !get< I >( values ) || ... ) )
                return nullopt;

            auto items = make_tuple( FromValue< tuple_element_t< I, TT > >( *get< I >( values ) )... );
            if( ( !get< I >( items ) || ... ) )
                return nullopt;

            return TT( move( *get< I >( items ) )... );
        }
    }

    template< typename... T >
    optional< tuple< T... > > Bridge< tuple< T... > >::FromVectorTerm( const Term& v )
    {
        const auto& vec = *get< pvec >( v );
        return BuildTupleFromValueVec< tuple< T... > >( vec, index_sequence_for< T... >() );

    auto cfg = make_shared< llr::CFG >();
    p.setCFG( cfg );
    p.setCurrentBB( cfg->entryBB() );

    VerbosityContext vc( Verbosity::Normal, true );

    p.parseSequence();

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

    if( !r->eos() )
    {
        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage(
            r->getCurrentLocation(), "syntax error." );
        return 0;
    }

        // If we flush a context that had no location,
        // just print it as is.
        if( m_pendingContextFilename.empty() )
        {
            applyColor( m_pendingContextMessageColor );
            m_output << m_pendingContextMessage << '\n';
            applyColor( Colors::Reset );

            m_pendingContextFilename.clear();
            m_pendingContextMessage.clear();
            m_pendingContextMessageColor = nullptr;
            m_pendingCaret = false;
            m_pendingHighlightSpans.clear();
            return;

        if( !v.isConstant() )
        {
            const auto& llr = val.llr();
            if( !llr )
                return v.setPoison();

            VerbosityContext vc( Verbosity::Silent );
            execute::ExecutionBudgetGuard ebg;

            auto result = vm.execute( *llr );

            // Execution may fail: there are some cases when we can't really
            // be sure that eager evaluation is possible until we actually try.
            // In this case we forget about the eager evaluation and return the
            // value as is.
            if( !result || result->isPoison() )
                return v;

            ebg.commit();

            v = move( *result );
            v.setLocationId( val.locationId() );
        }

        return v;
    }

optional< Value > VM::execute( const ptr< CFG >& ic )
{
    return execute( *ic );
}

optional< Value > VM::execute( const llr::Call& call )
{
    if( !( ms_remainingBranchInstExecutions ) )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage( 0,
            "Execute: compilation time execution budget exceeded." );
        return PoisonValue();
    }

    --ms_remainingBranchInstExecutions;

    if( call.func().isPoison() )
        DiagnosticsManager::GetInstance().setCurrentVerbosityLevel( Verbosity::SilentLocally );

    auto func = Evaluate( call.func(), *this );
    if( func.isPoison() )
        return PoisonValue();

    if( !func.isConstant() )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage( 0,
            "Execute: function evaluation failed." );
        return PoisonValue();
    }

    if( IsExternalFunc( func ) )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage( 0,
            "Execute: can't call external functions." );
        return PoisonValue();
    }

    bool poisoned = false;
    const auto& vec = *get< pvec >( call.args() );

    if( IsBuiltinFunc( func ) )
    {
        auto newVec = vec.transform( [&]( auto&& x ) -> optional< Term >

            if( !newVal.isConstant() )
                return ValueToIRExpr( PoisonValue() );

            return ValueToIRExpr( newVal );
        } );

        if( poisoned )
            return PoisonValue();

        if( !newVec )
        {
            DiagnosticsManager::GetInstance().emitErrorMessage( 0,
                "Execute: args evaluation failed." );
            return PoisonValue();
        }

        return ExecuteBuiltinFuncCall( func, TERM( newVec ) );

    for( auto&& a : vec.terms() )
    {
        auto val = ValueFromIRExpr( a );
        assert( val );

        auto newVal = Evaluate( *val, *this );
        if( newVal.isPoison()  )
            return PoisonValue();

        if( !newVal.isConstant() )
        {
            DiagnosticsManager::GetInstance().emitErrorMessage( 0,
                "Execute: args evaluation failed." );
            return PoisonValue();
        }

        args.emplace_back( move( newVal ) );

optional< Value > VM::execute( const llr::LoadConstInt& lci )
{
    return ToValue( lci.value() );
}

ptr< BasicBlock > VM::execute( const llr::Branch& b )
{
    if( !( ms_remainingBranchInstExecutions ) )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage( 0,
            "Execute: compilation time execution budget exceeded." );
        m_frame.setRetVal( PoisonValue() );
        return nullptr;
    }

    --ms_remainingBranchInstExecutions;
    return b.dest().lock();
}

ptr< BasicBlock > VM::execute( const llr::CondBranch& cb )
{
    if( !( ms_remainingBranchInstExecutions ) )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage( 0,
            "Execute: compilation time execution budget exceeded." );
        m_frame.setRetVal( PoisonValue() );
        return nullptr;
    }

    --ms_remainingBranchInstExecutions;

    auto cond = Evaluate( cb.cond(), *this );
    if( cond.isPoison() )
        return nullptr;

    if( !cond.isConstant() )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage( 0,
            "Execute: branch condition evaluation failed." );
        m_frame.setRetVal( PoisonValue() );
        return nullptr;
    }

    if( *FromValue< bool >( cond ) )
        return cb.trueDest().lock();

    return cb.falseDest().lock();
}

#ifndef EMPATHY_EXECUTE_VM_H
#define EMPATHY_EXECUTE_VM_H

namespace empathy::execute
{
    class VM
    {
        friend class ExecutionBudgetGuard;

        public:
            optional< Value > execute( CFG& cfg );
            optional< Value > execute( ptr< BasicBlock > bb );

            optional< Value > execute( const llr::Instruction& instr );
            optional< Value > execute( const ptr< CFG >& ic );
            optional< Value > execute( const llr::Call& call );

            optional< Value > execute( const llr::SGE& bo );
            optional< Value > execute( const llr::SLT& bo );
            optional< Value > execute( const llr::SLE& bo );

            template< typename T >
            optional< Value > execute( const T& )
            {
                return PoisonValue();
            }

            ptr< BasicBlock > execute( const llr::Terminator& terminator );
            ptr< BasicBlock > execute( const llr::Ret& r );
            ptr< BasicBlock > execute( const llr::Branch& b );
            ptr< BasicBlock > execute( const llr::CondBranch& cb );

            ptr< BasicBlock > m_pPreviousBB;

            // To avoid compile time code to get stuck, we have a limitation on the
            // total number of call and loop instructions that we are willing to execute
            // before giving up.
            static uint32_t ms_remainingBranchInstExecutions;
    };

    // To avoid using up the execution budget on failed non mandatory compile time execution attempts
    class ExecutionBudgetGuard
    {
        public:
            ExecutionBudgetGuard() :
                m_savedBudget( VM::ms_remainingBranchInstExecutions )
            {}

            ~ExecutionBudgetGuard()
            {
                VM::ms_remainingBranchInstExecutions = m_savedBudget;
            }

            // If the budget use should be kept, call this before destruction.
            void commit()
            {
                m_savedBudget = VM::ms_remainingBranchInstExecutions;
            }

        private:
            uint32_t m_savedBudget = 0;
    };
}

#endif

#include "llr/llr.h"
#include "builtins/builtins.h"

using namespace empathy::builtins;

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

        if( IsExternalFunc( m_func ) )
            return false;

        bool argsCanBeExecuted = true;
        ForEachInVectorTerm( m_args, [&]( auto&& arg )
        {
            if( !IsValueConstantOrExecutable( *ValueFromIRExpr( arg ) ) )
            {
                argsCanBeExecuted = false;

#ifndef EMPATHY_LLR_CFG_H
#define EMPATHY_LLR_CFG_H

namespace empathy::llr
{
    class BasicBlock;

    class CFG
    {
        public:
            CFG();

            bool isPoisoned() const { return m_poisoned; }
            void poison() { m_poisoned = true; }

            const auto& entryBB() const { return m_basicBlocks.front(); }
            const auto& lastBB() const { return m_basicBlocks.back(); }

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

            vector< ptr< llr::BasicBlock > > m_basicBlocks;

            // The unique identifier of this CFG.
            uint32_t m_uniqueId = ms_nextUniqueId++;

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

            bool m_poisoned = false;

            static uint32_t ms_nextUniqueId;
    };
}

#endif

        m_currentBB->setTerminator( forward< T >( terminator ) );
    }

    template< typename V >
    void Parser::pushValue( V&& val )
    {
        if( val.isPoison() )
        {
            DiagnosticsManager::GetInstance().setCurrentVerbosityLevel( Verbosity::SilentLocally );
            if( cfg() )
                cfg()->poison();
        }

        flushValue();

        if( val.isConstant() || !llr::CanValueBeEagerlyEvaluated( val ) )
        {
            m_lastValue = forward< V >( val );
            return;

                if( !rightVal )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( locationId,
                        "expected an expression.", 0 );
                    return false;
                }
            }

            if( rightVal->isPoison() )
            {
                p.pushValue( PoisonValue() );
                return true;
            }

            DiagnosticsContext dc( locationId, false );

            auto result = func( p, *rightVal );
            p.pushValue( move( result ) );
            return true;
        } );

                auto leftVal = p.popValue();
                if( !leftVal )
                {
                    DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( locationId,
                        "expected a value operand.", 0 );
                    return false;
                }

                if( leftVal->isPoison() )
                {
                    p.pushValue( PoisonValue() );
                    return true;
                }

                DiagnosticsContext dc( locationId, false );

                auto result = func( p, *leftVal );
                p.pushValue( move( result ) );
                return true;
            } );

                    if( !rightVal )
                    {
                        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( locationId,
                            "expected an expression.", 0 );
                        return false;
                    }
                }

                if( leftVal->isPoison() || rightVal->isPoison() )
                {
                    p.pushValue( PoisonValue() );
                    return true;
                }

                DiagnosticsContext dcl( leftVal->locationId(), false );
                DiagnosticsContext dcr( rightVal->locationId(), false );

                DiagnosticsContext dc( locationId, false );

                auto result = func( p, *leftVal, *rightVal );

                    if( !rightVal )
                    {
                        DiagnosticsManager::GetInstance().emitSyntaxErrorMessage( locationId,
                            "expected an expression.", 0 );
                        return false;
                    }
                }

                if( leftVal->isPoison() || rightVal->isPoison() )
                {
                    p.pushValue( PoisonValue() );
                    return true;
                }

                DiagnosticsContext dcl( leftVal->locationId(), false );
                DiagnosticsContext dcr( rightVal->locationId(), false );

                DiagnosticsContext dc( locationId, false );

                auto result = func( p, *leftVal, *rightVal );

#include "sema.h"
#include "builtins/builtins.h"
#include "execute/execute.h"

namespace empathy::sema
{
    ptr< InvocationRule > GetInvocationRule( const Env& e, const Value& callee )
    {
        const auto& rules = e.invocationRuleSet()->rules();

    bool CanBeInvoked( const Context& c, const Value& callee )
    {
        return !!GetInvocationRule( *c.env(), callee );
    }

    Value ResolveInvocation( const Context& c, const ptr< InvocationRule >& pInvRule, const Value& callee, const Value& args )
    {
        if( callee.isPoison() || args.isPoison() )
            return PoisonValue();

        auto loc = Location::CreateSpanningLocation( callee.locationId(), args.locationId() );

        // If the current domain isn't compile time and the args are constant, attempt to resolve it as a compile time invocation
        // first.
        if( args.isConstant() && c.domain() != DomainCompileTime() && builtins::IsTupleConstant( args ) )
        {
            // This is a speculative attempt at compile time execution. It it doesn't work, we'll
            // just try to resolve the invocation in its originally intended domain.
            // So don't display any error message during the attempt.
            VerbosityContext vc( Verbosity::Silent );

            execute::ExecutionBudgetGuard ebg;

            Context localC( c.env(), InjectDomainIntoIdentity( c.identity(), DomainCompileTime() ) );
            auto result = pInvRule->resolveInvocation( localC, loc, callee, args ).setLocationId( loc );
            if( !result.isPoison() )
            {
                execute::VM vm;
                result = execute::Evaluate( result, vm );
                ebg.commit();
                return result;
            }
        }

        if( loc == ~0 )
            DiagnosticsManager::GetInstance().setCurrentVerbosityLevel( Verbosity::SilentLocally );

        return pInvRule->resolveInvocation( c, loc, callee, args ).setLocationId( loc );
    }
}