Goose  Diff

#include "builtins/builtins.h"
#include "builtins/helpers.h"

using namespace goose;
using namespace goose::ir;

namespace goose::builtins
{
    void SetupRuntimeTypesUnification( Env& e )
    {
        auto rtIntTypePattern = Value( TypeType(), VEC( TSID( rt_type ),
        auto rtIntTypePattern = Value( TypeType(), MkStdType( TSID( integer ),
            ANYTERM( _ ),
            TSID( integer ), VEC( ANYTERM( _ ), ANYTERM( _ ) ) ) );
            VEC( ANYTERM( _ ), ANYTERM( _ ) ) ) );

        // ct_int type against a IntegerType type:
        // return the IntegerType type. We don't care if the
        // ct_int fits at this point, this will be dealt with by
        // the ct_int value unification rule below.
        e.unificationRuleSet()->addSymRule(
            ValueToIRExpr( rtIntTypePattern ),

            }

            auto* llvmType = static_cast< llvm::IntegerType* >( GetLLVMType( *rttypeVal ) );
            co_yield { ValueToIRExpr(
                Value( lhsVal->type(), move( valToLoad ) ) ), c };
        } );

        auto rtInt8TypePattern = Value( TypeType(), VEC( TSID( rt_type ),
        auto rtInt8TypePattern = Value( TypeType(), MkStdType( TSID( integer ),
            ANYTERM( _ ),
            TSID( integer ), VEC( TERM( 8U ), ANYTERM( _ ) ) ) );
            VEC( TERM( 8U ), ANYTERM( _ ) ) ) );

        auto rtInt8PtrTypePattern = Value( TypeType(), VEC( TSID( rt_type ),
        auto rtInt8PtrTypePattern = Value( TypeType(), MkStdType( TSID( pointer ),
            ANYTERM( _ ),
            TSID( pointer ), ValueToIRExpr( rtInt8TypePattern ) ) );
            ValueToIRExpr( rtInt8TypePattern ) ) );

        // ct_string type against a char*:
        // return the char* type.
        e.unificationRuleSet()->addSymRule(
            ValueToIRExpr( rtInt8PtrTypePattern ),
            GetValueType< string >(),
        []( const Term& lhs, const Term& rhs, UnificationContext& c ) -> UniGen

            auto str = *FromValue< string >( *ValueFromIRExpr( lhs ) );
            auto rhsVal = *ValuePatternFromIRExpr( rhs );

            co_yield { ValueToIRExpr(
                BuildComputedValue( rhsVal.type(), llr::LoadConstStr( str ) ) ), c };
        } );

        auto ptrTypePattern = Value( TypeType(), VEC( TSID( rt_type ),
            ANYTERM( _ ),
        auto ptrTypePattern = Value( TypeType(), MkStdType( TSID( pointer ),
            ANYTERM( _ ) ) );
            TSID( pointer ), ANYTERM( _ ) ) );

        // nullptr constant unification against a pointer of any type;
        // Yield a value of the given pointer type, with a 0 integer as its content.
        // This'll be recognized by codegen to emit a null pointer value of the right type.
        e.unificationRuleSet()->addSymRule(

            ParamPat( ValueToIRExpr( ptrTypePattern ) ),