Goose  Artifact [dd3a54553f]

Artifact dd3a54553fc9ff8922b83de6c08d5b0f35876ecb09466a3a6496c019348b17d8:

• File bs/sema/postprocess.cpp — part of check-in [52ea24b083] at 2021-02-25 12:10:33 on branch trunk — Implemented a new method to order function overloads. Enabled several new reference tests which are now working properly. (user: achavasse size: 2595)

#include "sema.h"

namespace goose::sema
{
    Term WrapWithPostprocFunc( const Term& t, const ptr< PostProcFunc >& pp )
    {
        return SetWeight( VEC( TSID( postproc ),
            TERM( static_pointer_cast< void >( pp ) ),
            t ), GetWeight( t ) );
    }

    Term WrapWithPostprocFunc( const Term& t, PostProcFunc&& pp )
    {
        return SetWeight( VEC( TSID( postproc ),
            TERM( static_pointer_cast< void >( make_shared< PostProcFunc >( move( pp ) ) ) ),
            t ), GetWeight( t ) );
    }

    optional< pair< Term, ptr< PostProcFunc > > > UnwrapPostprocFunc( const Term& ppt )
    {
        auto result = Decompose( ppt,
            Vec(
                Lit( "postproc"_sid ),
                Val< ptr< void > >(),
                SubTerm()
            )
        );

        if( !result )
            return nullopt;

        auto&& [pPP, t] = *result;
        return make_pair( t, static_pointer_cast< PostProcFunc >( pPP ) );
    }

    optional< Term > Postprocess( const Term& src, TypeCheckingContext& tcc )
    {
        if( auto optHole = HoleFromIRExpr( src ) )
        {
            const auto& hole = *optHole;

            if( !hole.name().isNumerical() )
            {
                // If the name is not found, output it as is.
                auto index = tcc.getLHSHoleIndex( hole.name() );
                if( index == TypeCheckingContext::InvalidIndex )
                    return src;

                const auto& val = tcc.getValue( index );
                if( !val )
                    return src;

                return Postprocess( *val, tcc );
            }
            else
            {
                const auto& optVal = tcc.getValue( hole.name().id() );
                if( !optVal )
                    return HOLE( "_"_sid );

                return Postprocess( *optVal, tcc );
            }
        }

        if( !holds_alternative< pvec >( src ) )
            return src;

        if( auto optPP = UnwrapPostprocFunc( src ) )
        {
            auto val = Postprocess( optPP->first, tcc );
            if( !val )
                return nullopt;

            return ( *optPP->second )( *val, tcc );
        }

        const auto& vec = *get< pvec >( src );

        auto outputTerms = make_shared< Vector >();
        outputTerms->reserve( vec.terms().size() );

        for( auto&& t : vec.terms() )
        {
            auto newT = Postprocess( t, tcc );
            if( !newT )
                return nullopt;

            outputTerms->append( move( *newT ) );
        }

        return outputTerms;
    }
}