Goose  Artifact [de9a92b2ef]

Artifact de9a92b2ef7fbdf422f23b0fa88b603bd1d2b9e073ab9af8527d1564ba033bfc:

• File bs/builtins/types/overloadset/overloadset.cpp — part of check-in [429f55ae3c] at 2019-07-09 22:46:58 on branch trunk — codegen: added builtin functions to create a module and to dump it as llvm assembly text. (user: achavasse size: 3174)

#include "builtins/builtins.h"

using namespace empathy::builtins;

bool OverloadSet::add( const sema::Context& context, const Value& callee )
{
    auto pInvRule = GetInvocationRule( context, callee );
    assert( pInvRule );

    auto signature = pInvRule->getSignature( callee );
    assert( signature );

    auto result = Decompose( *signature,
        Vec(
            SubTerm(),
            Val< pvec >(),
            SubTerm()
        )
    );

    assert( result );

    auto&& [domain, p, rt] = *result;
    const auto& rtype = rt;
    const auto& params = p;

    bool success = false;
    m_trie = Merge( m_trie, domain, [&]< class UT >( const ptr< UT >& paramUTrie )
    {
        auto uTrieMergeFunc = [&]( auto&& rtTrie )
        {
            return Merge( rtTrie, rtype, [&]( auto&& previous ) -> Overload
            {
                if( previous.callee )
                    return move( previous );

                success = true;
                return { pInvRule, callee };
            } );
        };

        if( !paramUTrie )
            return UT().merge( *params, uTrieMergeFunc );

        return paramUTrie->merge( *params, uTrieMergeFunc );
    } );

    return success;
}

OverloadSet::UniGen OverloadSet::unify( const Term& domPat, const Term& argsPat, const Term& rtPat, UnificationContext& uc ) const
{
    auto argDecomp = Decompose( argsPat,
        Val< pvec >()
    );

    if( !argDecomp )
        co_return;

    for( auto&& [domain,paramUTrie] : Enumerate( m_trie ) )
    {
        auto localC = uc;
        for( auto&& [uniDom,uc] : Unify( domain, domPat, localC ) )
        {
            for( auto&& [uniParamsVec,rtTrie,uc] : paramUTrie->unify( *argDecomp->get(), uc ) )
            {
                auto uniParams = TERM( make_shared< Vector >( uniParamsVec ) );
                for( auto&& [rt,ovl] : Enumerate( rtTrie ) )
                {
                    auto localC = uc;
                    for( auto&& [uniRt,uc] : Unify( rt, rtPat, localC ) )
                    {
                        auto uniCall = TERM( Vector::Make( uniDom, uniParams, uniRt ) );
                        co_yield { move( uniCall ), ovl, uc };
                    }
                }
            }
        }
    }
}

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

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

    Value Bridge< ptr< builtins::OverloadSet > >::ToValue( const ptr< builtins::OverloadSet >& os )
    {
        return Value( Type(), TERM( static_pointer_cast< void >( os ) ) );
    }

    optional< ptr< builtins::OverloadSet > > Bridge< ptr< builtins::OverloadSet > >::FromValue( const Value& v )
    {
        if( !IsOverloadSet( v ) )
            return nullopt;

        auto result = Decompose( v.val(),
            Val< ptr< void > >()
        );

        if( !result )
            return nullopt;

        return static_pointer_cast< builtins::OverloadSet >( result->get() );
    }
}