Goose  Check-in [9089b014a2]

#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(
            Val< pvec >(),
            SubTerm()
        )
    );

    assert( result );

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

    bool success = false;

    m_trie = m_trie->merge( *params, [&]( auto&& rtTrie )
    {
        return Merge( rtTrie, rtype, [&]( auto&& previous ) -> Overload
        {
            if( previous.callee )
                return move( previous );

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

    return success;
}

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

        public:
            struct Overload
            {
                ptr< InvocationRule > pInvRule;
                optional< Value > callee;
            };

            OverloadSet( const StringId& name ) :
                m_name( name )
            {}

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

            bool add( const sema::Context& context, const Value& callee );

            using UniGen = Generator< tuple<
                Term,
                const Overload&,
                UnificationContext
            > >;

            UniGen unify( const Term& argsPat, const Term& rtPat, UnificationContext& uc ) const;

        private:
            StringId m_name;

            using utrie_type = UTrie< Trie< Overload > >;
            ptr< utrie_type > m_trie = make_shared< utrie_type >();
    };

    extern bool IsOverloadSet( const Value& os );
}

                UnificationContext uc( env );

                optional< UnificationContext > bestUC;
                optional< Term > bestSol;
                bool ambiguous = false;

                auto callPat = TVEC( args.val(), sema::MkHole( "_"_sid ) );

                for( auto&& [s, uc] : Unify( tf->signature(), callPat, uc ) )
                {
                    if( uc.numUnknownValues() )
                        continue;

                    if( !bestSol || uc.score() > bestUC->score() )
                    {

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

using namespace empathy::builtins;
using namespace empathy::parse;

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

    }

    Value Bridge< TFunc >::ToValue( const TFunc& tf )
    {
        return Value( Type( tf ), TVEC( tf.signature(), tf.identity(),
            TERM( static_pointer_cast< void >( tf.toks() ) ) ) );
    }

}

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

#endif

add_library( empathy-parse
    resolver.cpp
    parser.cpp
    rule-helpers.cpp
    blocks.cpp
    func.cpp
    tfunc.cpp
    overload.cpp
)

target_link_libraries( empathy-parse
    empathy-lex
    empathy-sema
    empathy-builtins
)

    const auto& c = m_resolver->context();
    auto funcValIdentity = AppendToVectorTerm( c.identity(), TERM( d->name() ) );

    // If we're here, this is not an overload, but the first time we come accross this function.
    // So create a new overload set. The case of actually overloading an existing function is parsed
    // elsewhere.
    auto pOvlSet = make_shared< OverloadSet >( d->name() );
    pOvlSet->add( c, *func );

    c.env()->storeValue( funcValIdentity, ANYTERM( c ),
        ValueToIRExpr( ToValue( pOvlSet ) ) );

    return true;
}

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

using namespace empathy;
using namespace empathy::parse;
using namespace empathy::builtins;

optional< uint32_t > Parser::getInfixOverloadSetPrecedence()
{
    if( isInParenExpr() )
        return nullopt;

    auto next = m_resolver->lookAheadUnresolved( 1 );
    if( !next )
        return nullopt;

    auto decomp = Decompose( *next, Val< Delimiter >() );
    if( !decomp || *decomp != Delimiter::OpenParen )
        return nullopt;

    return precedence::Application;
}

bool Parser::parseInfixOverloadSet( const ptr< builtins::OverloadSet >& pOvlSet, uint32_t prec )
{
    auto rt = *pop();
    m_resolver->consume();

    auto params = parseParenBlock( Delimiter::OpenParen );
    if( !params )
        return false;

    optional< Value > func;

    if( rt.type() == TSID( type ) )
        func = parseFunctionDeclaration( pOvlSet->name(), rt, *params );
    else if( IsTExpr( rt ) )
        func = parseTemplateFunction( pOvlSet->name(), rt, *params );

    if( !func )
        return false;

    const auto& c = m_resolver->context();
    if( !pOvlSet->add( c, *func ) )
    {
        cout << "error: duplicate function overload\n";
        return false;
    }

    return true;
}

}

optional< uint32_t > Parser::getPrecedence( const Term& t, const pvec& vec )
{
    auto val = ValueFromIRExpr( t );
    if( !val )
        return nullopt;

    if( val->type() == GetValueType< ptr< OverloadSet > >() )
        return getInfixOverloadSetPrecedence();

    // If the term is an infix rule value, invoke its getPrecedence() function.
    auto rule = FromValue< Rule >( *val );
    if( !rule )
        return nullopt;

    if( !rule->isInfix() )

{
    auto t = *m_resolver->lookAhead();

    auto val = ValueFromIRExpr( t );
    if( !val )
        return false;

    if( val->type() == GetValueType< ptr< OverloadSet > >() )
        return parseInfixOverloadSet( FromValue< ptr< OverloadSet > >( *val ), prec );

    // If the term is an infix rule value, invoke its parseInfix() function.
    auto rule = FromValue< Rule >( *val );
    if( !rule )
        return false;

    m_resolver->consume();

    if( !rule->isInfix() )
        return false;

    return rule->parseInfix( *this, t, prec );
}

            {
                optional< Value > result;
                swap( result, m_lastValue );
                return result;
            }

            optional< Value > result();

            bool isInParenExpr() const
            {
                return m_introDelimiter && *m_introDelimiter == Delimiter::OpenParen;
            }

        private:
            optional< uint32_t > getPrecedence( const Term& t );
            bool parsePrefix( const Term&, uint32_t precedence );
            bool parseInfix( const Term&, uint32_t precedence );

            // Default getPrecedence overload

            optional< Value > parseFunctionDeclaration( const StringId& name, const Value& returnType, const Value& params );

            // Template functions
            bool parseTemplateFunctionExpression( const Value& returnType, const Value& params );
            bool parseTemplateFunctionTNamedDecl( const Value& tnamedDecl, const Value& params );
            optional< Value > parseTemplateFunction( const StringId& name, const Value& returnType, const Value& params );

            // Overloading
            optional< uint32_t > getInfixOverloadSetPrecedence();
            bool parseInfixOverloadSet( const ptr< builtins::OverloadSet >& pOvlSet, uint32_t prec );

            // Resolver to fetch input terms from.
            ptr< Resolver > m_resolver;

            // The sequence under construction.
            ptr< llr::Seq > m_seq;

            // The last value that we have built,

    const auto& c = m_resolver->context();
    auto funcValIdentity = AppendToVectorTerm( c.identity(), TERM( d->name() ) );

    // If we're here, this is not an overload, but the first time we come accross this function.
    // So create a new overload set. The case of actually overloading an existing function is parsed
    // elsewhere.
    auto pOvlSet = make_shared< OverloadSet >( d->name() );
    pOvlSet->add( c, *tfunc );

    c.env()->storeValue( funcValIdentity, ANYTERM( c ),
        ValueToIRExpr( ToValue( pOvlSet ) ) );

    return true;
}

// Front-end. This is the interpreted code entry point, directly
// executed by the empathy command.
//
// This will setup the prelude and drive the compilation
// process (through function calls exposed by empathy).

// For now it's just a playground to dump test code.

void testTmpl( ct_string foo )
{
    Print( foo );
}

void testTmpl( $T foo )
{
    Print( "whatever" )
}

void testTmpl( ct_int foo )
{
    Print( "integer" )
}

testTmpl( 123 )

testTmpl( "Test2" )

// TODO: The following call ought to print "whatever", but
// the value of Print fails to unify because it contains the function's signature, whose holes
// are left unresolved. The signature pattern should really not be stored in the type, but along with
// the function's body, like for templates.
// testTmpl( Print )

///////////////////////////////////////////////

void test( $T a, $U b )
{
    Print( "different types" )
}


void test( $T a, $T b )
{
    Print( "same types" )
}

test(1,2)
test("a", "b")
test(1,"a")
test("b",45)

///////////////////////////////////////////////


using args = Args()

void testFunc()
{
    Print( "testFunc: overload 1" )
}

void testFunc( ct_string foo )
{
    Print( "testFunc: overload 2" )
    Print( foo )
}

void testFunc( ct_int foo )
{
    Print( "testFunc: overload 3" )
}

void testFunc( ct_int foo, ct_string bar )
{
    Print( "testFunc: overload 4" )
    Print( bar )
}

void testFunc( ct_string foo, ct_int bar )
{
    Print( "testFunc: overload 5" )
    Print( foo )
}

testFunc( "gg" )
testFunc()
testFunc( 1234 )
testFunc( 12347, args )
testFunc( "meh", 878787 )