Changeset e3e16bc


Ignore:
Timestamp:
Sep 13, 2017, 2:34:55 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
982832e
Parents:
9f5ecf5
Message:

Renamed safe_dynamic_cast to strict_dynamic_cast

Location:
src
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • src/Concurrency/Waitfor.cc

    r9f5ecf5 re3e16bc  
    228228                        decl_acceptable = decl;
    229229                        for( Declaration * field : decl_acceptable->members ) {
    230                                      if( field->name == "func"    ) decl_m_func     = safe_dynamic_cast< DeclarationWithType * >( field );
    231                                 else if( field->name == "count"   ) decl_m_count    = safe_dynamic_cast< DeclarationWithType * >( field );
    232                                 else if( field->name == "monitor" ) decl_m_monitors = safe_dynamic_cast< DeclarationWithType * >( field );
    233                                 else if( field->name == "is_dtor" ) decl_m_isdtor   = safe_dynamic_cast< DeclarationWithType * >( field );
     230                                     if( field->name == "func"    ) decl_m_func     = strict_dynamic_cast< DeclarationWithType * >( field );
     231                                else if( field->name == "count"   ) decl_m_count    = strict_dynamic_cast< DeclarationWithType * >( field );
     232                                else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field );
     233                                else if( field->name == "is_dtor" ) decl_m_isdtor   = strict_dynamic_cast< DeclarationWithType * >( field );
    234234                        }
    235235
  • src/GenPoly/Box.cc

    r9f5ecf5 re3e16bc  
    1515
    1616#include <algorithm>                     // for mismatch
    17 #include <cassert>                       // for assert, safe_dynamic_cast
     17#include <cassert>                       // for assert, strict_dynamic_cast
    1818#include <iostream>                      // for operator<<, stringstream
    1919#include <list>                          // for list, list<>::iterator, _Lis...
     
    12991299
    13001300                DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
    1301                         functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
     1301                        functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
    13021302                        FunctionType * ftype = functionDecl->get_functionType();
    13031303                        if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
     
    13781378                        // move polymorphic return type to parameter list
    13791379                        if ( isDynRet( funcType ) ) {
    1380                                 ObjectDecl *ret = safe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
     1380                                ObjectDecl *ret = strict_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
    13811381                                ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
    13821382                                funcType->get_parameters().push_front( ret );
  • src/GenPoly/InstantiateGeneric.cc

    r9f5ecf5 re3e16bc  
    459459                        Declaration * member = *std::next( aggr->members.begin(), memberIndex );
    460460                        assertf( member->name == memberExpr->member->name, "Instantiation has different member order than the generic type. %s / %s", toString( member ).c_str(), toString( memberExpr->member ).c_str() );
    461                         DeclarationWithType * field = safe_dynamic_cast< DeclarationWithType * >( member );
     461                        DeclarationWithType * field = strict_dynamic_cast< DeclarationWithType * >( member );
    462462                        MemberExpr * ret = new MemberExpr( field, memberExpr->aggregate->clone() );
    463463                        std::swap( ret->env, memberExpr->env );
  • src/GenPoly/Lvalue.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>                       // for safe_dynamic_cast
     16#include <cassert>                       // for strict_dynamic_cast
    1717#include <string>                        // for string
    1818
  • src/InitTweak/FixInit.cc

    r9f5ecf5 re3e16bc  
    1717#include <stddef.h>                    // for NULL
    1818#include <algorithm>                   // for set_difference, copy_if
    19 #include <cassert>                     // for assert, safe_dynamic_cast
     19#include <cassert>                     // for assert, strict_dynamic_cast
    2020#include <iostream>                    // for operator<<, ostream, basic_ost...
    2121#include <iterator>                    // for insert_iterator, back_inserter
     
    424424                        // arrays are not copy constructed, so this should always be an ExprStmt
    425425                        ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
    426                         ExprStmt * exprStmt = safe_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
     426                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
    427427                        Expression * untyped = exprStmt->get_expr();
    428428
     
    532532                                assert( ! body->get_kids().empty() );
    533533                                // must be an ExprStmt, otherwise it wouldn't have a result
    534                                 ExprStmt * last = safe_dynamic_cast< ExprStmt * >( body->get_kids().back() );
     534                                ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() );
    535535                                last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
    536536
     
    566566                        CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
    567567
    568                         impCpCtorExpr = safe_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
     568                        impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
    569569                        std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
    570570                        std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
     
    627627                                stmt = stmt->acceptMutator( *this );
    628628                        } // for
    629                         // stmtExpr = safe_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
     629                        // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
    630630                        assert( stmtExpr->get_result() );
    631631                        Type * result = stmtExpr->get_result();
     
    791791                                                }
    792792                                        } else {
    793                                                 ImplicitCtorDtorStmt * implicit = safe_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
     793                                                ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
    794794                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
    795795                                                ApplicationExpr * ctorCall = nullptr;
     
    996996                                FunctionType * type = function->get_functionType();
    997997                                assert( ! type->get_parameters().empty() );
    998                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
     998                                thisParam = strict_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
    999999                                Type * thisType = getPointerBase( thisParam->get_type() );
    10001000                                StructInstType * structType = dynamic_cast< StructInstType * >( thisType );
     
    11661166
    11671167                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
    1168                         return safe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
     1168                        return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
    11691169                }
    11701170
     
    11791179
    11801180                        // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
    1181                         ApplicationExpr * callExpr = safe_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
     1181                        ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
    11821182                        TypeSubstitution * env = ctorExpr->get_env();
    11831183                        ctorExpr->set_callExpr( nullptr );
  • src/InitTweak/GenInit.cc

    r9f5ecf5 re3e16bc  
    1717#include <stddef.h>                // for NULL
    1818#include <algorithm>               // for any_of
    19 #include <cassert>                 // for assert, safe_dynamic_cast, assertf
     19#include <cassert>                 // for assert, strict_dynamic_cast, assertf
    2020#include <iterator>                // for back_inserter, inserter, back_inse...
    2121#include <list>                    // for _List_iterator, list
     
    255255                SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), fname, back_inserter( stmts ), objDecl );
    256256                assert( stmts.size() <= 1 );
    257                 return stmts.size() == 1 ? safe_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
     257                return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
    258258        }
    259259
  • src/InitTweak/InitTweak.cc

    r9f5ecf5 re3e16bc  
    11#include <stddef.h>                // for NULL
    22#include <algorithm>               // for find, all_of
    3 #include <cassert>                 // for assertf, assert, safe_dynamic_cast
     3#include <cassert>                 // for assertf, assert, strict_dynamic_cast
    44#include <iostream>                // for ostream, cerr, endl
    55#include <iterator>                // for back_insert_iterator, back_inserter
     
    414414                        std::list< Statement * > & stmts = tupleExpr->get_stmtExpr()->get_statements()->get_kids();
    415415                        assertf( ! stmts.empty(), "TupleAssignExpr somehow has no statements." );
    416                         ExprStmt * stmt = safe_dynamic_cast< ExprStmt * >( stmts.back() );
    417                         TupleExpr * tuple = safe_dynamic_cast< TupleExpr * >( stmt->get_expr() );
     416                        ExprStmt * stmt = strict_dynamic_cast< ExprStmt * >( stmts.back() );
     417                        TupleExpr * tuple = strict_dynamic_cast< TupleExpr * >( stmt->get_expr() );
    418418                        assertf( ! tuple->get_exprs().empty(), "TupleAssignExpr somehow has empty tuple expr." );
    419419                        return getCallArg( tuple->get_exprs().front(), pos );
  • src/Parser/DeclarationNode.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>                 // for assert, assertf, safe_dynamic_cast
     16#include <cassert>                 // for assert, assertf, strict_dynamic_cast
    1717#include <iterator>                // for back_insert_iterator
    1818#include <list>                    // for list
     
    10271027
    10281028        if ( asmStmt ) {
    1029                 return new AsmDecl( safe_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
     1029                return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
    10301030        } // if
    10311031
  • src/Parser/StatementNode.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>                 // for assert, safe_dynamic_cast, assertf
     16#include <cassert>                 // for assert, strict_dynamic_cast, assertf
    1717#include <list>                    // for list
    1818#include <memory>                  // for unique_ptr
     
    5757        // find end of list and maintain previous pointer
    5858        for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
    59                 StatementNode *node = safe_dynamic_cast< StatementNode * >(curr);
     59                StatementNode *node = strict_dynamic_cast< StatementNode * >(curr);
    6060                assert( dynamic_cast< CaseStmt * >(node->stmt.get()) );
    6161                prev = curr;
     
    106106                for ( Statement * stmt : init ) {
    107107                        // build the && of all of the declared variables compared against 0
    108                         DeclStmt * declStmt = safe_dynamic_cast< DeclStmt * >( stmt );
    109                         DeclarationWithType * dwt = safe_dynamic_cast< DeclarationWithType * >( declStmt->decl );
     108                        DeclStmt * declStmt = strict_dynamic_cast< DeclStmt * >( stmt );
     109                        DeclarationWithType * dwt = strict_dynamic_cast< DeclarationWithType * >( declStmt->decl );
    110110                        Expression * nze = notZeroExpr( new VariableExpr( dwt ) );
    111111                        cond = cond ? new LogicalExpr( cond, nze, true ) : nze;
     
    202202        std::list< CatchStmt * > branches;
    203203        buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches );
    204         CompoundStmt *tryBlock = safe_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
     204        CompoundStmt *tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
    205205        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
    206206        return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
  • src/ResolvExpr/AlternativeFinder.cc

    r9f5ecf5 re3e16bc  
    1515
    1616#include <algorithm>               // for copy
    17 #include <cassert>                 // for safe_dynamic_cast, assert, assertf
     17#include <cassert>                 // for strict_dynamic_cast, assert, assertf
    1818#include <iostream>                // for operator<<, cerr, ostream, endl
    1919#include <iterator>                // for back_insert_iterator, back_inserter
     
    336336
    337337        Cost computeApplicationConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
    338                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
    339                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    340                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
     338                ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( alt.expr );
     339                PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
     340                FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
    341341
    342342                Cost convCost = Cost::zero;
     
    494494                        Cost cost = Cost::zero;
    495495                        std::list< Expression * > newExprs;
    496                         ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
     496                        ObjectDecl * obj = strict_dynamic_cast< ObjectDecl * >( formal );
    497497                        if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
    498498                                deleteAll( newExprs );
     
    787787
    788788                        PRINT(
    789                                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
    790                                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    791                                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
     789                                ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc->expr );
     790                                PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
     791                                FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
    792792                                std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl;
    793793                                std::cerr << "formals are:" << std::endl;
  • src/ResolvExpr/CommonType.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>                       // for safe_dynamic_cast
     16#include <cassert>                       // for strict_dynamic_cast
    1717#include <map>                           // for _Rb_tree_const_iterator
    1818#include <utility>                       // for pair
     
    100100                        // special case where one type has a reference depth of 1 larger than the other
    101101                        if ( diff > 0 ) {
    102                                 return handleReference( safe_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
     102                                return handleReference( strict_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
    103103                        } else if ( diff < 0 ) {
    104                                 return handleReference( safe_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
     104                                return handleReference( strict_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
    105105                        }
    106106                        // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
     
    114114                                if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) {
    115115                                        if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) {
    116                                                 TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
     116                                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
    117117                                                if ( type->get_base() ) {
    118118                                                        Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
     
    301301                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
    302302                        if ( nt ) {
    303                                 TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
     303                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
    304304                                if ( type->get_base() ) {
    305305                                        Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();
  • src/ResolvExpr/ConversionCost.cc

    r9f5ecf5 re3e16bc  
    9595                if ( diff > 0 ) {
    9696                        // TODO: document this
    97                         Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
     97                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
    9898                        cost.incReference();
    9999                        return cost;
    100100                } else if ( diff < -1 ) {
    101101                        // TODO: document this
    102                         Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
     102                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
    103103                        cost.incReference();
    104104                        return cost;
  • src/ResolvExpr/CurrentObject.cc

    r9f5ecf5 re3e16bc  
    286286                                for ( InitAlternative & alt : ret ) {
    287287                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
    288                                         alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
     288                                        alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
    289289                                        // need to substitute for generic types, so that casts are to concrete types
    290290                                        PRINT( std::cerr << "  type is: " << alt.type; )
     
    346346                                for ( InitAlternative & alt : ret ) {
    347347                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
    348                                         alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
     348                                        alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
    349349                                }
    350350                        }
  • src/ResolvExpr/Resolver.cc

    r9f5ecf5 re3e16bc  
    1515
    1616#include <stddef.h>                      // for NULL
    17 #include <cassert>                       // for safe_dynamic_cast, assert
     17#include <cassert>                       // for strict_dynamic_cast, assert
    1818#include <memory>                        // for allocator, allocator_traits<...
    1919#include <tuple>                         // for get
     
    342342                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
    343343                        Expression * newExpr = findSingleExpression( castExpr, *this );
    344                         castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
     344                        castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
    345345                        caseStmt->set_condition( castExpr->get_arg() );
    346346                        castExpr->set_arg( nullptr );
     
    398398                Parent::enterScope();
    399399                Visitor::visit( catchStmt );
    400                
     400
    401401                if ( catchStmt->get_cond() ) {
    402402                        Expression * wrapped = new CastExpr(
     
    423423                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
    424424                Expression * newExpr = findSingleExpression( untyped, *this );
    425                 InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
     425                InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
    426426
    427427                // move cursor to the object that is actually initialized
     
    445445                                        if ( isCharType( pt->get_base() ) ) {
    446446                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
    447                                                 CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
     447                                                CastExpr *ce = strict_dynamic_cast< CastExpr * >( newExpr );
    448448                                                newExpr = ce->get_arg();
    449449                                                ce->set_arg( nullptr );
  • src/SymTab/Autogen.cc

    r9f5ecf5 re3e16bc  
    1818#include <cstddef>                 // for NULL
    1919#include <algorithm>               // for count_if
    20 #include <cassert>                 // for safe_dynamic_cast, assert, assertf
     20#include <cassert>                 // for strict_dynamic_cast, assert, assertf
    2121#include <iterator>                // for back_insert_iterator, back_inserter
    2222#include <list>                    // for list, _List_iterator, list<>::iter...
     
    250250                // parameters) are using in the variable exprs
    251251                assert( ftype->get_parameters().size() == 2 );
    252                 ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
    253                 ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
     252                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
     253                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
    254254
    255255                VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
     
    307307
    308308                // assign to destination
    309                 Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), safe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
     309                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
    310310                genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
    311311        }
     
    436436                                FunctionType * assignType = dcl->get_functionType();
    437437                                assert( assignType->get_parameters().size() == 2 );
    438                                 ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );
     438                                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );
    439439                                dcl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
    440440                        }
     
    487487                FunctionType * ftype = funcDecl->get_functionType();
    488488                assert( ftype->get_parameters().size() == 2 );
    489                 ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
    490                 ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
     489                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
     490                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
    491491
    492492                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
     
    700700
    701701        Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
    702                 tupleType = safe_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
     702                tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
    703703                std::string mangleName = SymTab::Mangler::mangleType( tupleType );
    704704                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
     
    768768        CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
    769769                seenTuples.beginScope();
    770                 compoundStmt = safe_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
     770                compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
    771771                seenTuples.endScope();
    772772                return compoundStmt;
  • src/SymTab/Indexer.cc

    r9f5ecf5 re3e16bc  
    1616#include "Indexer.h"
    1717
    18 #include <cassert>                 // for assert, safe_dynamic_cast
     18#include <cassert>                 // for assert, strict_dynamic_cast
    1919#include <iostream>                // for operator<<, basic_ostream, ostream
    2020#include <string>                  // for string, operator<<, operator!=
  • src/SymTab/Validate.cc

    r9f5ecf5 re3e16bc  
    486486                std::list< DeclarationWithType * > asserts;
    487487                for ( Declaration * decl : inst->baseTrait->members ) {
    488                         asserts.push_back( safe_dynamic_cast<DeclarationWithType *>( decl->clone() ) );
     488                        asserts.push_back( strict_dynamic_cast<DeclarationWithType *>( decl->clone() ) );
    489489                }
    490490                // substitute trait decl parameters for instance parameters
     
    530530                // need to carry over the 'sized' status of each decl in the instance
    531531                for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
    532                         TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( std::get<1>(p) );
     532                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( std::get<1>(p) );
    533533                        if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
    534534                                TypeDecl * formalDecl = std::get<0>(p);
     
    892892                        for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
    893893                                if ( i < args.size() ) {
    894                                         TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
     894                                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
    895895                                        sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
    896896                                } else if ( i == args.size() ) {
     
    962962                if ( retVals.size() > 1 ) {
    963963                        // generate a single return parameter which is the tuple of all of the return values
    964                         TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
     964                        TupleType * tupleType = strict_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
    965965                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
    966966                        ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
  • src/SynTree/AddressExpr.cc

    r9f5ecf5 re3e16bc  
    4747                } else {
    4848                        // taking address of non-lvalue -- must be a reference, loses one layer of reference
    49                         ReferenceType * refType = safe_dynamic_cast< ReferenceType * >( arg->get_result() );
     49                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() );
    5050                        set_result( addrType( refType->get_base() ) );
    5151                }
  • src/SynTree/ApplicationExpr.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>               // for safe_dynamic_cast, assert
     16#include <cassert>               // for strict_dynamic_cast, assert
    1717#include <list>                  // for list
    1818#include <map>                   // for _Rb_tree_const_iterator, map, map<>:...
     
    5050
    5151ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
    52         PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
    53         FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
     52        PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() );
     53        FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
    5454
    5555        set_result( ResolvExpr::extractResultType( function ) );
  • src/SynTree/CompoundStmt.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>                    // for assert, safe_dynamic_cast
     16#include <cassert>                    // for assert, strict_dynamic_cast
    1717#include <list>                       // for list, _List_const_iterator, lis...
    1818#include <ostream>                    // for operator<<, ostream, basic_ostream
     
    5252                Statement * origStmt = *origit++;
    5353                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
    54                         DeclStmt * origDeclStmt = safe_dynamic_cast< DeclStmt * >( origStmt );
     54                        DeclStmt * origDeclStmt = strict_dynamic_cast< DeclStmt * >( origStmt );
    5555                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
    56                                 DeclarationWithType * origdwt = safe_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
     56                                DeclarationWithType * origdwt = strict_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
    5757                                assert( dwt->get_name() == origdwt->get_name() );
    5858                                declMap[ origdwt ] = dwt;
  • src/SynTree/Constant.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>   // for safe_dynamic_cast, assertf
     16#include <cassert>   // for strict_dynamic_cast, assertf
    1717#include <iostream>  // for operator<<, ostream, basic_ostream
    1818#include <string>    // for to_string, string, char_traits, operator<<
     
    5858
    5959unsigned long long Constant::get_ival() const {
    60         assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
     60        assertf( strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
    6161        return val.ival;
    6262}
    6363
    6464double Constant::get_dval() const {
    65         assertf( ! safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
     65        assertf( ! strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
    6666        return val.dval;
    6767}
  • src/SynTree/Declaration.h

    r9f5ecf5 re3e16bc  
    156156
    157157        Type * get_type() const { return type; }
    158         virtual void set_type(Type * t) { type = safe_dynamic_cast< FunctionType* >( t ); }
     158        virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
    159159
    160160        FunctionType * get_functionType() const { return type; }
  • src/SynTree/TupleExpr.cc

    r9f5ecf5 re3e16bc  
    1414//
    1515
    16 #include <cassert>              // for assert, safe_dynamic_cast, assertf
     16#include <cassert>              // for assert, strict_dynamic_cast, assertf
    1717#include <iterator>             // for next
    1818#include <list>                 // for list, _List_iterator
     
    6464
    6565TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
    66         TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
     66        TupleType * type = strict_dynamic_cast< TupleType * >( tuple->get_result() );
    6767        assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
    6868        set_result( (*std::next( type->get_types().begin(), index ))->clone() );
  • src/Tuples/TupleExpansion.cc

    r9f5ecf5 re3e16bc  
    168168                                // steal the already generated assignment to var from the unqExpr - this has been generated by FixInit
    169169                                Expression * expr = unqExpr->get_expr();
    170                                 CommaExpr * commaExpr = safe_dynamic_cast< CommaExpr * >( expr );
     170                                CommaExpr * commaExpr = strict_dynamic_cast< CommaExpr * >( expr );
    171171                                assignUnq = commaExpr->get_arg1();
    172172                                commaExpr->set_arg1( nullptr );
     
    237237                delete tupleExpr;
    238238
    239                 StructInstType * type = safe_dynamic_cast< StructInstType * >( tuple->get_result() );
     239                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
    240240                StructDecl * structDecl = type->get_baseStruct();
    241241                assert( structDecl->get_members().size() > idx );
    242242                Declaration * member = *std::next(structDecl->get_members().begin(), idx);
    243                 MemberExpr * memExpr = new MemberExpr( safe_dynamic_cast< DeclarationWithType * >( member ), tuple );
     243                MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
    244244                memExpr->set_env( env );
    245245                return memExpr;
  • src/include/cassert

    r9f5ecf5 re3e16bc  
    3131        __ASSERT_FUNCTION, fmt, ## __VA_ARGS__ ))
    3232
    33 void __assert_fail_f(   const char *assertion, const char *file, 
    34                                                 unsigned int line, const char *function, 
    35                                                 const char *fmt, ... 
     33void __assert_fail_f(   const char *assertion, const char *file,
     34                                                unsigned int line, const char *function,
     35                                                const char *fmt, ...
    3636        ) __attribute__((noreturn, format(printf, 5, 6)));
    3737
     
    3939
    4040template<typename T, typename U>
    41 static inline T safe_dynamic_cast( const U & src ) {
     41static inline T strict_dynamic_cast( const U & src ) {
    4242        T ret = dynamic_cast<T>(src);
    4343        assert(ret);
Note: See TracChangeset for help on using the changeset viewer.