Changeset 68f9c43 for src/GenPoly


Ignore:
Timestamp:
Mar 16, 2018, 5:15:02 PM (6 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/GenPoly
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.