Changes in / [c831073:8a2f7f1]

Location:

src

Files:

• AST/Inspect.cpp (modified) (2 diffs)
• AST/Inspect.hpp (modified) (2 diffs)
• AST/SymbolTable.cpp (modified) (4 diffs)
• AST/SymbolTable.hpp (modified) (1 diff)
• InitTweak/FixInitNew.cpp (modified) (8 diffs)
• InitTweak/GenInit.cc (modified) (1 diff)
• SymTab/Autogen.cc (modified) (4 diffs)
• SymTab/Autogen.h (modified) (8 diffs)
• SymTab/GenImplicitCall.cpp (deleted)
• SymTab/GenImplicitCall.hpp (deleted)
• SymTab/module.mk (modified) (1 diff)
• Validate/Autogen.cpp (modified) (3 diffs)

src/AST/Inspect.cpp

@@ -10 +10 @@
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Apr 14 15:09:00 2023
-// Update Count     : 4
+// Last Modified On : Mon Oct  3 11:04:00 2022
+// Update Count     : 3
 //
 
@@ -168 +168 @@
 }
 
-bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
-        return obj && obj->name.empty() && obj->bitfieldWidth;
-}
-
 } // namespace ast

src/AST/Inspect.hpp

@@ -10 +10 @@
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Apr 14 15:09:00 2023
-// Update Count     : 3
+// Last Modified On : Thr Sep 22 13:44:00 2022
+// Update Count     : 2
 //
 
@@ -38 +38 @@
 const ApplicationExpr * isIntrinsicCallExpr( const Expr * expr );
 
-/// Returns true if obj's name is the empty string and it has a bitfield width.
-bool isUnnamedBitfield( const ObjectDecl * obj );
-
 }

src/AST/SymbolTable.cpp

@@ -260 +260 @@
 void SymbolTable::addId( const DeclWithType * decl, const Expr * baseExpr ) {
         // default handling of conflicts is to raise an error
-        addIdCommon( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
 }
 
 void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) {
         // default handling of conflicts is to raise an error
-        addIdCommon( decl, OnConflict::error(), nullptr, deleter );
+        addId( decl, OnConflict::error(), nullptr, deleter );
 }
 
@@ -677 +677 @@
 }
 
-void SymbolTable::addIdCommon(
-                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts,
-                const Expr * baseExpr, const Decl * deleter ) {
+void SymbolTable::addId(
+                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
+                const Decl * deleter ) {
         SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
         if (kind == NUMBER_OF_KINDS) { // not a special decl
-                addIdToTable(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+                addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
         }
         else {
@@ -695 +695 @@
                         assertf(false, "special decl with non-function type");
                 }
-                addIdToTable(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
-        }
-}
-
-void SymbolTable::addIdToTable(
-                const DeclWithType * decl, const std::string & lookupKey,
-                IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts,
-                const Expr * baseExpr, const Decl * deleter ) {
+                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+
+void SymbolTable::addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
+                const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -779 +778 @@
 void SymbolTable::addMembers(
                 const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) {
-        for ( const ptr<Decl> & decl : aggr->members ) {
-                auto dwt = decl.as<DeclWithType>();
-                if ( nullptr == dwt ) continue;
-                addIdCommon( dwt, handleConflicts, expr );
-                // Inline through unnamed struct/union members.
-                if ( "" != dwt->name ) continue;
-                const Type * t = dwt->get_type()->stripReferences();
-                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
-                        if ( ! dynamic_cast<const StructInstType *>(rty)
-                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
-                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
-                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
-                        expr = mutate_field(expr, &Expr::env, nullptr);
-                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
-                        base = mutate_field(base, &Expr::env, tmp);
-
-                        addMembers(
-                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+        for ( const Decl * decl : aggr->members ) {
+                if ( auto dwt = dynamic_cast< const DeclWithType * >( decl ) ) {
+                        addId( dwt, handleConflicts, expr );
+                        if ( dwt->name == "" ) {
+                                const Type * t = dwt->get_type()->stripReferences();
+                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                                        if ( ! dynamic_cast<const StructInstType *>(rty)
+                                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
+                                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
+                                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
+                                        expr = mutate_field(expr, &Expr::env, nullptr);
+                                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
+                                        base = mutate_field(base, &Expr::env, tmp);
+
+                                        addMembers(
+                                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+                                }
+                        }
                 }
         }

src/AST/SymbolTable.hpp

@@ -192 +192 @@
 
         /// common code for addId, addDeletedId, etc.
-        void addIdCommon(
-                const DeclWithType * decl, OnConflict handleConflicts,
-                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr );
+        void addId(
+                const DeclWithType * decl, OnConflict handleConflicts, const Expr * baseExpr = nullptr,
+                const Decl * deleter = nullptr );
 
         /// common code for addId when special decls are placed into separate tables
-        void addIdToTable(
-                const DeclWithType * decl, const std::string & lookupKey,
-                IdTable::Ptr & idTable, OnConflict handleConflicts,
+        void addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts, 
                 const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
-
+        
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/InitTweak/FixInitNew.cpp

@@ -14 +14 @@
 #include <utility>                     // for pair
 
-#include "AST/DeclReplacer.hpp"
-#include "AST/Expr.hpp"
 #include "AST/Inspect.hpp"             // for getFunction, getPointerBase, g...
-#include "AST/Node.hpp"
-#include "AST/Pass.hpp"
-#include "AST/Print.hpp"
-#include "AST/SymbolTable.hpp"
-#include "AST/Type.hpp"
 #include "CodeGen/GenType.h"           // for genPrettyType
 #include "CodeGen/OperatorTable.h"
+#include "Common/CodeLocationTools.hpp"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
@@ -34 +28 @@
 #include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "SymTab/Autogen.h"            // for genImplicitCall
-#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
@@ -52 +45 @@
 #include "Validate/FindSpecialDecls.h" // for dtorStmt, dtorStructDestroy
 
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Print.hpp"
+#include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
+#include "AST/DeclReplacer.hpp"
+
 extern bool ctordtorp; // print all debug
 extern bool ctorp; // print ctor debug
@@ -62 +63 @@
 namespace InitTweak {
 namespace {
-
-        // Shallow copy the pointer list for return.
-        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams( const ast::Type * t ) {
-                if ( auto inst = dynamic_cast<const ast::StructInstType *>( t ) ) {
-                        return inst->base->params;
-                }
-                if ( auto inst = dynamic_cast<const ast::UnionInstType *>( t ) ) {
-                        return inst->base->params;
-                }
-                return {};
-        }
-
-        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
-        ast::FunctionDecl * genDefaultFunc(
-                        const CodeLocation loc,
-                        const std::string fname,
-                        const ast::Type * paramType,
-                        bool maybePolymorphic = true) {
-                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
-                if ( maybePolymorphic ) typeParams = getGenericParams( paramType );
-                auto dstParam = new ast::ObjectDecl( loc,
-                        "_dst",
-                        new ast::ReferenceType( paramType ),
-                        nullptr,
-                        {},
-                        ast::Linkage::Cforall
-                );
-                return new ast::FunctionDecl( loc,
-                        fname,
-                        std::move(typeParams),
-                        {dstParam},
-                        {},
-                        new ast::CompoundStmt(loc),
-                        {},
-                        ast::Linkage::Cforall
-                );
-        }
-
         struct SelfAssignChecker {
                 void previsit( const ast::ApplicationExpr * appExpr );
@@ -158 +121 @@
                 void previsit( const ast::FunctionDecl * ) { visit_children = false; }
 
-        protected:
+          protected:
                 ObjectSet curVars;
         };
@@ -239 +202 @@
 
                 SemanticErrorException errors;
-        private:
+          private:
                 template< typename... Params >
                 void emit( CodeLocation, const Params &... params );
@@ -325 +288 @@
                 static UniqueName dtorNamer( "__cleanup_dtor" );
                 std::string name = dtorNamer.newName();
-                ast::FunctionDecl * dtorFunc = genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
+                ast::FunctionDecl * dtorFunc = SymTab::genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
                 stmtsToAdd.push_back( new ast::DeclStmt(loc, dtorFunc ) );
 
@@ -1117 +1080 @@
         void InsertDtors::previsit( const ast::BranchStmt * stmt ) {
                 switch( stmt->kind ) {
-                case ast::BranchStmt::Continue:
-                case ast::BranchStmt::Break:
+                  case ast::BranchStmt::Continue:
+                  case ast::BranchStmt::Break:
                         // could optimize the break/continue case, because the S_L-S_G check is unnecessary (this set should
                         // always be empty), but it serves as a small sanity check.
-                case ast::BranchStmt::Goto:
+                  case ast::BranchStmt::Goto:
                         handleGoto( stmt );
                         break;
-                default:
+                  default:
                         assert( false );
                 } // switch

src/InitTweak/GenInit.cc

@@ -39 +39 @@
 #include "ResolvExpr/Resolver.h"
 #include "SymTab/Autogen.h"            // for genImplicitCall
-#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"            // for Mangler
 #include "SynTree/LinkageSpec.h"       // for isOverridable, C

src/SymTab/Autogen.cc

@@ -10 +10 @@
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 14 15:03:00 2023
-// Update Count     : 64
+// Last Modified On : Fri Apr 27 14:39:06 2018
+// Update Count     : 63
 //
 
@@ -211 +211 @@
         }
 
+        bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
+                return obj && obj->name.empty() && obj->bitfieldWidth;
+        }
+
         /// inserts a forward declaration for functionDecl into declsToAdd
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
@@ -230 +234 @@
         }
 
+        // shallow copy the pointer list for return
+        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams (const ast::Type * t) {
+                if (auto structInst = dynamic_cast<const ast::StructInstType*>(t)) {
+                        return structInst->base->params;
+                }
+                if (auto unionInst = dynamic_cast<const ast::UnionInstType*>(t)) {
+                        return unionInst->base->params;
+                }
+                return {};
+        }
+
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
@@ -241 +256 @@
                 ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
+
+        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
+        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
+                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
+                if (maybePolymorphic) typeParams = getGenericParams(paramType);
+                auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
+                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc), {}, ast::Linkage::Cforall);
         }
 

src/SymTab/Autogen.h

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Sun May 17 21:53:34 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Apr 14 15:06:00 2023
-// Update Count     : 17
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Dec 13 16:38:06 2019
+// Update Count     : 16
 //
 
@@ -45 +45 @@
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
+        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
 
         /// generate the type of an assignment function for paramType.
@@ -54 +55 @@
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
 
+        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic = true);
+
         /// generate the type of a copy constructor for paramType.
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
@@ -64 +67 @@
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
+
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
@@ -112 +121 @@
 
                 *out++ = new ExprStmt( fExpr );
+
+                srcParam.clearArrayIndices();
+
+                return listInit;
+        }
+
+        /// inserts into out a generated call expression to function fname with arguments dstParam and
+        /// srcParam. Should only be called with non-array types.
+        /// optionally returns a statement which must be inserted prior to the containing loop, if
+        /// there is one
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genScalarCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type,
+                const ast::Type * addCast = nullptr
+        ) {
+                bool isReferenceCtorDtor = false;
+                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
+                        // reference constructors are essentially application of the rebind operator.
+                        // apply & to both arguments, do not need a cast
+                        fname = "?=?";
+                        dstParam = new ast::AddressExpr{ dstParam };
+                        addCast = nullptr;
+                        isReferenceCtorDtor = true;
+                }
+
+                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
+                // "?=?", "?{}", or "^?{}"
+                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
+
+                if ( addCast ) {
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and
+                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue
+                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an
+                        // lvalue-qualified type, so remove all qualifiers except lvalue.
+                        // xxx -- old code actually removed lvalue too...
+                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
+                        ast::ptr< ast::Type > castType = addCast;
+                        ast::remove_qualifiers(
+                                castType,
+                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
+                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
+                }
+                fExpr->args.emplace_back( dstParam );
+
+                ast::ptr<ast::Stmt> listInit = srcParam.buildListInit( fExpr );
+
+                // fetch next set of arguments
+                ++srcParam;
+
+                // return if adding reference fails -- will happen on default ctor and dtor
+                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
+
+                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
+                splice( fExpr->args, args );
+
+                *out++ = new ast::ExprStmt{ loc, fExpr };
 
                 srcParam.clearArrayIndices();
@@ -182 +248 @@
         }
 
+        /// Store in out a loop which calls fname on each element of the array with srcParam and
+        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
+        template< typename OutIter >
+        void genArrayCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
+                const ast::ArrayType * array, const ast::Type * addCast = nullptr,
+                LoopDirection forward = LoopForward
+        ) {
+                static UniqueName indexName( "_index" );
+
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->dimension ) return;
+
+                if ( addCast ) {
+                        // peel off array layer from cast
+                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
+                }
+
+                ast::ptr< ast::Expr > begin, end;
+                std::string cmp, update;
+
+                if ( forward ) {
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = ast::ConstantExpr::from_int( loc, 0 );
+                        end = array->dimension;
+                        cmp = "?<?";
+                        update = "++?";
+                } else {
+                        // generate: for ( int i = N-1; i >= 0; --i )
+                        begin = ast::UntypedExpr::createCall( loc, "?-?",
+                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } );
+                        end = ast::ConstantExpr::from_int( loc, 0 );
+                        cmp = "?>=?";
+                        update = "--?";
+                }
+
+                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{
+                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
+                        new ast::SingleInit{ loc, begin } };
+                ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
+
+                ast::ptr< ast::Expr > cond = ast::UntypedExpr::createCall(
+                        loc, cmp, { indexVar, end } );
+
+                ast::ptr< ast::Expr > inc = ast::UntypedExpr::createCall(
+                        loc, update, { indexVar } );
+
+                ast::ptr< ast::Expr > dstIndex = ast::UntypedExpr::createCall(
+                        loc, "?[?]", { dstParam, indexVar } );
+
+                // srcParam must keep track of the array indices to build the source parameter and/or
+                // array list initializer
+                srcParam.addArrayIndex( indexVar, array->dimension );
+
+                // for stmt's body, eventually containing call
+                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
+                ast::ptr< ast::Stmt > listInit = genCall(
+                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast,
+                        forward );
+
+                // block containing the stmt and index variable
+                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
+                block->push_back( new ast::DeclStmt{ loc, index } );
+                if ( listInit ) { block->push_back( listInit ); }
+                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
+
+                *out++ = block;
+        }
+
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
@@ -189 +325 @@
                 } else {
                         return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                }
+        }
+
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
+        ) {
+                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        genArrayCall(
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast,
+                                forward );
+                        return {};
+                } else {
+                        return genScalarCall(
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
                 }
         }
@@ -226 +379 @@
         }
 
+        static inline ast::ptr< ast::Stmt > genImplicitCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,
+                LoopDirection forward = LoopForward
+        ) {
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( isUnnamedBitfield( obj ) ) return {};
+
+                ast::ptr< ast::Type > addCast;
+                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
+                        assert( dstParam->result );
+                        addCast = dstParam->result;
+                }
+
+                std::vector< ast::ptr< ast::Stmt > > stmts;
+                genCall(
+                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
+
+                if ( stmts.empty() ) {
+                        return {};
+                } else if ( stmts.size() == 1 ) {
+                        const ast::Stmt * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are
+                                // aware they were generated.
+                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
+                        }
+                        return callStmt;
+                } else {
+                        assert( false );
+                        return {};
+                }
+        }
 } // namespace SymTab
 

src/SymTab/module.mk

@@ -20 +20 @@
         SymTab/FixFunction.cc \
         SymTab/FixFunction.h \
-        SymTab/GenImplicitCall.cpp \
-        SymTab/GenImplicitCall.hpp \
         SymTab/Indexer.cc \
         SymTab/Indexer.h \

src/Validate/Autogen.cpp

@@ -39 +39 @@
 #include "InitTweak/GenInit.h"     // for fixReturnStatements
 #include "InitTweak/InitTweak.h"   // for isAssignment, isCopyConstructor
-#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"        // for Mangler
 #include "CompilationState.h"
@@ -424 +423 @@
         for ( unsigned int index = 0 ; index < fields ; ++index ) {
                 auto member = aggr->members[index].strict_as<ast::DeclWithType>();
-                if ( ast::isUnnamedBitfield(
+                if ( SymTab::isUnnamedBitfield(
                                 dynamic_cast<const ast::ObjectDecl *>( member ) ) ) {
                         if ( index == fields - 1 ) {
@@ -600 +599 @@
                 // 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 ) ) {
+                if ( nullptr == field || SymTab::isUnnamedBitfield( field ) ) {
                         continue;
                 // Matching Parameter: Initialize the field by copy.