Goose  Diff

        if( !cfg )
            return PoisonValue();

        auto bb = cfg->currentBB();
        if( !bb )
            return PoisonValue();

        // To infer the type and obtain a suitable initialization function, we typecheck
        //          ( $$T, _ ( MutRef[$$T], initValType ) initFunc )
        // against  ( pat, Initialize                              )
        //
        // Where:
        //   pat is the type pattern provided for the declaration,
        //   initValType is the initialization expression's type,
        //   Initialize is the Initialize overload set.
        //
        // The possible types that can be infered according to the initialization expression
        // are therefore defined by the Initialize overloads.

        auto type = InferTypeFromTExprAndInitializer( c, typeTExpr, initVal );
        // The best solution (if any) will give us the wanted type and
        // the function to invoke to initialize it.

        if( type.isPoison() )
        // Create the _ texpr.
        static auto TVarAny = ValueToEIR( ToValue( TVar( "_"_sid ) ) );

        // The $$T texpr.
        static auto TTVarT = ValueToEIR( ToValue( TTVar( "T"_sid ) ) );

        // Create the MutRef[$$T] param.
        static auto mutRefParam = ValueToEIR( ToValue( TNamedDecl(
            ValueToEIR( ToDeclValue( ReferenceType{ TTVarT, MutAccessSpecifer(), } ) ), "ref"_sid ) ) );

        auto initValParam = ValueToEIR( ToValue( Decl( initVal.type(), "initVal"_sid ) ) );

        // Create the _ ( MutRef[$$T], initType ) initFunc param.
        auto initFuncTFTParam = ValueToEIR( ToValue(
            TNamedDecl( ValueToEIR( ToValue( TFuncType( TVarAny, VEC( move( mutRefParam ), move( initValParam ) ) ) ) ),
                "initFunc"_sid ) ) );

        TemplateContext tc( c );

        // Create our parameter list.
        auto paramPat = VEC(
            *BuildTemplateSignature( tc, TTVarT ),
            *BuildTemplateSignature( tc, initFuncTFTParam )
        );

        // Create our arg list.
        auto args = VEC(
            *BuildTemplateArgPattern( c, typeTExpr ),
            ValueToEIR( ToValue( c.env()->extInitialize() ) )
        );

        auto us = FindBestTyping( paramPat, args, c );

        if( holds_alternative< NoUnification >( us ) )
        {
            // TODO display details
            DiagnosticsManager::GetInstance().emitErrorMessage( 0,
                "variable initialization type mismatch." );
            return PoisonValue();
        }


        if( holds_alternative< AmbiguousTypeCheck >( us ) )
        {
            // TODO display details
            DiagnosticsManager::GetInstance().emitErrorMessage( 0,
                "ambiguous variable type inference." );
            return PoisonValue();
        }

        auto&& [s,tcc] = get< TCSol >( us );

        // Perform the setup of the type template expression. This will create local bindings
        // for tvars ($whatever), if any, making them available for further use.

        // We need to create a temporary context and adjust the identity so that the tvar
        // bindings will be injected to our parent scope, rather than in our local statement scope.
        auto parentIdentity = TakeVectorTerm( c.identity(), VecSize( c.identity() ) - 2 );
        Context ctxt( c.env(), parentIdentity );

        // The TVar setup expects to find its name on the left hand side of the type checking,
        // But in our case we have put it on the rhs, so we need to flip the context around
        // before setup.
        TemplateSetup( ctxt, tcc.flip(), typeTExpr );

        auto callDecomp = Decompose( s,
            Vec(
                SubTerm(),  // locvar
                SubTerm()   // initializer
            )
        );

        auto&& [type, initializer] = *callDecomp;

        if( !ParseTypePredicates( c, *EIRToValue( type ) ) )
            return PoisonValue();

        auto index = util::GenerateNewUID();

        // Retrieve the texpr's location and set it on the inferred type. This way if an
        // error occurs later with it, for instance when calling LowerTypeForRuntime on it during codegen,
        // it will have a meaningful location for the error message to attach itself on.
        auto typeLoc = EIRToValue( typeTExpr )->locationId();
        LocalVar lv( name, type, index );

        LocalVar lv( name, ValueToEIR( type ), index );
        bb->append( AllocVar( type, index, locId ) );
        bb->append( AllocVar( EIRToValue( lv.type() )->setLocationId( typeLoc ), index, locId ) );

        DiagnosticsContext dc( 0, "When invoking Initialize." );

        auto initResult = InvokeOverloadSet( c,
            c.env()->extInitialize(),
            MakeClosedTuple( ToValue( lv ).setLocationId( locId ), initVal ) );