Changeset eb0aedb


Ignore:
Timestamp:
Jan 10, 2018, 11:12:53 AM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
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:
80e8582
Parents:
b8a4f47
Message:

Minor code cleanup

Location:
src/ResolvExpr
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • src/ResolvExpr/CastCost.cc

    rb8a4f47 reb0aedb  
    5252                                // all typedefs should be gone by this point
    5353                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
    54                                 if ( type->get_base() ) {
    55                                         return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
     54                                if ( type->base ) {
     55                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
    5656                                } // if
    5757                        } // if
     
    105105        void CastCost::visit( PointerType *pointerType ) {
    106106                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
    107                         if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
     107                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
    108108                                cost = Cost::safe;
    109109                        } else {
    110110                                TypeEnvironment newEnv( env );
    111                                 newEnv.add( pointerType->get_forall() );
    112                                 newEnv.add( pointerType->get_base()->get_forall() );
    113                                 int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
     111                                newEnv.add( pointerType->forall );
     112                                newEnv.add( pointerType->base->forall );
     113                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
    114114                                if ( castResult > 0 ) {
    115115                                        cost = Cost::safe;
  • src/ResolvExpr/ConversionCost.cc

    rb8a4f47 reb0aedb  
    4444                        EqvClass eqvClass;
    4545                        NamedTypeDecl *namedType;
    46                         PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
    47                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
     46                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
     47                        if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
    4848                                if ( eqvClass.type ) {
    4949                                        return conversionCost( src, eqvClass.type, indexer, env );
     
    5151                                        return Cost::infinity;
    5252                                }
    53                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
     53                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
    5454                                PRINT( std::cerr << " found" << std::endl; )
    5555                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    5656                                // all typedefs should be gone by this point
    5757                                assert( type );
    58                                 if ( type->get_base() ) {
    59                                         return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
     58                                if ( type->base ) {
     59                                        return conversionCost( src, type->base, indexer, env ) + Cost::safe;
    6060                                } // if
    6161                        } // if
     
    9595                if ( diff > 0 ) {
    9696                        // TODO: document this
    97                         Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
     97                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->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, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
     102                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func );
    103103                        cost.incReference();
    104104                        return cost;
     
    108108                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
    109109                                PRINT( std::cerr << "converting between references" << std::endl; )
    110                                 Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers();
    111                                 Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers();
    112                                 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
     110                                Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers();
     111                                Type::Qualifiers tq2 = destAsRef->base->get_qualifiers();
     112                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
    113113                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    114114                                        if ( tq1 == tq2 ) {
     
    120120                                        }
    121121                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
    122                                         int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
     122                                        int assignResult = func( srcAsRef->base, destAsRef->base, env, indexer );
    123123                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
    124124                                        if ( assignResult > 0 ) {
     
    138138                        assert( diff == -1 && destAsRef );
    139139                        PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
    140                         if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
     140                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
    141141                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
    142142                                if ( src->get_lvalue() ) {
     
    146146                                        )
    147147                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
    148                                         if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
     148                                        if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) {
    149149                                                return Cost::reference; // cost needs to be non-zero to add cast
    150                                         } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
     150                                        } if ( src->get_qualifiers() < destAsRef->base->get_qualifiers() ) {
    151151                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
    152152                                        } else {
    153153                                                return Cost::unsafe;
    154154                                        } // if
    155                                 } else if ( destAsRef->get_base()->get_const() ) {
     155                                } else if ( destAsRef->base->get_const() ) {
    156156                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
    157157                                        // rvalue-to-const-reference conversion: T => const T &
     
    281281                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
    282282                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
    283                         Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
    284                         Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
    285                         if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
     283                        Type::Qualifiers tq1 = pointerType->base->get_qualifiers();
     284                        Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers();
     285                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
    286286                                PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    287287                                if ( tq1 == tq2 ) {
     
    363363                EqvClass eqvClass;
    364364                NamedTypeDecl *namedType;
    365                 if ( env.lookup( inst->get_name(), eqvClass ) ) {
     365                if ( env.lookup( inst->name, eqvClass ) ) {
    366366                        cost = conversionCost( eqvClass.type, dest, indexer, env );
    367367                } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
    368                         if ( inst->get_name() == destAsInst->get_name() ) {
     368                        if ( inst->name == destAsInst->name ) {
    369369                                cost = Cost::zero;
    370370                        }
    371                 } else if ( ( namedType = indexer.lookupType( inst->get_name() ) ) ) {
     371                } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
    372372                        TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    373373                        // all typedefs should be gone by this point
    374374                        assert( type );
    375                         if ( type->get_base() ) {
    376                                 cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
     375                        if ( type->base ) {
     376                                cost = conversionCost( type->base, dest, indexer, env ) + Cost::safe;
    377377                        } // if
    378378                } // if
     
    382382                Cost c = Cost::zero;
    383383                if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
    384                         std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin();
    385                         std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin();
    386                         while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
     384                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
     385                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
     386                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
    387387                                Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
    388388                                if ( newCost == Cost::infinity ) {
     
    391391                                c += newCost;
    392392                        } // while
    393                         if ( destIt != destAsTuple->get_types().end() ) {
     393                        if ( destIt != destAsTuple->types.end() ) {
    394394                                cost = Cost::infinity;
    395395                        } else {
Note: See TracChangeset for help on using the changeset viewer.