Goose  Artifact [956c9ccd05]

Artifact 956c9ccd05aa3e0a4d689404085d58c531d7f9dc5f146c331b81132454f61a9f:

• File bs/builtins/types/localvar/unify.cpp — part of check-in [652107629a] at 2020-02-20 22:42:24 on branch trunk —
  • Wrap function parameters into local variables, which will make it easier later on to distinguish temporaries from stack values when implementing references.
  • Register parameters for destruction, which was missing.
  • Added an invocation rule for local variables, so that they can be invoked if they contain an invokable object.
  (user: achavasse size: 2074)

#include "builtins/builtins.h"

using namespace goose;
using namespace goose::ir;
using namespace goose::llr;

namespace goose::builtins
{
    void SetupLocalVarUnification( Env& e )
    {
        auto localVarPattern = GetValueType< LocalVar >( ANYTERM( _ ) );

        // LocalVar unification against a param:
        // Unify the contained value with the param.
        e.unificationRuleSet()->addSymRule(

            ParamPat( ANYTERM( _ ) ),

            ValueToIRExpr( ValuePattern(
                ANYTERM( _ ),
                localVarPattern,
                ANYTERM( _ ) ) ),

        []( const Term& lhs, const Term& rhs, UnificationContext& c ) -> UniGen
        {
            auto lvval = *ValueFromIRExpr( rhs );
            auto locvar = FromValue< LocalVar >( lvval );
            if( !locvar )
                co_return;

            auto varcontent = ValueToIRExpr( BuildComputedValue( locvar->type(),
                GetVar( locvar->type(), locvar->index() ) ).setLocationId( lvval.locationId() ) );

            // Unify the param with the var's content
            co_yield Unify( lhs, varcontent, c );
        } );

        // LocalVar unification against another LocalVar: unify their types.
        e.unificationRuleSet()->addSymRule(

            ParamPat( localVarPattern ),

            ValueToIRExpr( ValuePattern(
                ANYTERM( _ ),
                localVarPattern,
                ANYTERM( _ ) ) ),

        []( const Term& lhs, const Term& rhs, UnificationContext& uc ) -> UniGen
        {
            auto lvarType = *FromValue< LocalVarType >( *ValueFromIRExpr( ValuePatternFromIRExpr( lhs )->type() ) );

            auto rhsVal = *ValuePatternFromIRExpr( rhs );
            auto rvarType = *FromValue< LocalVarType >( *ValueFromIRExpr( rhsVal.type() ) );

            for( auto&& [s, uc] : Unify( lvarType.type(), rvarType.type(), uc ) )
            {
                co_yield { ValueToIRExpr( Value( ValueToIRExpr( ToValue( LocalVarType( s ) ) ),
                    rhsVal.val() ) ), uc };
            }
        } );
    }
}