Changeset 68f9c43


Ignore:
Timestamp:
Mar 16, 2018, 5:15:02 PM (4 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
new-env, with_gc
Children:
8d7bef2
Parents:
6171841
git-author:
Aaron Moss <a3moss@…> (03/16/18 17:04:24)
git-committer:
Aaron Moss <a3moss@…> (03/16/18 17:15:02)
Message:

First pass at delete removal

Location:
src
Files:
4 added
79 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/Generate.cc

    r6171841 r68f9c43  
    4141                void cleanTree( std::list< Declaration * > & translationUnit ) {
    4242                        PassVisitor<TreeCleaner> cleaner;
    43                         filter( translationUnit, [](Declaration * decl) { return TreeCleaner::shouldClean(decl); }, false );
     43                        filter( translationUnit, [](Declaration * decl) { return TreeCleaner::shouldClean(decl); } );
    4444                        mutateAll( translationUnit, cleaner );
    4545                } // cleanTree
     
    7979                                }
    8080                                return false;
    81                         }, false );
     81                        } );
    8282                }
    8383
     
    8585                        Statement * callStmt = nullptr;
    8686                        std::swap( stmt->callStmt, callStmt );
    87                         delete stmt;
    8887                        return callStmt;
    8988                }
  • src/Common/PassVisitor.h

    r6171841 r68f9c43  
    152152        virtual void visit( Attribute * attribute ) override final;
    153153
     154        virtual void visit( TypeSubstitution * sub ) final;
     155
    154156        virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override final;
    155157        virtual DeclarationWithType * mutate( FunctionDecl * functionDecl ) override final;
  • src/Common/PassVisitor.impl.h

    r6171841 r68f9c43  
    25562556// TypeSubstitution
    25572557template< typename pass_type >
     2558void PassVisitor< pass_type >::visit( TypeSubstitution * node ) {
     2559        VISIT_START( node );
     2560
     2561        for ( auto & p : node->typeEnv ) {
     2562                indexerScopedAccept( p.second, *this );
     2563        }
     2564        for ( auto & p : node->varEnv ) {
     2565                indexerScopedAccept( p.second, *this );
     2566        }
     2567
     2568        VISIT_END( node );
     2569}
     2570
     2571template< typename pass_type >
    25582572TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
    25592573        MUTATE_START( node );
  • src/Common/module.mk

    r6171841 r68f9c43  
    1818       Common/UniqueName.cc \
    1919       Common/DebugMalloc.cc \
     20       Common/GC.cc \
    2021       Common/Assert.cc
  • src/Common/utility.h

    r6171841 r68f9c43  
    190190
    191191template <typename E, typename UnaryPredicate, template< typename, typename...> class Container, typename... Args >
    192 void filter( Container< E *, Args... > & container, UnaryPredicate pred, bool doDelete ) {
     192void filter( Container< E *, Args... > & container, UnaryPredicate pred ) {
    193193        auto i = begin( container );
    194194        while ( i != end( container ) ) {
    195195                auto it = next( i );
    196196                if ( pred( *i ) ) {
    197                         if ( doDelete ) {
    198                                 delete *i;
    199                         } // if
    200197                        container.erase( i );
    201198                } // if
  • src/Concurrency/Keywords.cc

    r6171841 r68f9c43  
    291291                StructDecl * forward = decl->clone();
    292292                forward->set_body( false );
    293                 deleteAll( forward->get_members() );
    294293                forward->get_members().clear();
    295294
     
    355354                        fixupGenerics(main_type, decl);
    356355                }
    357 
    358                 delete this_decl;
    359356
    360357                declsToAddBefore.push_back( forward );
  • src/Concurrency/Waitfor.cc

    r6171841 r68f9c43  
    476476                }
    477477
    478                 delete setter;
    479 
    480478                return new VariableExpr( timeout );
    481479        }
  • src/ControlStruct/ExceptTranslate.cc

    r6171841 r68f9c43  
    204204                call->get_args().push_back( throwStmt->get_expr() );
    205205                throwStmt->set_expr( nullptr );
    206                 delete throwStmt;
    207206                return new ExprStmt( call );
    208207        }
     
    234233                        new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
    235234                        ) );
    236                 delete throwStmt;
    237235                return result;
    238236        }
     
    251249                        );
    252250                result->labels = throwStmt->labels;
    253                 delete throwStmt;
    254251                return result;
    255252        }
     
    384381                modded_handler->set_cond( nullptr );
    385382                modded_handler->set_body( nullptr );
    386                 delete modded_handler;
    387383                return block;
    388384        }
     
    530526                CompoundStmt * body = finally->get_block();
    531527                finally->set_block( nullptr );
    532                 delete finally;
    533528                tryStmt->set_finally( nullptr );
    534529
  • src/ControlStruct/MLEMutator.cc

    r6171841 r68f9c43  
    151151
    152152                // transform break/continue statements into goto to simplify later handling of branches
    153                 delete branchStmt;
    154153                return new BranchStmt( exitLabel, BranchStmt::Goto );
    155154        }
  • src/GenPoly/Box.cc

    r6171841 r68f9c43  
    860860                        // do not carry over attributes to real type parameters/return values
    861861                        for ( DeclarationWithType * dwt : realType->parameters ) {
    862                                 deleteAll( dwt->get_type()->attributes );
    863862                                dwt->get_type()->attributes.clear();
    864863                        }
    865864                        for ( DeclarationWithType * dwt : realType->returnVals ) {
    866                                 deleteAll( dwt->get_type()->attributes );
    867865                                dwt->get_type()->attributes.clear();
    868866                        }
     
    985983                        } // if
    986984                        appExpr->get_args().clear();
    987                         delete appExpr;
    988985                        return addAssign;
    989986                }
     
    10161013                                                } // if
    10171014                                                if ( baseType1 || baseType2 ) {
    1018                                                         delete ret->get_result();
    10191015                                                        ret->set_result( appExpr->get_result()->clone() );
    10201016                                                        if ( appExpr->get_env() ) {
     
    10231019                                                        } // if
    10241020                                                        appExpr->get_args().clear();
    1025                                                         delete appExpr;
    10261021                                                        return ret;
    10271022                                                } // if
     
    10331028                                                        Expression *ret = appExpr->get_args().front();
    10341029                                                        // fix expr type to remove pointer
    1035                                                         delete ret->get_result();
    10361030                                                        ret->set_result( appExpr->get_result()->clone() );
    10371031                                                        if ( appExpr->get_env() ) {
     
    10401034                                                        } // if
    10411035                                                        appExpr->get_args().clear();
    1042                                                         delete appExpr;
    10431036                                                        return ret;
    10441037                                                } // if
     
    11801173                                                Expression *ret = expr->args.front();
    11811174                                                expr->args.clear();
    1182                                                 delete expr;
    11831175                                                return ret;
    11841176                                        } // if
     
    12141206                        if ( polytype || needs ) {
    12151207                                Expression *ret = addrExpr->arg;
    1216                                 delete ret->result;
    12171208                                ret->result = addrExpr->result->clone();
    12181209                                addrExpr->arg = nullptr;
    1219                                 delete addrExpr;
    12201210                                return ret;
    12211211                        } else {
     
    12271217                        if ( retval && returnStmt->expr ) {
    12281218                                assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
    1229                                 delete returnStmt->expr;
    12301219                                returnStmt->expr = nullptr;
    12311220                        } // if
     
    12701259                                }
    12711260                        }
    1272 //  deleteAll( functions );
    12731261                }
    12741262
     
    12901278                        for ( Declaration * param : functionDecl->type->parameters ) {
    12911279                                if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( param ) ) {
    1292                                         delete obj->init;
    12931280                                        obj->init = nullptr;
    12941281                                }
     
    14991486                                                        // polymorphic aggregate members should be converted into monomorphic members.
    15001487                                                        // Using char[size_T] here respects the expected sizing rules of an aggregate type.
    1501                                                         Type * newType = polyToMonoType( field->type );
    1502                                                         delete field->type;
    1503                                                         field->type = newType;
     1488                                                        field->type = polyToMonoType( field->type );
    15041489                                                }
    15051490                                        }
     
    15241509                                        stmtsToAddBefore.push_back( new DeclStmt( newBuf ) );
    15251510
    1526                                         delete objectDecl->get_init();
    15271511                                        objectDecl->set_init( new SingleInit( new VariableExpr( newBuf ) ) );
    15281512                                }
     
    16031587                        }
    16041588
    1605                         delete memberType;
    1606                         delete memberExpr;
    16071589                        return newMemberExpr;
    16081590                }
     
    16241606                                                addrExpr->arg = nullptr;
    16251607                                                std::swap( addrExpr->env, ret->env );
    1626                                                 delete addrExpr;
    16271608                                                return ret;
    16281609                                        }
     
    17501731                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
    17511732                        if ( findGeneric( ty ) ) {
    1752                                 Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
    1753                                 delete sizeofExpr;
    1754                                 return ret;
     1733                                return new NameExpr( sizeofName( mangleType( ty ) ) );
    17551734                        }
    17561735                        return sizeofExpr;
     
    17601739                        Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
    17611740                        if ( findGeneric( ty ) ) {
    1762                                 Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
    1763                                 delete alignofExpr;
    1764                                 return ret;
     1741                                return new NameExpr( alignofName( mangleType( ty ) ) );
    17651742                        }
    17661743                        return alignofExpr;
     
    17771754                                if ( i == -1 ) return offsetofExpr;
    17781755
    1779                                 Expression *offsetInd = makeOffsetIndex( ty, i );
    1780                                 delete offsetofExpr;
    1781                                 return offsetInd;
     1756                                return makeOffsetIndex( ty, i );
    17821757                        } else if ( dynamic_cast< UnionInstType* >( ty ) ) {
    17831758                                // all union members are at offset zero
    1784                                 delete offsetofExpr;
    17851759                                return new ConstantExpr( Constant::from_ulong( 0 ) );
    17861760                        } else return offsetofExpr;
     
    18221796                        }
    18231797
    1824                         delete offsetPackExpr;
    18251798                        return ret;
    18261799                }
  • src/GenPoly/InstantiateGeneric.cc

    r6171841 r68f9c43  
    5858
    5959                TypeList& operator= ( const TypeList &that ) {
    60                         deleteAll( params );
    61 
    6260                        params.clear();
    6361                        cloneAll( that.params, params );
     
    6765
    6866                TypeList& operator= ( TypeList &&that ) {
    69                         deleteAll( params );
    70 
    7167                        params = std::move( that.params );
    7268
     
    7470                }
    7571
    76                 ~TypeList() { deleteAll( params ); }
     72                ~TypeList() {}
    7773
    7874                bool operator== ( const TypeList& that ) const {
     
    293289        /// Strips the instances's type parameters
    294290        void stripInstParams( ReferenceToType *inst ) {
    295                 deleteAll( inst->get_parameters() );
    296291                inst->get_parameters().clear();
    297292        }
     
    300295                substituteMembers( base->get_members(), baseParams, typeSubs );
    301296
    302                 // xxx - can't delete type parameters because they may have assertions that are used
    303                 // deleteAll( baseParams );
    304297                baseParams.clear();
    305298
     
    380373                        newInst->set_baseStruct( concDecl );
    381374
    382                         delete inst;
    383375                        inst = newInst;
    384376                        break;
     
    390382                }
    391383
    392                 deleteAll( typeSubs );
    393384                return inst;
    394385        }
     
    430421                        newInst->set_baseUnion( concDecl );
    431422
    432                         delete inst;
    433423                        inst = newInst;
    434424                        break;
     
    439429                }
    440430
    441                 deleteAll( typeSubs );
    442431                return inst;
    443432        }
     
    477466                        ResolvExpr::adjustExprType( ret->result ); // pointer decay
    478467                        std::swap( ret->env, memberExpr->env );
    479                         delete memberExpr;
    480468                        return ret;
    481469                }
  • src/GenPoly/Lvalue.cc

    r6171841 r68f9c43  
    5050                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() );
    5151                                ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
    52                                 delete ret->result;
    5352                                ret->result = base->clone();
    5453                                ret->result->set_lvalue( true );
     
    171170                                        return ret;
    172171                                }
    173                                 delete result;
    174172                        }
    175173                        return appExpr;
     
    214212                                                        Type * baseType = InitTweak::getPointerBase( arg->get_result() );
    215213                                                        assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
    216                                                         PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
    217                                                         delete arg->get_result();
    218                                                         arg->set_result( ptrType );
     214                                                        arg->set_result( new PointerType{ Type::Qualifiers(), baseType->clone() } );
    219215                                                        arg = mkDeref( arg );
    220216                                                }
     
    294290                                                )
    295291                                                callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
    296                                                 delete callExpr->get_result();
    297292                                                callExpr->set_result( refType->clone() );
    298293                                                // move environment out to new top-level
     
    300295                                                castExpr->set_arg( nullptr );
    301296                                                castExpr->set_env( nullptr );
    302                                                 delete castExpr;
    303297                                                return callExpr;
    304298                                        }
     
    318312                                                }
    319313                                                ret->env = castExpr->env;
    320                                                 delete ret->result;
    321314                                                ret->result = castExpr->result;
    322315                                                ret->result->set_lvalue( true ); // ensure result is lvalue
     
    324317                                                castExpr->arg = nullptr;
    325318                                                castExpr->result = nullptr;
    326                                                 delete castExpr;
    327319                                                return ret;
    328320                                        } else if ( diff > 0 ) {
     
    333325                                                }
    334326                                                ret->env = castExpr->env;
    335                                                 delete ret->result;
    336327                                                ret->result = castExpr->result;
    337328                                                castExpr->env = nullptr;
    338329                                                castExpr->arg = nullptr;
    339330                                                castExpr->result = nullptr;
    340                                                 delete castExpr;
    341331                                                return ret;
    342332                                        }
     
    360350                                        }
    361351                                        ret->env = castExpr->env;
    362                                         delete ret->result;
    363352                                        ret->result = castExpr->result;
    364353                                        castExpr->env = nullptr;
    365354                                        castExpr->arg = nullptr;
    366355                                        castExpr->result = nullptr;
    367                                         delete castExpr;
    368356                                        return ret;
    369357                                } else {
     
    390378                                        ret->result->set_lvalue( true );  // ensure result is lvalue
    391379                                        castExpr->arg = nullptr;
    392                                         delete castExpr;
    393380                                } else {
    394381                                        // must keep cast if types are different
     
    407394                        Type::Qualifiers qualifiers = refType->get_qualifiers();
    408395                        refType->set_base( nullptr );
    409                         delete refType;
    410396                        return new PointerType( qualifiers, base );
    411397                }
     
    419405                                ret->set_env( expr->get_env() );
    420406                                expr->set_env( nullptr );
    421                                 delete expr;
    422407                                return ret;
    423408                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
     
    428413                                ret->set_env( expr->get_env() );
    429414                                expr->set_env( nullptr );
    430                                 delete expr;
    431415
    432416                                // conditional expr type may not be either of the argument types, need to unify
     
    461445                                        arg0 = nullptr;
    462446                                        addrExpr->set_env( nullptr );
    463                                         delete addrExpr;
    464447                                        return ret;
    465448                                }
     
    491474                                                addrExpr->set_arg( nullptr );
    492475                                                appExpr->set_env( nullptr );
    493                                                 delete appExpr;
    494476                                                return ret;
    495477                                        }
  • src/GenPoly/ScrubTyVars.cc

    r6171841 r68f9c43  
    2828                if ( ! tyVars ) {
    2929                        if ( typeInst->get_isFtype() ) {
    30                                 delete typeInst;
    31                                 return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
     30                                return new PointerType{ Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) };
    3231                        } else {
    33                                 PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
    34                                 delete typeInst;
    35                                 return ret;
     32                                return new PointerType{ Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) };
    3633                        }
    3734                }
     
    4239                          case TypeDecl::Dtype:
    4340                          case TypeDecl::Ttype:
    44                                 {
    45                                         PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
    46                                         delete typeInst;
    47                                         return ret;
    48                                 }
     41                                return new PointerType{ Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) };
    4942                          case TypeDecl::Ftype:
    50                                 delete typeInst;
    51                                 return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
     43                                return new PointerType{ Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) };
    5244                        } // switch
    5345                } // if
     
    5749        Type * ScrubTyVars::mutateAggregateType( Type * ty ) {
    5850                if ( shouldScrub( ty ) ) {
    59                         PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
    60                         delete ty;
    61                         return ret;
     51                        return new PointerType{ Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) };
    6252                }
    6353                return ty;
     
    10494                        Type * ret = dynType->acceptMutator( *visitor );
    10595                        ret->get_qualifiers() |= pointer->get_qualifiers();
    106                         pointer->base = nullptr;
    107                         delete pointer;
    10896                        return ret;
    10997                }
  • src/GenPoly/Specialize.cc

    r6171841 r68f9c43  
    193193                                explodeSimple( new TupleIndexExpr( expr->clone(), i ), out );
    194194                        }
    195                         delete expr;
    196195                } else {
    197196                        // non-tuple type - output a clone of the expression
  • src/InitTweak/FixGlobalInit.cc

    r6171841 r68f9c43  
    5757                GlobalFixer & fixer = visitor.pass;
    5858                // don't need to include function if it's empty
    59                 if ( fixer.initFunction->get_statements()->get_kids().empty() ) {
    60                         delete fixer.initFunction;
    61                 } else {
     59                if ( ! fixer.initFunction->get_statements()->get_kids().empty() ) {
    6260                        translationUnit.push_back( fixer.initFunction );
    6361                } // if
    6462
    65                 if ( fixer.destroyFunction->get_statements()->get_kids().empty() ) {
    66                         delete fixer.destroyFunction;
    67                 } else {
     63                if ( ! fixer.destroyFunction->get_statements()->get_kids().empty() ) {
    6864                        translationUnit.push_back( fixer.destroyFunction );
    6965                } // if
     
    130126                                objDecl->set_init( NULL );
    131127                        } // if
    132                         delete ctorInit;
    133128                } // if
    134129        }
  • src/InitTweak/FixInit.cc

    r6171841 r68f9c43  
    454454                                resolved->env = nullptr;
    455455                        } // if
    456                         delete stmt;
    457456                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
    458457                                // fix newly generated StmtExpr
     
    554553                                result = result->clone();
    555554                                env->apply( result );
    556                                 if ( ! InitTweak::isConstructable( result ) ) {
    557                                         delete result;
    558                                         return;
    559                                 }
     555                                if ( ! InitTweak::isConstructable( result ) ) return;
    560556
    561557                                // create variable that will hold the result of the stmt expr
     
    652648                        std::swap( impCpCtorExpr->env, callExpr->env );
    653649                        assert( impCpCtorExpr->env == nullptr );
    654                         delete impCpCtorExpr;
    655650
    656651                        if ( returnDecl ) {
     
    711706                        if ( unqMap.count( unqExpr->get_id() ) ) {
    712707                                // take data from other UniqueExpr to ensure consistency
    713                                 delete unqExpr->get_expr();
    714708                                unqExpr->set_expr( unqMap[unqExpr->get_id()]->get_expr()->clone() );
    715                                 delete unqExpr->get_result();
    716709                                unqExpr->set_result( maybeClone( unqExpr->get_expr()->get_result() ) );
    717710                                if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
     
    824817                                                        // create a new object which is never used
    825818                                                        static UniqueName dummyNamer( "_dummy" );
    826                                                         ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
    827                                                         delete ctorInit;
    828                                                         return dummy;
     819                                                        return new ObjectDecl{
     820                                                                dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0,
     821                                                                new PointerType{ Type::Qualifiers(), new VoidType( Type::Qualifiers() ) },
     822                                                                0, std::list< Attribute * >{ new Attribute("unused") } };
    829823                                                }
    830824                                        } else {
     
    852846                                        objDecl->init = nullptr;
    853847                                } // if
    854                                 delete ctorInit;
    855848                        } // if
    856849                        return objDecl;
     
    12281221                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), callExpr->args.front()->result->clone(), nullptr );
    12291222                        declsToAddBefore.push_back( tmp );
    1230                         delete ctorExpr;
    12311223
    12321224                        // build assignment and replace constructor's first argument with new temporary
     
    12371229                        // resolve assignment and dispose of new env
    12381230                        ResolvExpr::findVoidExpression( assign, indexer );
    1239                         delete assign->env;
    12401231                        assign->env = nullptr;
    12411232
  • src/InitTweak/InitTweak.cc

    r6171841 r68f9c43  
    122122        public:
    123123                ExprImpl( Expression * expr ) : arg( expr ) {}
    124                 virtual ~ExprImpl() { delete arg; }
     124                virtual ~ExprImp() = default;
    125125
    126126                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
     
    166166
    167167        void InitExpander::clearArrayIndices() {
    168                 deleteAll( indices );
    169168                indices.clear();
    170169        }
     
    263262                build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
    264263                if ( block->get_kids().empty() ) {
    265                         delete block;
    266264                        return nullptr;
    267265                } else {
  • src/MakeLibCfa.cc

    r6171841 r68f9c43  
    6565                struct ZeroOneReplacer {
    6666                        ZeroOneReplacer( Type * t ) : type( t ) {}
    67                         ~ZeroOneReplacer() { delete type; }
    6867                        Type * type = nullptr;
    6968
    7069                        Type * common( Type * t ) {
    7170                                if ( ! type ) return t;
    72                                 delete t;
    7371                                return type->clone();
    7472                        }
  • src/Makefile.in

    r6171841 r68f9c43  
    163163        Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \
    164164        Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \
     165        Common/driver_cfa_cpp-GC.$(OBJEXT) \
    165166        Common/driver_cfa_cpp-Assert.$(OBJEXT) \
    166167        ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \
     
    249250        SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
    250251        SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
     252        SynTree/driver_cfa_cpp-GcTracer.$(OBJEXT) \
    251253        SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT) \
    252254        Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
     
    485487        CodeTools/TrackLoc.cc Concurrency/Keywords.cc \
    486488        Concurrency/Waitfor.cc Common/SemanticError.cc \
    487         Common/UniqueName.cc Common/DebugMalloc.cc Common/Assert.cc \
    488         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
    489         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
    490         ControlStruct/ForExprMutator.cc \
     489        Common/UniqueName.cc Common/DebugMalloc.cc Common/GC.cc \
     490        Common/Assert.cc ControlStruct/LabelGenerator.cc \
     491        ControlStruct/LabelFixer.cc ControlStruct/MLEMutator.cc \
     492        ControlStruct/Mutate.cc ControlStruct/ForExprMutator.cc \
    491493        ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
    492494        GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \
     
    526528        SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
    527529        SynTree/Initializer.cc SynTree/TypeSubstitution.cc \
    528         SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
    529         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
    530         Tuples/Explode.cc Virtual/ExpandCasts.cc
     530        SynTree/Attribute.cc SynTree/GcTracer.cc \
     531        SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \
     532        Tuples/TupleExpansion.cc Tuples/Explode.cc \
     533        Virtual/ExpandCasts.cc
    531534MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
    532535        ${cfa_cpplib_PROGRAMS}}
     
    670673        Common/$(DEPDIR)/$(am__dirstamp)
    671674Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
     675        Common/$(DEPDIR)/$(am__dirstamp)
     676Common/driver_cfa_cpp-GC.$(OBJEXT): Common/$(am__dirstamp) \
    672677        Common/$(DEPDIR)/$(am__dirstamp)
    673678Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \
     
    912917SynTree/driver_cfa_cpp-Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
    913918        SynTree/$(DEPDIR)/$(am__dirstamp)
     919SynTree/driver_cfa_cpp-GcTracer.$(OBJEXT): SynTree/$(am__dirstamp) \
     920        SynTree/$(DEPDIR)/$(am__dirstamp)
    914921SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT):  \
    915922        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
     
    973980@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@
    974981@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@
     982@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-GC.Po@am__quote@
    975983@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@
    976984@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@
     
    10451053@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-FunctionDecl.Po@am__quote@
    10461054@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-FunctionType.Po@am__quote@
     1055@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Po@am__quote@
    10471056@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Initializer.Po@am__quote@
    10481057@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-NamedTypeDecl.Po@am__quote@
     
    12941303@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi`
    12951304
     1305Common/driver_cfa_cpp-GC.o: Common/GC.cc
     1306@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-GC.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo -c -o Common/driver_cfa_cpp-GC.o `test -f 'Common/GC.cc' || echo '$(srcdir)/'`Common/GC.cc
     1307@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo Common/$(DEPDIR)/driver_cfa_cpp-GC.Po
     1308@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/GC.cc' object='Common/driver_cfa_cpp-GC.o' libtool=no @AMDEPBACKSLASH@
     1309@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1310@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-GC.o `test -f 'Common/GC.cc' || echo '$(srcdir)/'`Common/GC.cc
     1311
     1312Common/driver_cfa_cpp-GC.obj: Common/GC.cc
     1313@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-GC.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo -c -o Common/driver_cfa_cpp-GC.obj `if test -f 'Common/GC.cc'; then $(CYGPATH_W) 'Common/GC.cc'; else $(CYGPATH_W) '$(srcdir)/Common/GC.cc'; fi`
     1314@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-GC.Tpo Common/$(DEPDIR)/driver_cfa_cpp-GC.Po
     1315@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/GC.cc' object='Common/driver_cfa_cpp-GC.obj' libtool=no @AMDEPBACKSLASH@
     1316@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1317@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-GC.obj `if test -f 'Common/GC.cc'; then $(CYGPATH_W) 'Common/GC.cc'; else $(CYGPATH_W) '$(srcdir)/Common/GC.cc'; fi`
     1318
    12961319Common/driver_cfa_cpp-Assert.o: Common/Assert.cc
    12971320@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-Assert.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc
     
    24972520@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    24982521@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
     2522
     2523SynTree/driver_cfa_cpp-GcTracer.o: SynTree/GcTracer.cc
     2524@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-GcTracer.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo -c -o SynTree/driver_cfa_cpp-GcTracer.o `test -f 'SynTree/GcTracer.cc' || echo '$(srcdir)/'`SynTree/GcTracer.cc
     2525@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Po
     2526@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/GcTracer.cc' object='SynTree/driver_cfa_cpp-GcTracer.o' libtool=no @AMDEPBACKSLASH@
     2527@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2528@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-GcTracer.o `test -f 'SynTree/GcTracer.cc' || echo '$(srcdir)/'`SynTree/GcTracer.cc
     2529
     2530SynTree/driver_cfa_cpp-GcTracer.obj: SynTree/GcTracer.cc
     2531@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-GcTracer.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo -c -o SynTree/driver_cfa_cpp-GcTracer.obj `if test -f 'SynTree/GcTracer.cc'; then $(CYGPATH_W) 'SynTree/GcTracer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/GcTracer.cc'; fi`
     2532@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-GcTracer.Po
     2533@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/GcTracer.cc' object='SynTree/driver_cfa_cpp-GcTracer.obj' libtool=no @AMDEPBACKSLASH@
     2534@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2535@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-GcTracer.obj `if test -f 'SynTree/GcTracer.cc'; then $(CYGPATH_W) 'SynTree/GcTracer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/GcTracer.cc'; fi`
    24992536
    25002537SynTree/driver_cfa_cpp-VarExprReplacer.o: SynTree/VarExprReplacer.cc
  • src/Parser/DeclarationNode.cc

    r6171841 r68f9c43  
    986986                                        obj->location = cur->location;
    987987                                        * out++ = obj;
    988                                         delete agg;
    989988                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    990989                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
  • src/Parser/ExpressionNode.cc

    r6171841 r68f9c43  
    427427        Type * targetType = maybeMoveBuildType( decl_node );
    428428        if ( dynamic_cast< VoidType * >( targetType ) ) {
    429                 delete targetType;
    430429                return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
    431430        } else {
     
    451450
    452451Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
    453         Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
    454         delete member;
    455         return ret;
     452        return new UntypedOffsetofExpr{ maybeMoveBuildType( decl_node ), member->get_name() };
    456453} // build_offsetOf
    457454
  • src/ResolvExpr/AdjustExprType.cc

    r6171841 r68f9c43  
    6666
    6767        Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
    68                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
    69                 arrayType->base = nullptr;
    70                 delete arrayType;
    71                 return pointerType;
     68                return new PointerType{ arrayType->get_qualifiers(), arrayType->base };
    7269        }
    7370
    7471        Type * AdjustExprType::postmutate( FunctionType * functionType ) {
    75                 return new PointerType( Type::Qualifiers(), functionType );
     72                return new PointerType{ Type::Qualifiers(), functionType };
    7673        }
    7774
     
    8077                if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
    8178                        if ( eqvClass.data.kind == TypeDecl::Ftype ) {
    82                                 PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
    83                                 return pointerType;
     79                                return new PointerType{ Type::Qualifiers(), typeInst };
    8480                        }
    8581                } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    8682                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
    8783                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
    88                                         PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
    89                                         return pointerType;
     84                                        return new PointerType{ Type::Qualifiers(), typeInst };
    9085                                } // if
    9186                        } // if
  • src/ResolvExpr/Alternative.cc

    r6171841 r68f9c43  
    3434        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost, const Cost &cvtCost )
    3535                : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
    36 
    37         Alternative::Alternative( const Alternative &other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), env( other.env ) {
    38         }
    39 
    40         Alternative &Alternative::operator=( const Alternative &other ) {
    41                 if ( &other == this ) return *this;
    42                 delete expr;
    43                 cost = other.cost;
    44                 cvtCost = other.cvtCost;
    45                 expr = maybeClone( other.expr );
    46                 env = other.env;
    47                 return *this;
    48         }
    49 
    50         Alternative::Alternative( Alternative && other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), env( other.env ) {
    51                 other.expr = nullptr;
    52         }
    53 
    54         Alternative & Alternative::operator=( Alternative && other ) {
    55                 if ( &other == this )  return *this;
    56                 delete expr;
    57                 cost = other.cost;
    58                 cvtCost = other.cvtCost;
    59                 expr = other.expr;
    60                 env = other.env;
    61                 other.expr = nullptr;
    62                 return *this;
    63         }
    64 
    65         Alternative::~Alternative() {
    66                 delete expr;
    67         }
    6836
    6937        void Alternative::print( std::ostream &os, Indenter indent ) const {
  • src/ResolvExpr/Alternative.h

    r6171841 r68f9c43  
    2929                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost );
    3030                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost, const Cost &cvtCost );
    31                 Alternative( const Alternative &other );
    32                 Alternative &operator=( const Alternative &other );
    33                 Alternative( Alternative && other );
    34                 Alternative &operator=( Alternative && other );
    35                 ~Alternative();
     31                Alternative( const Alternative &other ) = default;
     32                Alternative &operator=( const Alternative &other ) = default;
    3633
    3734                void print( std::ostream &os, Indenter indent = {} ) const;
    3835
    39                 /// Returns the stored expression, but released from management of this Alternative
    40                 Expression* release_expr() {
    41                         Expression* tmp = expr;
    42                         expr = nullptr;
    43                         return tmp;
    44                 }
    45 
    4636                Cost cost;
    4737                Cost cvtCost;
    48                 Expression *expr;
     38                Expression * expr;
    4939                TypeEnvironment env;
    5040        };
  • src/ResolvExpr/AlternativeFinder.cc

    r6171841 r68f9c43  
    165165                                        candidate->env.apply( newType );
    166166                                        mangleName = SymTab::Mangler::mangle( newType );
    167                                         delete newType;
    168167                                }
    169168                                std::map< std::string, PruneStruct >::iterator mapPlace = selected.find( mangleName );
     
    568567
    569568                                Expression *varExpr = data.combine( newerAlt.cvtCost );
    570                                 delete varExpr->get_result();
    571569                                varExpr->set_result( adjType->clone() );
    572570                                PRINT(
     
    585583                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
    586584                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
    587                         } else {
    588                                 delete adjType;
    589585                        }
    590586                }
     
    12641260                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
    12651261                        }
    1266                         delete argExpr;
    12671262                        assert( componentExprs.size() > 0 );
    12681263                        // produce the tuple of casts
     
    16001595                        alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt.expr->clone() ), alt.env, alt.cost ) );
    16011596                } // for
    1602                 delete newFirstArg;
    16031597        }
    16041598
  • src/ResolvExpr/ResolveTypeof.cc

    r6171841 r68f9c43  
    7070                        Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
    7171                        assert( newExpr->result && ! newExpr->result->isVoid() );
    72                         Type * newType = newExpr->result;
    73                         newExpr->result = nullptr;
    74                         delete typeofType;
    75                         delete newExpr;
    76                         return newType;
     72                        return newExpr->result;
    7773                } // if
    7874                return typeofType;
  • src/ResolvExpr/Resolver.cc

    r6171841 r68f9c43  
    138138                                        castExpr->arg = nullptr;
    139139                                        std::swap( expr->env, castExpr->env );
    140                                         delete castExpr;
    141140                                }
    142141                        }
     
    198197                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
    199198                        finishExpr( choice.expr, choice.env, untyped->env );
    200                         delete untyped;
    201199                        untyped = choice.expr;
    202200                        choice.expr = nullptr;
     
    244242                Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
    245243                finishExpr( newExpr, env, untyped->env );
    246                 delete untyped;
    247244                untyped = newExpr;
    248245        }
     
    418415                        caseStmt->condition = castExpr->arg;
    419416                        castExpr->arg = nullptr;
    420                         delete castExpr;
    421417                }
    422418        }
     
    700696                std::swap( initExpr->env, newExpr->env );
    701697                std::swap( initExpr->inferParams, newExpr->inferParams ) ;
    702                 delete initExpr;
    703698
    704699                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
     
    718713                                                        ce->set_arg( nullptr );
    719714                                                        std::swap( ce->env, newExpr->env );
    720                                                         delete ce;
    721715                                                }
    722716                                        }
     
    769763                // could not find valid constructor, or found an intrinsic constructor
    770764                // fall back on C-style initializer
    771                 delete ctorInit->get_ctor();
    772                 ctorInit->set_ctor( NULL );
    773                 delete ctorInit->get_dtor();
    774                 ctorInit->set_dtor( NULL );
     765                ctorInit->set_ctor( nullptr );
     766                ctorInit->set_dtor( nullptr );
    775767                maybeAccept( ctorInit->get_init(), *visitor );
    776768        }
     
    798790
    799791                // found a constructor - can get rid of C-style initializer
    800                 delete ctorInit->init;
    801792                ctorInit->init = nullptr;
    802793
     
    805796                // to clean up generated code.
    806797                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
    807                         delete ctorInit->ctor;
    808798                        ctorInit->ctor = nullptr;
    809799                }
    810800
    811801                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
    812                         delete ctorInit->dtor;
    813802                        ctorInit->dtor = nullptr;
    814803                }
  • src/ResolvExpr/TypeEnvironment.cc

    r6171841 r68f9c43  
    5959        EqvClass &EqvClass::operator=( const EqvClass &other ) {
    6060                if ( this == &other ) return *this;
    61                 delete type;
    6261                initialize( other, *this );
    6362                return *this;
    64         }
    65 
    66         EqvClass::~EqvClass() {
    67                 delete type;
    6863        }
    6964
     
    147142///         std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl;
    148143                                        sub.add( *theVar, newTypeInst );
    149                                         delete newTypeInst;
    150144                                } // if
    151145                        } // for
     
    188182                                        if ( secondClass->type ) {
    189183                                                if ( newClass.type ) {
    190                                                         Type *newType = combineFunc( newClass.type, secondClass->type );
    191                                                         delete newClass.type;
    192                                                         newClass.type = newType;
     184                                                        newClass.type = combineFunc( newClass.type, secondClass->type );
    193185                                                        newClass.allowWidening = newClass.allowWidening && secondClass->allowWidening;
    194186                                                } else {
  • src/ResolvExpr/TypeEnvironment.h

    r6171841 r68f9c43  
    6767                EqvClass( const EqvClass &other );
    6868                EqvClass &operator=( const EqvClass &other );
    69                 ~EqvClass();
    7069                void print( std::ostream &os, Indenter indent = {} ) const;
    7170        };
  • src/ResolvExpr/Unify.cc

    r6171841 r68f9c43  
    9999                findOpenVars( newSecond, openVars, closedVars, needAssertions, haveAssertions, true );
    100100
    101                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    102                 delete newFirst;
    103                 delete newSecond;
    104                 return result;
     101                return unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    105102        }
    106103
     
    123120///   newSecond->print( std::cerr );
    124121///   std::cerr << std::endl;
    125                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    126                 delete newFirst;
    127                 delete newSecond;
    128                 return result;
     122                return unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    129123        }
    130124
     
    176170                                        if ( common ) {
    177171                                                common->get_qualifiers() = Type::Qualifiers();
    178                                                 delete curClass.type;
    179172                                                curClass.type = common;
    180173                                                env.add( curClass );
     
    239232                                if ( common ) {
    240233                                        common->get_qualifiers() = Type::Qualifiers();
    241                                         delete class1.type;
    242234                                        class1.type = common;
    243235                                } // if
     
    272264                        env.add( newClass );
    273265                } // if
    274                 delete type1;
    275                 delete type2;
    276266                return result;
    277267        }
     
    282272                findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
    283273                Type *commonType = 0;
    284                 if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) {
    285                         if ( commonType ) {
    286                                 delete commonType;
    287                         } // if
    288                         return true;
    289                 } else {
    290                         return false;
    291                 } // if
     274                return unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType );
    292275        }
    293276
     
    544527                                        // expand ttype parameter into its actual type
    545528                                        if ( eqvClass.type ) {
    546                                                 delete typeInst;
    547529                                                return eqvClass.type->clone();
    548530                                        }
     
    569551                                dst.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
    570552                        }
    571                         delete dcl;
    572553                }
    573554        }
  • src/ResolvExpr/Unify.h

    r6171841 r68f9c43  
    6464        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
    6565                std::list< Type* > commonTypes;
    66                 if ( unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
    67                         deleteAll( commonTypes );
    68                         return true;
    69                 } else {
    70                         return false;
    71                 } // if
     66                return unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions, openVars, indexer, commonTypes );
    7267        }
    7368
  • src/SymTab/Autogen.cc

    r6171841 r68f9c43  
    214214        void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
    215215                FunctionDecl * decl = functionDecl->clone();
    216                 delete decl->statements;
    217216                decl->statements = nullptr;
    218217                declsToAdd.push_back( decl );
     
    333332                } catch ( SemanticErrorException err ) {
    334333                        // okay if decl does not resolve - that means the function should not be generated
    335                         delete dcl;
    336334                }
    337335        }
     
    373371                        // do not carry over field's attributes to parameter type
    374372                        Type * paramType = field->get_type()->clone();
    375                         deleteAll( paramType->attributes );
    376373                        paramType->attributes.clear();
    377374                        // add a parameter corresponding to this field
     
    383380                        resolve( ctor );
    384381                }
    385                 delete memCtorType;
    386382        }
    387383
     
    511507                        // do not carry over field's attributes to parameter type
    512508                        Type * paramType = field->get_type()->clone();
    513                         deleteAll( paramType->attributes );
    514509                        paramType->attributes.clear();
    515510                        // add a parameter corresponding to this field
     
    524519                        break;
    525520                }
    526                 delete memCtorType;
    527521        }
    528522
  • src/SymTab/Autogen.h

    r6171841 r68f9c43  
    9797                // return if adding reference fails - will happen on default constructor and destructor
    9898                if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
    99                         delete fExpr;
    10099                        return listInit;
    101100                }
  • src/SymTab/FixFunction.cc

    r6171841 r68f9c43  
    2828
    2929        DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) {
    30                 // can't delete function type because it may contain assertions, so transfer ownership to new object
    31                 ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
    32                 functionDecl->attributes.clear();
    33                 functionDecl->type = nullptr;
    34                 delete functionDecl;
    35                 return pointer;
     30                return new ObjectDecl{
     31                        functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr,
     32                        new PointerType{ Type::Qualifiers(), functionDecl->type },
     33                        nullptr, functionDecl->attributes };
    3634        }
    3735
     
    4240        Type * FixFunction::postmutate(ArrayType *arrayType) {
    4341                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
    44                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
    45                 arrayType->base = nullptr;
    46                 arrayType->dimension = nullptr;
    47                 delete arrayType;
    48                 return pointerType;
     42                return new PointerType{ arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic };
    4943        }
    5044
  • src/SymTab/Validate.cc

    r6171841 r68f9c43  
    310310                } // if
    311311                // Always remove the hoisted aggregate from the inner structure.
    312                 GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
     312                GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion ); } );
    313313        }
    314314
     
    365365                        // one void is the only thing in the list; remove it.
    366366                        if ( containsVoid ) {
    367                                 delete dwts.front();
    368367                                dwts.clear();
    369368                        }
     
    492491                                }
    493492                        }
    494                         deleteAll( td->assertions );
    495493                        td->assertions.clear();
    496494                } // for
     
    608606                                        // expand trait instance into all of its members
    609607                                        expandAssertions( traitInst, back_inserter( type->assertions ) );
    610                                         delete traitInst;
    611608                                } else {
    612609                                        // pass other assertions through
     
    682679                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
    683680                }
    684                 filter( translationUnit, isTypedef, true );
     681                filter( translationUnit, isTypedef );
    685682        }
    686683
     
    696693                                ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
    697694                        } else {
    698                                 deleteAll( ret->attributes );
    699695                                ret->attributes.clear();
    700696                        }
     
    709705                                mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
    710706                        } // if
    711                         delete typeInst;
    712707                        return ret;
    713708                } else {
     
    795790                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
    796791                        // replace the current object declaration with a function declaration
    797                         FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
    798                         objDecl->get_attributes().clear();
    799                         objDecl->set_type( nullptr );
    800                         delete objDecl;
    801                         return newDecl;
     792                        return new FunctionDecl{
     793                                objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(),
     794                                funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() };
    802795                } // if
    803796                return objDecl;
     
    823816                        } // if
    824817                        return false;
    825                 }, true);
     818                } );
    826819                return compoundStmt;
    827820        }
     
    831824        template<typename AggDecl>
    832825        AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
    833                 filter( aggDecl->members, isTypedef, true );
     826                filter( aggDecl->members, isTypedef );
    834827                return aggDecl;
    835828        }
     
    961954                static UniqueName indexName( "_compLit" );
    962955
    963                 ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
    964                 compLitExpr->set_result( nullptr );
    965                 compLitExpr->set_initializer( nullptr );
    966                 delete compLitExpr;
     956                ObjectDecl * tempvar = new ObjectDecl{
     957                        indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() };
    967958                declsToAddBefore.push_back( tempvar );                                  // add modified temporary to current block
    968959                return new VariableExpr( tempvar );
     
    1000991                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
    1001992                        ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
    1002                         deleteAll( retVals );
    1003993                        retVals.clear();
    1004994                        retVals.push_back( newRet );
     
    10411031                        if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( inner->arg ) ) {
    10421032                                if ( labels.count( nameExpr->name ) ) {
    1043                                         Label name = nameExpr->name;
    1044                                         delete addrExpr;
    1045                                         return new LabelAddressExpr( name );
     1033                                        return new LabelAddressExpr{ nameExpr->name };
    10461034                                }
    10471035                        }
  • src/SynTree/AddressExpr.cc

    r6171841 r68f9c43  
    5858}
    5959
    60 AddressExpr::~AddressExpr() {
    61         delete arg;
    62 }
    63 
    6460void AddressExpr::print( std::ostream &os, Indenter indent ) const {
    6561        os << "Address of:" << std::endl;
     
    7571}
    7672LabelAddressExpr::LabelAddressExpr( const LabelAddressExpr & other ) : Expression( other ), arg( other.arg ) {}
    77 LabelAddressExpr::~LabelAddressExpr() {}
    7873
    7974void LabelAddressExpr::print( std::ostream & os, Indenter ) const {
  • src/SynTree/AggregateDecl.cc

    r6171841 r68f9c43  
    3333        cloneAll( other.attributes, attributes );
    3434        body = other.body;
    35 }
    36 
    37 AggregateDecl::~AggregateDecl() {
    38         deleteAll( attributes );
    39         deleteAll( parameters );
    40         deleteAll( members );
    4135}
    4236
  • src/SynTree/ApplicationExpr.cc

    r6171841 r68f9c43  
    4343}
    4444
    45 ParamEntry::~ParamEntry() {
    46         delete actualType;
    47         delete formalType;
    48         delete expr;
    49 }
    50 
    5145ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
    5246        PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() );
     
    6155                Expression( other ), function( maybeClone( other.function ) ) {
    6256        cloneAll( other.args, args );
    63 }
    64 
    65 ApplicationExpr::~ApplicationExpr() {
    66         delete function;
    67         deleteAll( args );
    6857}
    6958
  • src/SynTree/ArrayType.cc

    r6171841 r68f9c43  
    3434}
    3535
    36 ArrayType::~ArrayType() {
    37         delete base;
    38         delete dimension;
    39 }
    40 
    4136void ArrayType::print( std::ostream &os, Indenter indent ) const {
    4237        Type::print( os, indent );
  • src/SynTree/AttrType.cc

    r6171841 r68f9c43  
    3737}
    3838
    39 AttrType::~AttrType() {
    40         delete expr;
    41         delete type;
    42 }
    43 
    4439void AttrType::print( std::ostream &os, Indenter indent ) const {
    4540        Type::print( os, indent );
  • src/SynTree/Attribute.cc

    r6171841 r68f9c43  
    2323Attribute::Attribute( const Attribute &other ) : name( other.name ) {
    2424        cloneAll( other.parameters, parameters );
    25 }
    26 
    27 Attribute::~Attribute() {
    28         deleteAll( parameters );
    2925}
    3026
  • src/SynTree/Attribute.h

    r6171841 r68f9c43  
    3636        Attribute( std::string name = "", const std::list< Expression * > & parameters = std::list< Expression * >() ) : name( name ), parameters( parameters ) {}
    3737        Attribute( const Attribute &other );
    38         virtual ~Attribute();
    3938
    4039        std::string get_name() const { return name; }
  • src/SynTree/BaseSyntaxNode.h

    r6171841 r68f9c43  
    1717
    1818#include "Common/CodeLocation.h"
     19#include "Common/GC.h"
    1920#include "Common/Indenter.h"
     21
    2022class Visitor;
    2123class Mutator;
    2224
    23 class BaseSyntaxNode {
    24   public:
     25class BaseSyntaxNode : GC_Object {
     26public:
    2527        CodeLocation location;
    26 
    27         virtual ~BaseSyntaxNode() {}
    2828
    2929        virtual BaseSyntaxNode * clone() const = 0;
  • src/SynTree/CommaExpr.cc

    r6171841 r68f9c43  
    3434}
    3535
    36 CommaExpr::~CommaExpr() {
    37         delete arg1;
    38         delete arg2;
    39 }
    40 
    4136void CommaExpr::print( std::ostream &os, Indenter indent ) const {
    4237        os << "Comma Expression:" << std::endl;
  • src/SynTree/CompoundStmt.cc

    r6171841 r68f9c43  
    6868}
    6969
    70 CompoundStmt::~CompoundStmt() {
    71         deleteAll( kids );
    72 }
    73 
    7470void CompoundStmt::print( std::ostream &os, Indenter indent ) const {
    7571        os << "CompoundStmt" << endl;
  • src/SynTree/Constant.cc

    r6171841 r68f9c43  
    2727        type = other.type->clone();
    2828}
    29 
    30 Constant::~Constant() { delete type; }
    3129
    3230Constant Constant::from_bool( bool b ) {
  • src/SynTree/Constant.h

    r6171841 r68f9c43  
    3030        Constant( Type * type, std::string rep, double val );
    3131        Constant( const Constant & other );
    32         virtual ~Constant();
    33 
     32       
    3433        virtual Constant * clone() const { return new Constant( *this ); }
    3534
  • src/SynTree/DeclStmt.cc

    r6171841 r68f9c43  
    2929}
    3030
    31 DeclStmt::~DeclStmt() {
    32         delete decl;
    33 }
    34 
    3531void DeclStmt::print( std::ostream &os, Indenter indent ) const {
    3632        assert( decl != 0 );
  • src/SynTree/Declaration.cc

    r6171841 r68f9c43  
    3838}
    3939
    40 Declaration::~Declaration() {
    41 }
    42 
    4340void Declaration::fixUniqueId() {
    4441        // don't need to set unique ID twice
     
    6865}
    6966
    70 AsmDecl::~AsmDecl() {
    71         delete stmt;
    72 }
    73 
    7467void AsmDecl::print( std::ostream &os, Indenter indent ) const {
    7568        stmt->print( os, indent );
  • src/SynTree/Declaration.h

    r6171841 r68f9c43  
    4545        Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
    4646        Declaration( const Declaration &other );
    47         virtual ~Declaration();
    4847
    4948        const std::string &get_name() const { return name; }
     
    8786        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
    8887        DeclarationWithType( const DeclarationWithType &other );
    89         virtual ~DeclarationWithType();
    90 
     88       
    9189        std::string get_mangleName() const { return mangleName; }
    9290        DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
     
    126124                                const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
    127125        ObjectDecl( const ObjectDecl &other );
    128         virtual ~ObjectDecl();
    129126
    130127        virtual Type * get_type() const override { return type; }
     
    156153                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
    157154        FunctionDecl( const FunctionDecl &other );
    158         virtual ~FunctionDecl();
    159155
    160156        virtual Type * get_type() const override { return type; }
     
    184180        NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
    185181        NamedTypeDecl( const NamedTypeDecl &other );
    186         virtual ~NamedTypeDecl();
    187182
    188183        Type *get_base() const { return base; }
     
    219214        TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init = nullptr );
    220215        TypeDecl( const TypeDecl &other );
    221         virtual ~TypeDecl();
    222216
    223217        Kind get_kind() const { return kind; }
     
    268262        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
    269263        AggregateDecl( const AggregateDecl &other );
    270         virtual ~AggregateDecl();
    271 
     264       
    272265        std::list<Declaration*>& get_members() { return members; }
    273266        std::list<TypeDecl*>& get_parameters() { return parameters; }
     
    353346        AsmDecl( AsmStmt *stmt );
    354347        AsmDecl( const AsmDecl &other );
    355         virtual ~AsmDecl();
    356348
    357349        AsmStmt *get_stmt() { return stmt; }
  • src/SynTree/DeclarationWithType.cc

    r6171841 r68f9c43  
    3434}
    3535
    36 DeclarationWithType::~DeclarationWithType() {
    37         deleteAll( attributes );
    38         delete asmName;
    39 }
    40 
    4136// Local Variables: //
    4237// tab-width: 4 //
  • src/SynTree/Expression.cc

    r6171841 r68f9c43  
    5252Expression::~Expression() {
    5353        delete env;
    54         delete result;
    5554}
    5655
     
    7473ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
    7574}
    76 
    77 ConstantExpr::~ConstantExpr() {}
    7875
    7976void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
     
    120117}
    121118
    122 VariableExpr::~VariableExpr() {
    123         // don't delete the declaration, since it points somewhere else in the tree
    124 }
    125 
    126119VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) {
    127120        VariableExpr * funcExpr = new VariableExpr( func );
     
    150143}
    151144
    152 SizeofExpr::~SizeofExpr() {
    153         delete expr;
    154         delete type;
    155 }
    156 
    157145void SizeofExpr::print( std::ostream &os, Indenter indent) const {
    158146        os << "Sizeof Expression on: ";
     
    176164}
    177165
    178 AlignofExpr::~AlignofExpr() {
    179         delete expr;
    180         delete type;
    181 }
    182 
    183166void AlignofExpr::print( std::ostream &os, Indenter indent) const {
    184167        os << "Alignof Expression on: ";
     
    196179UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr &other ) :
    197180        Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
    198 
    199 UntypedOffsetofExpr::~UntypedOffsetofExpr() {
    200         delete type;
    201 }
    202181
    203182void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
     
    217196        Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
    218197
    219 OffsetofExpr::~OffsetofExpr() {
    220         delete type;
    221 }
    222 
    223198void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
    224199        os << "Offsetof Expression on member " << member->name << " of ";
     
    234209OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
    235210
    236 OffsetPackExpr::~OffsetPackExpr() { delete type; }
    237 
    238211void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
    239212        os << "Offset pack expression on ";
     
    252225AttrExpr::AttrExpr( const AttrExpr &other ) :
    253226                Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
    254 }
    255 
    256 AttrExpr::~AttrExpr() {
    257         delete attr;
    258         delete expr;
    259         delete type;
    260227}
    261228
     
    280247
    281248CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
    282 }
    283 
    284 CastExpr::~CastExpr() {
    285         delete arg;
    286249}
    287250
     
    306269}
    307270
    308 VirtualCastExpr::~VirtualCastExpr() {
    309         delete arg;
    310 }
    311 
    312271void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
    313272        os << "Virtual Cast of:" << std::endl << indent+1;
     
    332291}
    333292
    334 UntypedMemberExpr::~UntypedMemberExpr() {
    335         delete aggregate;
    336         delete member;
    337 }
    338 
    339293void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
    340294        os << "Untyped Member Expression, with field: " << std::endl << indent+1;
     
    363317}
    364318
    365 MemberExpr::~MemberExpr() {
    366         // don't delete the member declaration, since it points somewhere else in the tree
    367         delete aggregate;
    368 }
    369 
    370319void MemberExpr::print( std::ostream &os, Indenter indent ) const {
    371320        os << "Member Expression, with field: " << std::endl;
     
    383332                Expression( other ), function( maybeClone( other.function ) ) {
    384333        cloneAll( other.args, args );
    385 }
    386 
    387 UntypedExpr::~UntypedExpr() {
    388         delete function;
    389         deleteAll( args );
    390334}
    391335
     
    436380}
    437381
    438 NameExpr::~NameExpr() {}
    439 
    440382void NameExpr::print( std::ostream &os, Indenter indent ) const {
    441383        os << "Name: " << get_name();
     
    450392LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
    451393                Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
    452 }
    453 
    454 LogicalExpr::~LogicalExpr() {
    455         delete arg1;
    456         delete arg2;
    457394}
    458395
     
    470407ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
    471408                Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
    472 }
    473 
    474 ConditionalExpr::~ConditionalExpr() {
    475         delete arg1;
    476         delete arg2;
    477         delete arg3;
    478409}
    479410
     
    513444ImplicitCopyCtorExpr::~ImplicitCopyCtorExpr() {
    514445        set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
    515         delete callExpr;
    516         deleteAll( tempDecls );
    517         deleteAll( returnDecls );
    518         deleteAll( dtors );
    519446}
    520447
     
    541468}
    542469
    543 ConstructorExpr::~ConstructorExpr() {
    544         delete callExpr;
    545 }
    546 
    547470void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
    548471        os <<  "Constructor Expression: " << std::endl << indent+1;
     
    559482
    560483CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
    561 
    562 CompoundLiteralExpr::~CompoundLiteralExpr() {
    563         delete initializer;
    564 }
    565484
    566485void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
     
    589508        cloneAll( other.dtors, dtors );
    590509}
    591 StmtExpr::~StmtExpr() {
    592         delete statements;
    593         deleteAll( dtors );
    594         deleteAll( returnDecls );
    595 }
    596510void StmtExpr::computeResult() {
    597511        assert( statements );
    598512        std::list< Statement * > & body = statements->kids;
    599         delete result;
    600513        result = nullptr;
    601514        if ( ! returnDecls.empty() ) {
     
    640553UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
    641554}
    642 UniqueExpr::~UniqueExpr() {
    643         delete expr;
    644         delete object;
    645         delete var;
    646 }
     555
    647556void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
    648557        os << "Unique Expression with id:" << id << std::endl << indent+1;
     
    657566InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {}
    658567InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {}
    659 InitAlternative::~InitAlternative() {
    660         delete type;
    661         delete designation;
    662 }
    663568
    664569UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts ) : expr( expr ), initAlts( initAlts ) {}
    665570UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {}
    666 UntypedInitExpr::~UntypedInitExpr() {
    667         delete expr;
    668 }
    669571
    670572void UntypedInitExpr::print( std::ostream & os, Indenter indent ) const {
     
    684586}
    685587InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}
    686 InitExpr::~InitExpr() {
    687         delete expr;
    688         delete designation;
    689 }
    690588
    691589void InitExpr::print( std::ostream & os, Indenter indent ) const {
     
    701599}
    702600DeletedExpr::DeletedExpr( const DeletedExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), deleteStmt( other.deleteStmt ) {}
    703 DeletedExpr::~DeletedExpr() {
    704         delete expr;
    705 }
    706601
    707602void DeletedExpr::print( std::ostream & os, Indenter indent ) const {
  • src/SynTree/Expression.h

    r6171841 r68f9c43  
    4141        ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
    4242        ParamEntry( const ParamEntry & other );
    43         ~ParamEntry();
    4443        ParamEntry & operator=( const ParamEntry & other );
    4544
     
    5352/// Expression is the root type for all expressions
    5453class Expression : public BaseSyntaxNode {
     54  protected:
     55        virtual ~Expression();
     56
    5557  public:
    5658        Type * result;
     
    6163        Expression();
    6264        Expression( const Expression & other );
    63         virtual ~Expression();
    6465
    6566        Type *& get_result() { return result; }
     
    8990        ApplicationExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
    9091        ApplicationExpr( const ApplicationExpr & other );
    91         virtual ~ApplicationExpr();
    9292
    9393        Expression * get_function() const { return function; }
     
    111111        UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
    112112        UntypedExpr( const UntypedExpr & other );
    113         virtual ~UntypedExpr();
    114113
    115114        Expression * get_function() const { return function; }
     
    136135        NameExpr( std::string name );
    137136        NameExpr( const NameExpr & other );
    138         virtual ~NameExpr();
    139137
    140138        const std::string & get_name() const { return name; }
     
    157155        AddressExpr( Expression * arg );
    158156        AddressExpr( const AddressExpr & other );
    159         virtual ~AddressExpr();
    160157
    161158        Expression * get_arg() const { return arg; }
     
    176173        LabelAddressExpr( const Label &arg );
    177174        LabelAddressExpr( const LabelAddressExpr & other );
    178         virtual ~LabelAddressExpr();
    179175
    180176        virtual LabelAddressExpr * clone() const { return new LabelAddressExpr( * this ); }
     
    192188        CastExpr( Expression * arg, Type * toType );
    193189        CastExpr( const CastExpr & other );
    194         virtual ~CastExpr();
    195190
    196191        Expression * get_arg() const { return arg; }
     
    210205        VirtualCastExpr( Expression * arg, Type * toType );
    211206        VirtualCastExpr( const VirtualCastExpr & other );
    212         virtual ~VirtualCastExpr();
    213207
    214208        Expression * get_arg() const { return arg; }
     
    229223        UntypedMemberExpr( Expression * member, Expression * aggregate );
    230224        UntypedMemberExpr( const UntypedMemberExpr & other );
    231         virtual ~UntypedMemberExpr();
    232225
    233226        Expression * get_member() const { return member; }
     
    251244        MemberExpr( DeclarationWithType * member, Expression * aggregate );
    252245        MemberExpr( const MemberExpr & other );
    253         virtual ~MemberExpr();
    254246
    255247        DeclarationWithType * get_member() const { return member; }
     
    272264        VariableExpr( DeclarationWithType * var );
    273265        VariableExpr( const VariableExpr & other );
    274         virtual ~VariableExpr();
    275266
    276267        DeclarationWithType * get_var() const { return var; }
     
    292283        ConstantExpr( Constant constant );
    293284        ConstantExpr( const ConstantExpr & other );
    294         virtual ~ConstantExpr();
    295285
    296286        Constant * get_constant() { return & constant; }
     
    316306        SizeofExpr( const SizeofExpr & other );
    317307        SizeofExpr( Type * type );
    318         virtual ~SizeofExpr();
    319308
    320309        Expression * get_expr() const { return expr; }
     
    341330        AlignofExpr( const AlignofExpr & other );
    342331        AlignofExpr( Type * type );
    343         virtual ~AlignofExpr();
    344332
    345333        Expression * get_expr() const { return expr; }
     
    364352        UntypedOffsetofExpr( Type * type, const std::string & member );
    365353        UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
    366         virtual ~UntypedOffsetofExpr();
    367354
    368355        std::string get_member() const { return member; }
     
    385372        OffsetofExpr( Type * type, DeclarationWithType * member );
    386373        OffsetofExpr( const OffsetofExpr & other );
    387         virtual ~OffsetofExpr();
    388374
    389375        Type * get_type() const { return type; }
     
    405391        OffsetPackExpr( StructInstType * type );
    406392        OffsetPackExpr( const OffsetPackExpr & other );
    407         virtual ~OffsetPackExpr();
    408393
    409394        StructInstType * get_type() const { return type; }
     
    427412        AttrExpr( const AttrExpr & other );
    428413        AttrExpr( Expression * attr, Type * type );
    429         virtual ~AttrExpr();
    430414
    431415        Expression * get_attr() const { return attr; }
     
    452436        LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true );
    453437        LogicalExpr( const LogicalExpr & other );
    454         virtual ~LogicalExpr();
    455438
    456439        bool get_isAnd() const { return isAnd; }
     
    478461        ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 );
    479462        ConditionalExpr( const ConditionalExpr & other );
    480         virtual ~ConditionalExpr();
    481463
    482464        Expression * get_arg1() const { return arg1; }
     
    501483        CommaExpr( Expression * arg1, Expression * arg2 );
    502484        CommaExpr( const CommaExpr & other );
    503         virtual ~CommaExpr();
    504485
    505486        Expression * get_arg1() const { return arg1; }
     
    521502        TypeExpr( Type * type );
    522503        TypeExpr( const TypeExpr & other );
    523         virtual ~TypeExpr();
    524504
    525505        Type * get_type() const { return type; }
     
    541521        AsmExpr( Expression * inout, Expression * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
    542522        AsmExpr( const AsmExpr & other );
    543         virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
    544523
    545524        Expression * get_inout() const { return inout; }
     
    563542/// along with a set of copy constructor calls, one for each argument.
    564543class ImplicitCopyCtorExpr : public Expression {
     544protected:
     545        virtual ~ImplicitCopyCtorExpr();
     546
    565547public:
    566548        ApplicationExpr * callExpr;
     
    571553        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
    572554        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
    573         virtual ~ImplicitCopyCtorExpr();
    574555
    575556        ApplicationExpr * get_callExpr() const { return callExpr; }
     
    593574        ConstructorExpr( Expression * callExpr );
    594575        ConstructorExpr( const ConstructorExpr & other );
    595         ~ConstructorExpr();
    596576
    597577        Expression * get_callExpr() const { return callExpr; }
     
    611591        CompoundLiteralExpr( Type * type, Initializer * initializer );
    612592        CompoundLiteralExpr( const CompoundLiteralExpr & other );
    613         virtual ~CompoundLiteralExpr();
    614593
    615594        Initializer * get_initializer() const { return initializer; }
     
    648627        UntypedTupleExpr( const std::list< Expression * > & exprs );
    649628        UntypedTupleExpr( const UntypedTupleExpr & other );
    650         virtual ~UntypedTupleExpr();
    651629
    652630        std::list<Expression*>& get_exprs() { return exprs; }
     
    665643        TupleExpr( const std::list< Expression * > & exprs );
    666644        TupleExpr( const TupleExpr & other );
    667         virtual ~TupleExpr();
    668645
    669646        std::list<Expression*>& get_exprs() { return exprs; }
     
    683660        TupleIndexExpr( Expression * tuple, unsigned int index );
    684661        TupleIndexExpr( const TupleIndexExpr & other );
    685         virtual ~TupleIndexExpr();
    686662
    687663        Expression * get_tuple() const { return tuple; }
     
    703679        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls );
    704680        TupleAssignExpr( const TupleAssignExpr & other );
    705         virtual ~TupleAssignExpr();
    706681
    707682        TupleAssignExpr * set_stmtExpr( StmtExpr * newValue ) { stmtExpr = newValue; return this; }
     
    723698        StmtExpr( CompoundStmt * statements );
    724699        StmtExpr( const StmtExpr & other );
    725         virtual ~StmtExpr();
    726700
    727701        CompoundStmt * get_statements() const { return statements; }
     
    748722        UniqueExpr( Expression * expr, long long idVal = -1 );
    749723        UniqueExpr( const UniqueExpr & other );
    750         ~UniqueExpr();
    751724
    752725        Expression * get_expr() const { return expr; }
     
    778751        InitAlternative( const InitAlternative & other );
    779752        InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it
    780         ~InitAlternative();
    781753};
    782754
     
    788760        UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
    789761        UntypedInitExpr( const UntypedInitExpr & other );
    790         ~UntypedInitExpr();
    791762
    792763        Expression * get_expr() const { return expr; }
     
    808779        InitExpr( Expression * expr, Designation * designation );
    809780        InitExpr( const InitExpr & other );
    810         ~InitExpr();
    811781
    812782        Expression * get_expr() const { return expr; }
     
    830800        DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt );
    831801        DeletedExpr( const DeletedExpr & other );
    832         ~DeletedExpr();
    833802
    834803        virtual DeletedExpr * clone() const { return new DeletedExpr( * this ); }
  • src/SynTree/FunctionDecl.cc

    r6171841 r68f9c43  
    5252        }
    5353        cloneAll( other.withExprs, withExprs );
    54 }
    55 
    56 FunctionDecl::~FunctionDecl() {
    57         delete type;
    58         delete statements;
    59         deleteAll( withExprs );
    6054}
    6155
  • src/SynTree/FunctionType.cc

    r6171841 r68f9c43  
    3131        cloneAll( other.returnVals, returnVals );
    3232        cloneAll( other.parameters, parameters );
    33 }
    34 
    35 FunctionType::~FunctionType() {
    36         deleteAll( returnVals );
    37         deleteAll( parameters );
    3833}
    3934
  • src/SynTree/Initializer.cc

    r6171841 r68f9c43  
    3232}
    3333
    34 Designation::~Designation() {
    35         // std::cerr << "destroying designation" << std::endl;
    36         deleteAll( designators );
    37         // std::cerr << "finished destroying designation" << std::endl;
    38 }
    39 
    4034void Designation::print( std::ostream &os, Indenter indent ) const {
    4135        if ( ! designators.empty() ) {
     
    5246Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
    5347}
    54 Initializer::~Initializer() {}
    5548
    5649SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) {
     
    5851
    5952SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) {
    60 }
    61 
    62 SingleInit::~SingleInit() {
    63         delete value;
    6453}
    6554
     
    8776}
    8877
    89 ListInit::~ListInit() {
    90         deleteAll( initializers );
    91         deleteAll( designations );
    92 }
    93 
    9478void ListInit::print( std::ostream &os, Indenter indent ) const {
    9579        os << "Compound initializer: " << std::endl;
     
    11094ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ) {}
    11195ConstructorInit::ConstructorInit( const ConstructorInit &other ) : Initializer( other ), ctor( maybeClone( other.ctor ) ), dtor( maybeClone( other.dtor ) ), init( maybeClone( other.init ) ) {
    112 }
    113 
    114 ConstructorInit::~ConstructorInit() {
    115         delete ctor;
    116         delete dtor;
    117         delete init;
    11896}
    11997
  • src/SynTree/Initializer.h

    r6171841 r68f9c43  
    3333        Designation( const std::list< Expression * > & designators );
    3434        Designation( const Designation & other );
    35         virtual ~Designation();
    3635
    3736        std::list< Expression * > & get_designators() { return designators; }
     
    5049        Initializer( bool maybeConstructed );
    5150        Initializer( const Initializer & other );
    52         virtual ~Initializer();
    5351
    5452        bool get_maybeConstructed() { return maybeConstructed; }
     
    7068        SingleInit( Expression *value, bool maybeConstructed = false );
    7169        SingleInit( const SingleInit &other );
    72         virtual ~SingleInit();
    7370
    7471        Expression *get_value() { return value; }
     
    9188                          const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
    9289        ListInit( const ListInit & other );
    93         virtual ~ListInit();
    9490
    9591        std::list<Designation *> & get_designations() { return designations; }
     
    123119        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
    124120        ConstructorInit( const ConstructorInit &other );
    125         virtual ~ConstructorInit();
    126121
    127122        void set_ctor( Statement * newValue ) { ctor = newValue; }
  • src/SynTree/NamedTypeDecl.cc

    r6171841 r68f9c43  
    3030        cloneAll( other.parameters, parameters );
    3131        cloneAll( other.assertions, assertions );
    32 }
    33 
    34 NamedTypeDecl::~NamedTypeDecl() {
    35         delete base;
    36         deleteAll( parameters );
    37         deleteAll( assertions );
    3832}
    3933
  • src/SynTree/ObjectDecl.cc

    r6171841 r68f9c43  
    3232ObjectDecl::ObjectDecl( const ObjectDecl &other )
    3333        : Parent( other ), type( maybeClone( other.type ) ), init( maybeClone( other.init ) ), bitfieldWidth( maybeClone( other.bitfieldWidth ) ) {
    34 }
    35 
    36 ObjectDecl::~ObjectDecl() {
    37         delete type;
    38         delete init;
    39         delete bitfieldWidth;
    4034}
    4135
  • src/SynTree/PointerType.cc

    r6171841 r68f9c43  
    3636}
    3737
    38 PointerType::~PointerType() {
    39         delete base;
    40         delete dimension;
    41 }
    42 
    4338void PointerType::print( std::ostream &os, Indenter indent ) const {
    4439        Type::print( os, indent );
  • src/SynTree/ReferenceToType.cc

    r6171841 r68f9c43  
    3232ReferenceToType::ReferenceToType( const ReferenceToType &other ) : Type( other ), name( other.name ), hoistType( other.hoistType ) {
    3333        cloneAll( other.parameters, parameters );
    34 }
    35 
    36 ReferenceToType::~ReferenceToType() {
    37         deleteAll( parameters );
    3834}
    3935
     
    170166}
    171167
    172 TraitInstType::~TraitInstType() {
    173 }
    174 
    175168bool TraitInstType::isComplete() const { assert( false ); }
    176169
     
    183176
    184177TypeInstType::TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {
    185 }
    186 
    187 
    188 TypeInstType::~TypeInstType() {
    189         // delete baseType; //This is shared and should not be deleted
    190178}
    191179
  • src/SynTree/ReferenceType.cc

    r6171841 r68f9c43  
    2828}
    2929
    30 ReferenceType::~ReferenceType() {
    31         delete base;
    32 }
    33 
    3430int ReferenceType::referenceDepth() const {
    3531        return base->referenceDepth()+1;
  • src/SynTree/Statement.cc

    r6171841 r68f9c43  
    4444}
    4545
    46 Statement::~Statement() {}
    47 
    4846ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
    4947
    5048ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
    51 
    52 ExprStmt::~ExprStmt() {
    53         delete expr;
    54 }
    5549
    5650void ExprStmt::print( std::ostream &os, Indenter indent ) const {
     
    6660  cloneAll( other.input, input );
    6761  cloneAll( other.clobber, clobber );
    68 }
    69 
    70 AsmStmt::~AsmStmt() {
    71         delete instruction;
    72         deleteAll( output );
    73         deleteAll( input );
    74         deleteAll( clobber );
    7562}
    7663
     
    122109ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
    123110
    124 ReturnStmt::~ReturnStmt() {
    125         delete expr;
    126 }
    127 
    128111void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
    129112        os << "Return Statement, returning: ";
     
    141124        Statement( other ), condition( maybeClone( other.condition ) ), thenPart( maybeClone( other.thenPart ) ), elsePart( maybeClone( other.elsePart ) ) {
    142125        cloneAll( other.initialization, initialization );
    143 }
    144 
    145 IfStmt::~IfStmt() {
    146         deleteAll( initialization );
    147         delete condition;
    148         delete thenPart;
    149         delete elsePart;
    150126}
    151127
     
    185161}
    186162
    187 SwitchStmt::~SwitchStmt() {
    188         delete condition;
    189         // destroy statements
    190         deleteAll( statements );
    191 }
    192 
    193163void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
    194164        os << "Switch on condition: ";
     
    209179        Statement( other ), condition( maybeClone(other.condition ) ), _isDefault( other._isDefault ) {
    210180        cloneAll( other.stmts, stmts );
    211 }
    212 
    213 CaseStmt::~CaseStmt() {
    214         delete condition;
    215         deleteAll( stmts );
    216181}
    217182
     
    243208}
    244209
    245 WhileStmt::~WhileStmt() {
    246         delete body;
    247         delete condition;
    248 }
    249 
    250210void WhileStmt::print( std::ostream &os, Indenter indent ) const {
    251211        os << "While on condition: " << endl ;
     
    265225                cloneAll( other.initialization, initialization );
    266226
    267 }
    268 
    269 ForStmt::~ForStmt() {
    270         deleteAll( initialization );
    271         delete condition;
    272         delete increment;
    273         delete body;
    274227}
    275228
     
    311264ThrowStmt::ThrowStmt( const ThrowStmt &other ) :
    312265        Statement ( other ), kind( other.kind ), expr( maybeClone( other.expr ) ), target( maybeClone( other.target ) ) {
    313 }
    314 
    315 ThrowStmt::~ThrowStmt() {
    316         delete expr;
    317         delete target;
    318266}
    319267
     
    336284}
    337285
    338 TryStmt::~TryStmt() {
    339         delete block;
    340         deleteAll( handlers );
    341         delete finallyBlock;
    342 }
    343 
    344286void TryStmt::print( std::ostream &os, Indenter indent ) const {
    345287        os << "Try Statement" << endl;
     
    370312}
    371313
    372 CatchStmt::~CatchStmt() {
    373         delete decl;
    374         delete body;
    375 }
    376 
    377314void CatchStmt::print( std::ostream &os, Indenter indent ) const {
    378315        os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
     
    397334
    398335FinallyStmt::FinallyStmt( const FinallyStmt & other ) : Statement( other ), block( maybeClone( other.block ) ) {
    399 }
    400 
    401 FinallyStmt::~FinallyStmt() {
    402         delete block;
    403336}
    404337
     
    434367}
    435368
    436 WaitForStmt::~WaitForStmt() {
    437         for( auto & clause : clauses ) {
    438                 delete clause.target.function;
    439                 deleteAll( clause.target.arguments );
    440                 delete clause.statement;
    441                 delete clause.condition;
    442         }
    443 
    444         delete timeout.time;
    445         delete timeout.statement;
    446         delete timeout.condition;
    447 
    448         delete orelse.statement;
    449         delete orelse.condition;
    450 }
    451 
    452369void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
    453370        os << "Waitfor Statement" << endl;
     
    460377WithStmt::WithStmt( const WithStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
    461378        cloneAll( other.exprs, exprs );
    462 }
    463 WithStmt::~WithStmt() {
    464         deleteAll( exprs );
    465         delete stmt;
    466379}
    467380
     
    489402}
    490403
    491 ImplicitCtorDtorStmt::~ImplicitCtorDtorStmt() {
    492         delete callStmt;
    493 }
    494 
    495404void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
    496405        os << "Implicit Ctor Dtor Statement" << endl;
  • src/SynTree/Statement.h

    r6171841 r68f9c43  
    3838
    3939        Statement( const std::list<Label> & labels = {} );
    40         virtual ~Statement();
    4140
    4241        std::list<Label> & get_labels() { return labels; }
     
    5655        CompoundStmt( std::list<Statement *> stmts );
    5756        CompoundStmt( const CompoundStmt &other );
    58         virtual ~CompoundStmt();
    5957
    6058        std::list<Statement*>& get_kids() { return kids; }
     
    8482        ExprStmt( Expression *expr );
    8583        ExprStmt( const ExprStmt &other );
    86         virtual ~ExprStmt();
    8784
    8885        Expression *get_expr() { return expr; }
     
    105102        AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
    106103        AsmStmt( const AsmStmt &other );
    107         virtual ~AsmStmt();
    108104
    109105        bool get_voltile() { return voltile; }
     
    136132                        std::list<Statement *> initialization = std::list<Statement *>() );
    137133        IfStmt( const IfStmt &other );
    138         virtual ~IfStmt();
    139134
    140135        std::list<Statement *> &get_initialization() { return initialization; }
     
    159154        SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
    160155        SwitchStmt( const SwitchStmt &other );
    161         virtual ~SwitchStmt();
    162156
    163157        Expression *get_condition() { return condition; }
     
    181175        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
    182176        CaseStmt( const CaseStmt &other );
    183         virtual ~CaseStmt();
    184177
    185178        static CaseStmt * makeDefault( const std::list<Label> & labels = {}, std::list<Statement *> stmts = std::list<Statement *>() );
     
    212205               Statement *body, bool isDoWhile = false );
    213206        WhileStmt( const WhileStmt &other );
    214         virtual ~WhileStmt();
    215207
    216208        Expression *get_condition() { return condition; }
     
    237229             Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
    238230        ForStmt( const ForStmt &other );
    239         virtual ~ForStmt();
    240231
    241232        std::list<Statement *> &get_initialization() { return initialization; }
     
    290281        ReturnStmt( Expression *expr );
    291282        ReturnStmt( const ReturnStmt &other );
    292         virtual ~ReturnStmt();
    293283
    294284        Expression *get_expr() { return expr; }
     
    311301        ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
    312302        ThrowStmt( const ThrowStmt &other );
    313         virtual ~ThrowStmt();
    314303
    315304        Kind get_kind() { return kind; }
     
    333322        TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
    334323        TryStmt( const TryStmt &other );
    335         virtual ~TryStmt();
    336324
    337325        CompoundStmt *get_block() const { return block; }
     
    360348                   Expression *cond, Statement *body );
    361349        CatchStmt( const CatchStmt &other );
    362         virtual ~CatchStmt();
    363350
    364351        Kind get_kind() { return kind; }
     
    382369        FinallyStmt( CompoundStmt *block );
    383370        FinallyStmt( const FinallyStmt &other );
    384         virtual ~FinallyStmt();
    385371
    386372        CompoundStmt *get_block() const { return block; }
     
    409395        WaitForStmt();
    410396        WaitForStmt( const WaitForStmt & );
    411         virtual ~WaitForStmt();
    412397
    413398        std::vector<Clause> clauses;
     
    438423        WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
    439424        WithStmt( const WithStmt & other );
    440         virtual ~WithStmt();
    441425
    442426        virtual WithStmt * clone() const override { return new WithStmt( *this ); }
     
    454438        DeclStmt( Declaration *decl );
    455439        DeclStmt( const DeclStmt &other );
    456         virtual ~DeclStmt();
    457440
    458441        Declaration *get_decl() const { return decl; }
     
    476459        ImplicitCtorDtorStmt( Statement * callStmt );
    477460        ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
    478         virtual ~ImplicitCtorDtorStmt();
    479461
    480462        Statement *get_callStmt() const { return callStmt; }
  • src/SynTree/TupleExpr.cc

    r6171841 r68f9c43  
    3535}
    3636
    37 UntypedTupleExpr::~UntypedTupleExpr() {
    38         deleteAll( exprs );
    39 }
    40 
    4137void UntypedTupleExpr::print( std::ostream &os, Indenter indent ) const {
    4238        os << "Untyped Tuple:" << std::endl;
     
    5147TupleExpr::TupleExpr( const TupleExpr &other ) : Expression( other ) {
    5248        cloneAll( other.exprs, exprs );
    53 }
    54 
    55 TupleExpr::~TupleExpr() {
    56         deleteAll( exprs );
    5749}
    5850
     
    7264
    7365TupleIndexExpr::TupleIndexExpr( const TupleIndexExpr &other ) : Expression( other ), tuple( other.tuple->clone() ), index( other.index ) {
    74 }
    75 
    76 TupleIndexExpr::~TupleIndexExpr() {
    77         delete tuple;
    7866}
    7967
     
    10593}
    10694
    107 TupleAssignExpr::~TupleAssignExpr() {
    108         delete stmtExpr;
    109 }
    110 
    11195void TupleAssignExpr::print( std::ostream &os, Indenter indent ) const {
    11296        os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
  • src/SynTree/TupleType.cc

    r6171841 r68f9c43  
    4343}
    4444
    45 TupleType::~TupleType() {
    46         deleteAll( types );
    47         deleteAll( members );
    48 }
    49 
    5045void TupleType::print( std::ostream &os, Indenter indent ) const {
    5146        Type::print( os, indent );
  • src/SynTree/Type.cc

    r6171841 r68f9c43  
    5757}
    5858
    59 Type::~Type() {
    60         deleteAll( forall );
    61         deleteAll( attributes );
    62 }
    63 
    6459// These must remain in the same order as the corresponding bit fields.
    6560const char * Type::FuncSpecifiersNames[] = { "inline", "fortran", "_Noreturn" };
  • src/SynTree/Type.h

    r6171841 r68f9c43  
    141141        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
    142142        Type( const Type & other );
    143         virtual ~Type();
    144143
    145144        Qualifiers & get_qualifiers() { return tq; }
     
    261260        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    262261        PointerType( const PointerType& );
    263         virtual ~PointerType();
    264262
    265263        Type *get_base() { return base; }
     
    291289        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    292290        ArrayType( const ArrayType& );
    293         virtual ~ArrayType();
    294291
    295292        Type *get_base() { return base; }
     
    319316        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    320317        ReferenceType( const ReferenceType & );
    321         virtual ~ReferenceType();
    322318
    323319        Type *get_base() { return base; }
     
    352348        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    353349        FunctionType( const FunctionType& );
    354         virtual ~FunctionType();
    355350
    356351        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
     
    376371        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
    377372        ReferenceToType( const ReferenceToType & other );
    378         virtual ~ReferenceToType();
    379373
    380374        const std::string & get_name() const { return name; }
     
    503497        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    504498        TraitInstType( const TraitInstType & other );
    505         ~TraitInstType();
    506499
    507500        virtual bool isComplete() const override;
     
    525518        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    526519        TypeInstType( const TypeInstType & other );
    527         ~TypeInstType();
    528520
    529521        TypeDecl *get_baseType() const { return baseType; }
     
    549541        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    550542        TupleType( const TupleType& );
    551         virtual ~TupleType();
    552543
    553544        typedef std::list<Type*> value_type;
     
    583574        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    584575        TypeofType( const TypeofType& );
    585         virtual ~TypeofType();
    586576
    587577        Expression *get_expr() const { return expr; }
     
    606596        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    607597        AttrType( const AttrType& );
    608         virtual ~AttrType();
    609598
    610599        const std::string & get_name() const { return name; }
  • src/SynTree/TypeDecl.cc

    r6171841 r68f9c43  
    2525
    2626TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) {
    27 }
    28 
    29 TypeDecl::~TypeDecl() {
    30   delete init;
    3127}
    3228
  • src/SynTree/TypeExpr.cc

    r6171841 r68f9c43  
    2626}
    2727
    28 TypeExpr::~TypeExpr() {
    29         delete type;
    30 }
    31 
    3228void TypeExpr::print( std::ostream &os, Indenter indent ) const {
    3329        if ( type ) type->print( os, indent );
  • src/SynTree/TypeSubstitution.cc

    r6171841 r68f9c43  
    2626}
    2727
    28 TypeSubstitution::~TypeSubstitution() {
    29         for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
    30                 delete( i->second );
    31         }
    32         for ( VarEnvType::iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
    33                 delete( i->second );
    34         }
    35 }
    36 
    3728TypeSubstitution &TypeSubstitution::operator=( const TypeSubstitution &other ) {
    3829        if ( this == &other ) return *this;
     
    5748
    5849void TypeSubstitution::add( std::string formalType, Type *actualType ) {
    59         TypeEnvType::iterator i = typeEnv.find( formalType );
    60         if ( i != typeEnv.end() ) {
    61                 delete i->second;
    62         } // if
    6350        typeEnv[ formalType ] = actualType->clone();
    6451}
    6552
    6653void TypeSubstitution::remove( std::string formalType ) {
    67         TypeEnvType::iterator i = typeEnv.find( formalType );
    68         if ( i != typeEnv.end() ) {
    69                 delete i->second;
    70                 typeEnv.erase( formalType );
    71         } // if
     54        typeEnv.erase( formalType );
    7255}
    7356
     
    155138                Type * newtype = i->second->clone();
    156139                newtype->get_qualifiers() |= inst->get_qualifiers();
    157                 delete inst;
    158140                return newtype;
    159141        } // if
     
    166148        } else {
    167149                subCount++;
    168                 delete nameExpr;
    169150                return i->second->clone();
    170151        } // if
  • src/SynTree/TypeSubstitution.h

    r6171841 r68f9c43  
    3535        TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
    3636        TypeSubstitution( const TypeSubstitution &other );
    37         virtual ~TypeSubstitution();
    3837
    3938        TypeSubstitution &operator=( const TypeSubstitution &other );
     
    101100                        if ( TypeExpr *actual = dynamic_cast< TypeExpr* >( *actualIt ) ) {
    102101                                if ( formal->get_name() != "" ) {
    103                                         TypeEnvType::iterator i = typeEnv.find( formal->get_name() );
    104                                         if ( i != typeEnv.end() ) {
    105                                                 delete i->second;
    106                                         } // if
    107102                                        typeEnv[ formal->get_name() ] = actual->get_type()->clone();
    108103                                } // if
  • src/SynTree/TypeofType.cc

    r6171841 r68f9c43  
    2929}
    3030
    31 TypeofType::~TypeofType() {
    32         delete expr;
    33 }
    34 
    3531void TypeofType::print( std::ostream &os, Indenter indent ) const {
    3632        Type::print( os, indent );
  • src/SynTree/module.mk

    r6171841 r68f9c43  
    4848       SynTree/TypeSubstitution.cc \
    4949       SynTree/Attribute.cc \
     50       SynTree/GcTracer.cc \
    5051       SynTree/VarExprReplacer.cc
    5152
  • src/Tuples/Explode.cc

    r6171841 r68f9c43  
    7070                                // should now be a tuple of references rather than a reference to a tuple.
    7171                                // Still, this code is a bit awkward, and could use some improvement.
    72                                 UniqueExpr * newUniqueExpr = new UniqueExpr( applyCast( uniqueExpr->get_expr() ), uniqueExpr->get_id() );
    73                                 delete uniqueExpr;
     72                                UniqueExpr * newUniqueExpr = new UniqueExpr{ applyCast( uniqueExpr->get_expr() ), uniqueExpr->get_id() };
    7473                                if ( castAdded ) {
    7574                                        // if a cast was added by applyCast, then unique expr now has one more layer of reference
     
    8887                                // field is consistent with the type of the tuple expr, since the field
    8988                                // may have changed from type T to T&.
    90                                 Expression * expr = tupleExpr->get_tuple();
    91                                 tupleExpr->set_tuple( nullptr );
    92                                 TupleIndexExpr * ret = new TupleIndexExpr( expr, tupleExpr->get_index() );
    93                                 delete tupleExpr;
    94                                 return ret;
     89                                return new TupleIndexExpr{ tupleExpr->get_tuple(), tupleExpr->get_index() };
    9590                        }
    9691                };
  • src/Tuples/Explode.h

    r6171841 r68f9c43  
    2727namespace SymTab {
    2828class Indexer;
    29 }  // namespace SymTab
     29}  // namespace SymTabf
    3030
    3131namespace Tuples {
     
    6767                                for ( ResolvExpr::Alternative & alt : alts ) {
    6868                                        // distribute reference cast over all components
    69                                         append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
     69                                        append( std::forward<Output>(out), distributeReference( alt.expr ),
    7070                                                alt.env, alt.cost, alt.cvtCost );
    7171                                }
     
    9696                                        TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
    9797                                        explodeUnique( idx, alt, indexer, std::forward<Output>(out), isTupleAssign );
    98                                         delete idx;
    9998                                }
    100                                 delete arg;
    10199                        }
    102100                } else {
  • src/Tuples/TupleExpansion.cc

    r6171841 r68f9c43  
    4545
    4646                        std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
    47 
    48                         ~UniqueExprExpander() {
    49                                 for ( std::pair<const int, Expression *> & p : decls ) {
    50                                         delete p.second;
    51                                 }
    52                         }
    5347                };
    5448
     
    111105                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner );
    112106                                inner->location = newMemberExpr->location = loc;
    113                                 memberExpr->member = nullptr;
    114                                 memberExpr->aggregate = nullptr;
    115                                 delete memberExpr;
    116107                                return newMemberExpr->acceptMutator( expander );
    117108                        } else {
     
    135126                                expr->location = memberExpr->location;
    136127                        }
    137                         delete aggr;
    138128                        tupleExpr->location = memberExpr->location;
    139129                        return tupleExpr;
     
    181171                        decls[id] = condExpr;
    182172                }
    183                 delete unqExpr;
    184173                return decls[id]->clone();
    185174        }
     
    191180                ret->set_env( assnExpr->get_env() );
    192181                assnExpr->set_env( nullptr );
    193                 delete assnExpr;
    194182                return ret;
    195183        }
     
    222210                        newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
    223211                }
    224                 delete tupleType;
    225212                return newType;
    226213        }
     
    233220                TypeSubstitution * env = tupleExpr->get_env();
    234221                tupleExpr->set_env( nullptr );
    235                 delete tupleExpr;
    236222
    237223                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
     
    275261                TypeSubstitution * env = tupleExpr->get_env();
    276262
    277                 // remove data from shell and delete it
    278                 tupleExpr->set_result( nullptr );
    279                 tupleExpr->get_exprs().clear();
     263                // remove data from shell
    280264                tupleExpr->set_env( nullptr );
    281                 delete tupleExpr;
    282265
    283266                return replaceTupleExpr( result, exprs, env );
  • src/Virtual/ExpandCasts.cc

    r6171841 r68f9c43  
    139139                ObjectDecl * table = found->second;
    140140
    141                 Expression * result = new CastExpr(
     141                return new CastExpr{
    142142                        //new ApplicationExpr(
    143143                                //new AddressExpr( new VariableExpr( vcast_decl ) ),
     
    158158                                } ),
    159159                        castExpr->get_result()->clone()
    160                         );
    161 
    162                 castExpr->set_arg( nullptr );
    163                 castExpr->set_result( nullptr );
    164                 delete castExpr;
    165                 return result;
     160                };
    166161        }
    167162
  • src/main.cc

    r6171841 r68f9c43  
    3737#include "Common/PassVisitor.h"
    3838#include "Common/CompilerError.h"           // for CompilerError
     39#include "Common/GC.h"                                          // for GC
    3940#include "Common/SemanticError.h"           // for SemanticError
    4041#include "Common/UnimplementedError.h"      // for UnimplementedError
     
    5758#include "SymTab/Validate.h"                // for validate
    5859#include "SynTree/Declaration.h"            // for Declaration
     60#include "SynTree/GcTracer.h"               // for GC << TranslationUnit
    5961#include "SynTree/Visitor.h"                // for acceptAll
    6062#include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
     
    6466
    6567#define OPTPRINT(x) if ( errorp ) cerr << x << endl;
    66 
    6768
    6869LinkageSpec::Spec linkage = LinkageSpec::Cforall;
     
    233234                delete parseTree;
    234235                parseTree = nullptr;
     236                collect( translationUnit );
    235237
    236238                if ( astp ) {
     
    242244                OPTPRINT( "validate" )
    243245                SymTab::validate( translationUnit, symtabp );
    244                 if ( symtabp ) {
    245                         deleteAll( translationUnit );
    246                         return 0;
    247                 } // if
     246                collect( translationUnit );
     247                if ( symtabp ) return 0;
    248248
    249249                if ( expraltp ) {
     
    266266                OPTPRINT( "expandMemberTuples" );
    267267                Tuples::expandMemberTuples( translationUnit );
     268                collect( translationUnit );
    268269                if ( libcfap ) {
    269270                        // generate the bodies of cfa library functions
     
    273274                if ( declstatsp ) {
    274275                        CodeTools::printDeclStats( translationUnit );
    275                         deleteAll( translationUnit );
    276276                        return 0;
    277277                }
     
    286286                OPTPRINT( "resolve" )
    287287                ResolvExpr::resolve( translationUnit );
     288                collect( translationUnit );
    288289                if ( exprp ) {
    289290                        dump( translationUnit );
     
    294295                OPTPRINT( "fixInit" )
    295296                InitTweak::fix( translationUnit, filename, libcfap || treep );
     297                collect( translationUnit );
    296298                if ( ctorinitp ) {
    297299                        dump ( translationUnit );
     
    313315                OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
    314316                Tuples::expandTuples( translationUnit );
     317                collect( translationUnit );
    315318                if ( tuplep ) {
    316319                        dump( translationUnit );
     
    323326                OPTPRINT("instantiateGenerics")
    324327                GenPoly::instantiateGeneric( translationUnit );
     328                collect( translationUnit );
    325329                if ( genericsp ) {
    326330                        dump( translationUnit );
    327331                        return 0;
    328332                }
     333
    329334                OPTPRINT( "convertLvalue" )
    330335                GenPoly::convertLvalue( translationUnit );
    331 
    332 
     336                collect( translationUnit );
    333337                if ( bboxp ) {
    334338                        dump( translationUnit );
    335339                        return 0;
    336340                } // if
     341
    337342                OPTPRINT( "box" )
    338343                GenPoly::box( translationUnit );
    339 
     344                collect( translationUnit );
    340345                if ( bcodegenp ) {
    341346                        dump( translationUnit );
     
    383388        } // try
    384389
    385         deleteAll( translationUnit );
    386390        return 0;
    387391} // main
     
    568572                printAll( decls, out );
    569573        }
    570         deleteAll( translationUnit );
    571574} // dump
    572575
Note: See TracChangeset for help on using the changeset viewer.