source: src/Validate/Autogen.cpp@ a9ce782

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Autogen.cpp -- Generate automatic routines for data types.
//
// Author           : Andrew Beach
// Created On       : Thu Dec  2 13:44:00 2021
// Last Modified By : Andrew Beach
// Last Modified On : Tue Sep 20 16:00:00 2022
// Update Count     : 2
//

#include "Autogen.hpp"

#include <algorithm>                   // for count_if
#include <cassert>                     // for strict_dynamic_cast, assert, a...
#include <iterator>                    // for back_insert_iterator, back_ins...
#include <list>                        // for list, _List_iterator, list<>::...
#include <set>                         // for set, _Rb_tree_const_iterator
#include <utility>                     // for pair
#include <vector>                      // for vector

#include "AST/Attribute.hpp"
#include "AST/Copy.hpp"
#include "AST/Create.hpp"
#include "AST/Decl.hpp"
#include "AST/DeclReplacer.hpp"
#include "AST/Expr.hpp"
#include "AST/Inspect.hpp"
#include "AST/Pass.hpp"
#include "AST/Stmt.hpp"
#include "AST/SymbolTable.hpp"
#include "CodeGen/OperatorTable.hpp"   // for isCtorDtor, isCtorDtorAssign
#include "Common/ScopedMap.hpp"        // for ScopedMap<>::const_iterator, S...
#include "Common/Utility.hpp"          // for cloneAll, operator+
#include "GenPoly/ScopedSet.hpp"       // for ScopedSet, ScopedSet<>::iterator
#include "InitTweak/GenInit.hpp"       // for fixReturnStatements
#include "InitTweak/InitTweak.hpp"     // for isAssignment, isCopyConstructor
#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
#include "SymTab/Mangler.hpp"          // for Mangler
#include "CompilationState.hpp"

namespace Validate {

namespace {

// --------------------------------------------------------------------------
struct AutogenerateRoutines final :
                public ast::WithDeclsToAdd,
                public ast::WithShortCircuiting {
        void previsit( const ast::EnumDecl * enumDecl );
        void previsit( const ast::StructDecl * structDecl );
        void previsit( const ast::UnionDecl * structDecl );
        void previsit( const ast::TypeDecl * typeDecl );
        void previsit( const ast::TraitDecl * traitDecl );
        void previsit( const ast::FunctionDecl * functionDecl );
        void postvisit( const ast::FunctionDecl * functionDecl );

private:
        // Current level of nested functions.
        unsigned int functionNesting = 0;
};

// --------------------------------------------------------------------------
/// Class used to generate functions for a particular declaration.
/// Note it isn't really stored, it is just a class for organization and to
/// help pass around some of the common arguments.
class FuncGenerator {
public:
        std::list<ast::ptr<ast::Decl>> definitions;

        FuncGenerator( const ast::Type * type, unsigned int functionNesting ) :
                type( type ), functionNesting( functionNesting )
        {}

        /// Generate functions (and forward decls.) and append them to the list.
        void generateAndAppendFunctions( std::list<ast::ptr<ast::Decl>> & );

        virtual bool shouldAutogen() const = 0;
protected:
        const ast::Type * type;
        unsigned int functionNesting;
        ast::Linkage::Spec proto_linkage = ast::Linkage::AutoGen;

        // Internal helpers:
        virtual void genStandardFuncs();
        void produceDecl( const ast::FunctionDecl * decl );

        const CodeLocation& getLocation() const { return getDecl()->location; }
        ast::FunctionDecl * genProto( std::string&& name,
                std::vector<ast::ptr<ast::DeclWithType>>&& params,
                std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const;

        ast::ObjectDecl * dstParam() const;
        ast::ObjectDecl * srcParam() const;
        ast::FunctionDecl * genCtorProto() const;
        ast::FunctionDecl * genCopyProto() const;
        ast::FunctionDecl * genDtorProto() const;
        ast::FunctionDecl * genAssignProto() const;
        ast::FunctionDecl * genFieldCtorProto( unsigned int fields ) const;

        // Internal Hooks:
        virtual void genFuncBody( ast::FunctionDecl * decl ) = 0;
        virtual void genFieldCtors() = 0;
        virtual bool isConcurrentType() const { return false; }
        virtual const ast::Decl * getDecl() const = 0;
};

class StructFuncGenerator final : public FuncGenerator {
        const ast::StructDecl * decl;
public:
        StructFuncGenerator( const ast::StructDecl * decl,
                        const ast::StructInstType * type,
                        unsigned int functionNesting ) :
                FuncGenerator( type, functionNesting ), decl( decl )
        {}

        // Built-ins do not use autogeneration.
        bool shouldAutogen() const final { return !decl->linkage.is_builtin && !structHasFlexibleArray(decl); }
private:
        void genFuncBody( ast::FunctionDecl * decl ) final;
        void genFieldCtors() final;
        bool isConcurrentType() const final {
                return decl->is_thread() || decl->is_monitor();
        }
        virtual const ast::Decl * getDecl() const final { return decl; }

        /// Generates a single struct member operation.
        /// (constructor call, destructor call, assignment call)
        const ast::Stmt * makeMemberOp(
                const CodeLocation& location,
                const ast::ObjectDecl * dstParam, const ast::Expr * src,
                const ast::ObjectDecl * field, ast::FunctionDecl * func,
                SymTab::LoopDirection direction );

        /// Generates the body of a struct function by iterating the struct members
        /// (via parameters). Generates default constructor, copy constructor,
        /// copy assignment, and destructor bodies. No field constructor bodies.
        template<typename Iterator>
        void makeFunctionBody( Iterator member, Iterator end,
                        ast::FunctionDecl * func, SymTab::LoopDirection direction );

        /// Generate the body of a constructor which takes parameters that match
        /// fields. (With arguments for one to all of the fields.)
        template<typename Iterator>
        void makeFieldCtorBody( Iterator member, Iterator end,
                        ast::FunctionDecl * func );
};

class UnionFuncGenerator final : public FuncGenerator {
        const ast::UnionDecl * decl;
public:
        UnionFuncGenerator( const ast::UnionDecl * decl,
                        const ast::UnionInstType * type,
                        unsigned int functionNesting ) :
                FuncGenerator( type, functionNesting ), decl( decl )
        {}

        // Built-ins do not use autogeneration.
        bool shouldAutogen() const final { return !decl->linkage.is_builtin; }
private:
        void genFuncBody( ast::FunctionDecl * decl ) final;
        void genFieldCtors() final;
        const ast::Decl * getDecl() const final { return decl; }

        /// Generate a single union assignment expression (using memcpy).
        ast::ExprStmt * makeAssignOp( const CodeLocation& location,
                const ast::ObjectDecl * dstParam, const ast::ObjectDecl * srcParam );
};

class EnumFuncGenerator final : public FuncGenerator {
        const ast::EnumDecl * decl;
public:
        EnumFuncGenerator( const ast::EnumDecl * decl,
                        const ast::EnumInstType * type,
                        unsigned int functionNesting ) :
                FuncGenerator( type, functionNesting ), decl( decl )
        {
                // TODO: These functions are somewhere between instrinsic and autogen,
                // could possibly use a new linkage type. For now we just make the
                // basic ones intrinsic to code-gen them as C assignments.
                // const auto & real_type = decl->base;
                // const auto & basic = real_type.as<ast::BasicType>();

                // if(!real_type || (basic && basic->isInteger())) proto_linkage = ast::Linkage::Intrinsic;

                // Turns other enumeration type into Intrinstic as well to temporarily fix the recursive 
                // construction bug
                proto_linkage = ast::Linkage::Intrinsic;
        }

        bool shouldAutogen() const final { return true; }
private:
        void genFuncBody( ast::FunctionDecl * decl ) final;
        void genFieldCtors() final;
        const ast::Decl * getDecl() const final { return decl; }
protected:
        void genStandardFuncs() override;
};

class TypeFuncGenerator final : public FuncGenerator {
        const ast::TypeDecl * decl;
public:
        TypeFuncGenerator( const ast::TypeDecl * decl,
                        ast::TypeInstType * type,
                        unsigned int functionNesting ) :
                FuncGenerator( type, functionNesting ), decl( decl )
        {}

        bool shouldAutogen() const final { return true; }
        void genFieldCtors() final;
private:
        void genFuncBody( ast::FunctionDecl * decl ) final;
        const ast::Decl * getDecl() const final { return decl; }
};

// --------------------------------------------------------------------------
const std::vector<ast::ptr<ast::TypeDecl>>& getGenericParams( const ast::Type * t ) {
        if ( auto inst = dynamic_cast< const ast::StructInstType * >( t ) ) {
                return inst->base->params;
        } else if ( auto inst = dynamic_cast< const ast::UnionInstType * >( t ) ) {
                return inst->base->params;
        }
        static std::vector<ast::ptr<ast::TypeDecl>> const empty;
        return empty;
}

/// Changes the freshly-constructed (non-const) decl so that it has the unused attribute.
ast::ObjectDecl * addUnusedAttribute( ast::ObjectDecl * decl ) {
        decl->attributes.push_back( new ast::Attribute( "unused" ) );
        return decl;
}

// --------------------------------------------------------------------------
void AutogenerateRoutines::previsit( const ast::EnumDecl * enumDecl ) {
        if ( !enumDecl->body ) return;

        ast::EnumInstType enumInst( enumDecl->name );
        enumInst.base = enumDecl;

        EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
        gen.generateAndAppendFunctions( declsToAddAfter );
}

void AutogenerateRoutines::previsit( const ast::StructDecl * structDecl ) {
        visit_children = false;
        if ( !structDecl->body ) return;

        ast::StructInstType structInst( structDecl->name );
        structInst.base = structDecl;
        for ( const ast::TypeDecl * typeDecl : structDecl->params ) {
                structInst.params.push_back( new ast::TypeExpr(
                        typeDecl->location,
                        new ast::TypeInstType( typeDecl )
                ) );
        }
        StructFuncGenerator gen( structDecl, &structInst, functionNesting );
        gen.generateAndAppendFunctions( declsToAddAfter );
}

void AutogenerateRoutines::previsit( const ast::UnionDecl * unionDecl ) {
        visit_children = false;
        if ( !unionDecl->body ) return;

        ast::UnionInstType unionInst( unionDecl->name );
        unionInst.base = unionDecl;
        for ( const ast::TypeDecl * typeDecl : unionDecl->params ) {
                unionInst.params.push_back( new ast::TypeExpr(
                        unionDecl->location,
                        new ast::TypeInstType( typeDecl )
                ) );
        }
        UnionFuncGenerator gen( unionDecl, &unionInst, functionNesting );
        gen.generateAndAppendFunctions( declsToAddAfter );
}

/// Generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
void AutogenerateRoutines::previsit( const ast::TypeDecl * typeDecl ) {
        if ( !typeDecl->base ) return;

        ast::TypeInstType refType( typeDecl->name, typeDecl );
        TypeFuncGenerator gen( typeDecl, &refType, functionNesting );
        gen.generateAndAppendFunctions( declsToAddAfter );
}

void AutogenerateRoutines::previsit( const ast::TraitDecl * ) {
        // Ensure that we don't add assignment ops for types defined as part of the trait
        visit_children = false;
}

void AutogenerateRoutines::previsit( const ast::FunctionDecl * ) {
        // Track whether we're currently in a function.
        // Can ignore function type idiosyncrasies, because function type can never
        // declare a new type.
        functionNesting += 1;
}

void AutogenerateRoutines::postvisit( const ast::FunctionDecl * ) {
        functionNesting -= 1;
}

void FuncGenerator::generateAndAppendFunctions(
                std::list<ast::ptr<ast::Decl>> & decls ) {
        if ( !shouldAutogen() ) return;

        // Generate the functions (they go into forwards and definitions).
        genStandardFuncs();
        genFieldCtors();

        // Now export the lists contents.
//      decls.splice( decls.end(), forwards );    // mlb wip: delete me
        decls.splice( decls.end(), definitions );
}

void FuncGenerator::produceDecl( const ast::FunctionDecl * decl ) {
        assert( nullptr != decl->stmts );
        assert( decl->type_params.size() == getGenericParams( type ).size() );

        definitions.push_back( decl );
}

void replaceAll( std::vector<ast::ptr<ast::DeclWithType>> & dwts,
                const ast::DeclReplacer::TypeMap & map ) {
        for ( auto & dwt : dwts ) {
                dwt = strict_dynamic_cast<const ast::DeclWithType *>(
                                ast::DeclReplacer::replace( dwt, map ) );
        }
}

/// Generates a basic prototype function declaration.
ast::FunctionDecl * FuncGenerator::genProto( std::string&& name,
                std::vector<ast::ptr<ast::DeclWithType>>&& params,
                std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const {

        // Handle generic prameters and assertions, if any.
        auto const & old_type_params = getGenericParams( type );
        ast::DeclReplacer::TypeMap oldToNew;
        std::vector<ast::ptr<ast::TypeDecl>> type_params;
        std::vector<ast::ptr<ast::DeclWithType>> assertions;
        for ( auto & old_param : old_type_params ) {
                ast::TypeDecl * decl = ast::deepCopy( old_param );
                decl->init = nullptr;
                splice( assertions, decl->assertions );
                oldToNew.emplace( old_param, decl );
                type_params.push_back( decl );
        }
        replaceAll( params, oldToNew );
        replaceAll( returns, oldToNew );
        replaceAll( assertions, oldToNew );

        ast::FunctionDecl * decl = new ast::FunctionDecl(
                // Auto-generated routines use the type declaration's location.
                getLocation(),
                std::move( name ),
                std::move( type_params ),
                std::move( assertions ),
                std::move( params ),
                std::move( returns ),
                // Only a prototype, no body.
                nullptr,
                // Use static storage if we are at the top level.
                (0 < functionNesting) ? ast::Storage::Classes() : ast::Storage::Static,
                proto_linkage,
                std::vector<ast::ptr<ast::Attribute>>(),
                // Auto-generated routines are inline to avoid conflicts.
                ast::Function::Specs( ast::Function::Inline ) );
        decl->fixUniqueId();
        return decl;
}

ast::ObjectDecl * FuncGenerator::dstParam() const {
        return addUnusedAttribute(
                new ast::ObjectDecl( getLocation(), "_dst",
                        new ast::ReferenceType( ast::deepCopy( type ) ) ) );
}

ast::ObjectDecl * FuncGenerator::srcParam() const {
        return addUnusedAttribute(
                new ast::ObjectDecl( getLocation(), "_src",
                        ast::deepCopy( type ) ) );
}

/// Use the current type T to create `void ?{}(T & _dst)`.
ast::FunctionDecl * FuncGenerator::genCtorProto() const {
        return genProto( "?{}", { dstParam() }, {} );
}

/// Use the current type T to create `void ?{}(T & _dst, T _src)`.
ast::FunctionDecl * FuncGenerator::genCopyProto() const {
        return genProto( "?{}", { dstParam(), srcParam() }, {} );
}

/// Use the current type T to create `void ^?{}(T & _dst)`.
ast::FunctionDecl * FuncGenerator::genDtorProto() const {
        // The destructor must be mutex on a concurrent type.
        auto dst = dstParam();
        if ( isConcurrentType() ) {
                add_qualifiers( dst->type, ast::CV::Qualifiers( ast::CV::Mutex ) );
        }

        return genProto( "^?{}", { dst }, {} );
}

/// Use the current type T to create `T ?=?(T & _dst, T _src)`.
ast::FunctionDecl * FuncGenerator::genAssignProto() const {
        // Only the name is different, so just reuse the generation function.
        auto retval = srcParam();
        retval->name = "_ret";
        return genProto( "?=?", { dstParam(), srcParam() }, { retval } );
}

// This one can return null if the last field is an unnamed bitfield.
ast::FunctionDecl * FuncGenerator::genFieldCtorProto(
                unsigned int fields ) const {
        assert( 0 < fields );
        auto aggr = strict_dynamic_cast<const ast::AggregateDecl *>( getDecl() );

        std::vector<ast::ptr<ast::DeclWithType>> params = { dstParam() };
        for ( unsigned int index = 0 ; index < fields ; ++index ) {
                auto member = aggr->members[index].strict_as<ast::DeclWithType>();
                if ( ast::isUnnamedBitfield(
                                dynamic_cast<const ast::ObjectDecl *>( member ) ) ) {
                        if ( index == fields - 1 ) {
                                return nullptr;
                        }
                        continue;
                }

                auto * paramType = ast::deepCopy( member->get_type() );
                erase_if( paramType->attributes, []( ast::Attribute const * attr ){
                        return !attr->isValidOnFuncParam();
                } );
                ast::ObjectDecl * param = new ast::ObjectDecl(
                        getLocation(), member->name, paramType );
                for ( auto & attr : member->attributes ) {
                        if ( attr->isValidOnFuncParam() ) {
                                param->attributes.push_back( attr );
                        }
                }
                params.emplace_back( param );
        }
        return genProto( "?{}", std::move( params ), {} );
}

void appendReturnThis( ast::FunctionDecl * decl ) {
        assert( 1 <= decl->params.size() );
        assert( 1 == decl->returns.size() );
        assert( decl->stmts );

        const CodeLocation& location = (decl->stmts->kids.empty())
                ? decl->stmts->location : decl->stmts->kids.back()->location;
        const ast::DeclWithType * thisParam = decl->params.front();
        decl->stmts.get_and_mutate()->push_back(
                new ast::ReturnStmt( location,
                        new ast::VariableExpr( location, thisParam )
                )
        );
}

void FuncGenerator::genStandardFuncs() {
        // The order here determines the order that these functions are generated.
        // Assignment should come last since it uses copy constructor in return.
        ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
                        &FuncGenerator::genCtorProto, &FuncGenerator::genCopyProto,
                        &FuncGenerator::genDtorProto, &FuncGenerator::genAssignProto };
        for ( auto & generator : standardProtos ) {
                ast::FunctionDecl * decl = (this->*generator)();
                genFuncBody( decl );
                if ( CodeGen::isAssignment( decl->name ) ) {
                        appendReturnThis( decl );
                }
                produceDecl( decl );
        }
}

void StructFuncGenerator::genFieldCtors() {
        // The field constructors are only generated if the default constructor
        // and copy constructor are both generated, since the need both.
        unsigned numCtors = std::count_if( definitions.begin(), definitions.end(),
                [](const ast::Decl * decl){ return CodeGen::isConstructor( decl->name ); }
        );
        if ( 2 != numCtors ) return;

        for ( unsigned int num = 1 ; num <= decl->members.size() ; ++num ) {
                ast::FunctionDecl * ctor = genFieldCtorProto( num );
                if ( nullptr == ctor ) {
                        continue;
                }
                makeFieldCtorBody( decl->members.begin(), decl->members.end(), ctor );
                produceDecl( ctor );
        }
}

void StructFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
        // Generate appropriate calls to member constructors and assignment.
        // Destructor needs to do everything in reverse,
        // so pass "forward" based on whether the function is a destructor
        if ( CodeGen::isDestructor( functionDecl->name ) ) {
                makeFunctionBody( decl->members.rbegin(), decl->members.rend(),
                        functionDecl, SymTab::LoopBackward );
        } else {
                makeFunctionBody( decl->members.begin(), decl->members.end(),
                        functionDecl, SymTab::LoopForward );
        }
}

const ast::Stmt * StructFuncGenerator::makeMemberOp(
                const CodeLocation& location, const ast::ObjectDecl * dstParam,
                const ast::Expr * src, const ast::ObjectDecl * field,
                ast::FunctionDecl * func, SymTab::LoopDirection direction ) {
        InitTweak::InitExpander srcParam( src );
        // Assign to destination.
        ast::MemberExpr * dstSelect = new ast::MemberExpr(
                location,
                field,
                new ast::CastExpr(
                        location,
                        new ast::VariableExpr( location, dstParam ),
                        dstParam->type.strict_as<ast::ReferenceType>()->base
                )
        );
        const ast::Stmt * stmt = genImplicitCall(
                srcParam, dstSelect, location, func->name,
                field, direction
        );
        // This could return the above directly, except the generated code is
        // built using the structure's members and that means all the scoped
        // names (the forall parameters) are incorrect. This corrects them.
        if ( stmt && !decl->params.empty() ) {
                ast::DeclReplacer::TypeMap oldToNew;
                for ( auto pair : group_iterate( decl->params, func->type_params ) ) {
                        oldToNew.emplace( std::get<0>(pair), std::get<1>(pair) );
                }
                auto node = ast::DeclReplacer::replace( stmt, oldToNew );
                stmt = strict_dynamic_cast<const ast::Stmt *>( node );
        }
        return stmt;
}

template<typename Iterator>
void StructFuncGenerator::makeFunctionBody( Iterator current, Iterator end,
                ast::FunctionDecl * func, SymTab::LoopDirection direction ) {
        // Trying to get the best code location. Should probably use a helper or
        // just figure out what that would be given where this is called.
        assert( nullptr == func->stmts );
        const CodeLocation& location = func->location;

        ast::CompoundStmt * stmts = new ast::CompoundStmt( location );

        for ( ; current != end ; ++current ) {
                const ast::ptr<ast::Decl> & member = *current;
                auto field = member.as<ast::ObjectDecl>();
                if ( nullptr == field ) {
                        continue;
                }

                // Don't assign to constant members (but do construct/destruct them).
                if ( CodeGen::isAssignment( func->name ) ) {
                        // For array types we need to strip off the array layers.
                        const ast::Type * type = field->get_type();
                        while ( auto at = dynamic_cast<const ast::ArrayType *>( type ) ) {
                                type = at->base;
                        }
                        if ( type->is_const() ) {
                                continue;
                        }
                }

                assert( !func->params.empty() );
                const ast::ObjectDecl * dstParam =
                        func->params.front().strict_as<ast::ObjectDecl>();
                const ast::ObjectDecl * srcParam = nullptr;
                if ( 2 == func->params.size() ) {
                        srcParam = func->params.back().strict_as<ast::ObjectDecl>();
                }

                ast::MemberExpr * srcSelect = (srcParam) ? new ast::MemberExpr(
                        location, field, new ast::VariableExpr( location, srcParam )
                ) : nullptr;
                const ast::Stmt * stmt =
                        makeMemberOp( location, dstParam, srcSelect, field, func, direction );

                if ( nullptr != stmt ) {
                        stmts->kids.emplace_back( stmt );
                }
        }

        func->stmts = stmts;
}

template<typename Iterator>
void StructFuncGenerator::makeFieldCtorBody( Iterator current, Iterator end,
                ast::FunctionDecl * func ) {
        const CodeLocation& location = func->location;
        auto & params = func->params;
        // Need at least the constructed parameter and one field parameter.
        assert( 2 <= params.size() );

        ast::CompoundStmt * stmts = new ast::CompoundStmt( location );

        auto dstParam = params.front().strict_as<ast::ObjectDecl>();
        // Skip over the 'this' parameter.
        for ( auto param = params.begin() + 1 ; current != end ; ++current ) {
                const ast::ptr<ast::Decl> & member = *current;
                const ast::Stmt * stmt = nullptr;
                auto field = member.as<ast::ObjectDecl>();
                // Not sure why it could be null.
                // Don't make a function for a parameter that is an unnamed bitfield.
                if ( nullptr == field || ast::isUnnamedBitfield( field ) ) {
                        continue;
                // Matching Parameter: Initialize the field by copy.
                } else if ( params.end() != param ) {
                        const ast::Expr *srcSelect = new ast::VariableExpr(
                                func->location, param->get() );
                        stmt = makeMemberOp( location, dstParam, srcSelect, field, func, SymTab::LoopForward );
                        ++param;
                // No Matching Parameter: Initialize the field by default constructor.
                } else {
                        stmt = makeMemberOp( location, dstParam, nullptr, field, func, SymTab::LoopForward );
                }

                if ( nullptr != stmt ) {
                        stmts->kids.emplace_back( stmt );
                }
        }
        func->stmts = stmts;
}

void UnionFuncGenerator::genFieldCtors() {
        // Field constructors are only generated if default and copy constructor
        // are generated, since they need access to both
        unsigned numCtors = std::count_if( definitions.begin(), definitions.end(),
                []( const ast::Decl * d ){ return CodeGen::isConstructor( d->name ); }
        );
        if ( 2 != numCtors ) {
                return;
        }

        // Create a constructor which takes the first member type as a
        // parameter. For example for `union A { int x; char y; };` generate
        // a function with signature `void ?{}(A *, int)`. This mimics C's
        // behaviour which initializes the first member of the union.

        // Still, there must be some members.
        if ( !decl->members.empty() ) {
                ast::FunctionDecl * ctor = genFieldCtorProto( 1 );
                if ( nullptr == ctor ) {
                        return;
                }
                auto params = ctor->params;
                auto dstParam = params.front().strict_as<ast::ObjectDecl>();
                auto srcParam = params.back().strict_as<ast::ObjectDecl>();
                ctor->stmts = new ast::CompoundStmt( getLocation(),
                        { makeAssignOp( getLocation(), dstParam, srcParam ) }
                );
                produceDecl( ctor );
        }
}

void UnionFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
        const CodeLocation& location = functionDecl->location;
        auto & params = functionDecl->params;
        if ( InitTweak::isCopyConstructor( functionDecl )
                        || InitTweak::isAssignment( functionDecl ) ) {
                assert( 2 == params.size() );
                auto dstParam = params.front().strict_as<ast::ObjectDecl>();
                auto srcParam = params.back().strict_as<ast::ObjectDecl>();
                functionDecl->stmts = new ast::CompoundStmt( location,
                        { makeAssignOp( location, dstParam, srcParam ) }
                );
        } else {
                assert( 1 == params.size() );
                // Default constructor and destructor is empty.
                functionDecl->stmts = new ast::CompoundStmt( location );
        }
}

ast::ExprStmt * UnionFuncGenerator::makeAssignOp( const CodeLocation& location,
                const ast::ObjectDecl * dstParam, const ast::ObjectDecl * srcParam ) {
        return new ast::ExprStmt( location, new ast::UntypedExpr(
                location,
                new ast::NameExpr( location, "__builtin_memcpy" ),
                {
                        new ast::AddressExpr( location,
                                new ast::VariableExpr( location, dstParam ) ),
                        new ast::AddressExpr( location,
                                new ast::VariableExpr( location, srcParam ) ),
                        new ast::SizeofExpr( location, srcParam->type ),
                } ) );
}

void EnumFuncGenerator::genStandardFuncs() {
        // do everything FuncGenerator does except not make ForwardDecls
        ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
                &EnumFuncGenerator::genCtorProto, &EnumFuncGenerator::genCopyProto,
                &EnumFuncGenerator::genDtorProto, &EnumFuncGenerator::genAssignProto };

        for ( auto & generator : standardProtos ) {
                ast::FunctionDecl * decl = (this->*generator)();
                genFuncBody( decl );
                if ( CodeGen::isAssignment( decl->name ) ) {
                        appendReturnThis( decl );
                }
                produceDecl( decl );
        }
}

void EnumFuncGenerator::genFieldCtors() {
        // Enumerations to not have field constructors.
}

void EnumFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
        const CodeLocation& location = functionDecl->location;
        auto & params = functionDecl->params;
        if ( InitTweak::isCopyConstructor( functionDecl )
                        || InitTweak::isAssignment( functionDecl ) ) {
                assert( 2 == params.size() );
                auto dstParam = params.front().strict_as<ast::ObjectDecl>();
                auto srcParam = params.back().strict_as<ast::ObjectDecl>();

                /* This looks like a recursive call, but code-gen will turn it into
                 * a C-style assignment.
                 *
                 * This is still before function pointer type conversion,
                 * so this will have to do it manually.
                 *
                 * It will also reference the parent function declaration, creating
                 * a cycle for references. This also means that the ref-counts are
                 * now non-zero and the declaration will be deleted if it ever
                 * returns to zero.
                 */
                auto callExpr = new ast::ApplicationExpr( location,
                        ast::VariableExpr::functionPointer( location, functionDecl ),
                        {
                                new ast::VariableExpr( location, dstParam ),
                                new ast::VariableExpr( location, srcParam )
                        }
                );

                functionDecl->stmts = new ast::CompoundStmt( location,
                        { new ast::ExprStmt( location, callExpr ) }
                );
        } else {
                assert( 1 == params.size() );
                // Default constructor and destructor is empty.
                functionDecl->stmts = new ast::CompoundStmt( location );
        }
}

void TypeFuncGenerator::genFieldCtors() {
        // Opaque types do not have field constructors.
}

void TypeFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
        const CodeLocation& location = functionDecl->location;
        auto & params = functionDecl->type->params;
        assertf( 1 == params.size() || 2 == params.size(),
                "Incorrect number of parameters in autogenerated typedecl function: %zd",
                params.size() );
        auto dstParam = params.front().strict_as<ast::ObjectDecl>();
        auto srcParam = (2 == params.size())
                ? params.back().strict_as<ast::ObjectDecl>() : nullptr;
        // Generate appropriate calls to member constructor and assignment.
        ast::UntypedExpr * expr = new ast::UntypedExpr( location,
                new ast::NameExpr( location, functionDecl->name )
        );
        expr->args.push_back( new ast::CastExpr( location,
                new ast::VariableExpr( location, dstParam ),
                new ast::ReferenceType( decl->base )
        ) );
        if ( srcParam ) {
                expr->args.push_back( new ast::CastExpr( location,
                        new ast::VariableExpr( location, srcParam ),
                        decl->base
                ) );
        }
        functionDecl->stmts = new ast::CompoundStmt( location,
                { new ast::ExprStmt( location, expr ) }
        );
}

} // namespace

void autogenerateRoutines( ast::TranslationUnit & translationUnit ) {
        ast::Pass<AutogenerateRoutines>::run( translationUnit );
}

} // Validate

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //