Changeset eb0aedb for src/ResolvExpr/ConversionCost.cc

Timestamp:

Jan 10, 2018, 11:12:53 AM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

80e8582

Parents:

b8a4f47

Message:

Minor code cleanup

File:

• src/ResolvExpr/ConversionCost.cc (modified) (11 diffs)

src/ResolvExpr/ConversionCost.cc

@@ -44 +44 @@
                         EqvClass eqvClass;
                         NamedTypeDecl *namedType;
-                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
-                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
+                        if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
                                 if ( eqvClass.type ) {
                                         return conversionCost( src, eqvClass.type, indexer, env );
@@ -51 +51 @@
                                         return Cost::infinity;
                                 }
-                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
                                 PRINT( std::cerr << " found" << std::endl; )
                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                                 // all typedefs should be gone by this point
                                 assert( type );
-                                if ( type->get_base() ) {
-                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
+                                if ( type->base ) {
+                                        return conversionCost( src, type->base, indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -95 +95 @@
                 if ( diff > 0 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
                         cost.incReference();
                         return cost;
                 } else if ( diff < -1 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func );
                         cost.incReference();
                         return cost;
@@ -108 +108 @@
                         if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
                                 PRINT( std::cerr << "converting between references" << std::endl; )
-                                Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers();
-                                Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers();
-                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+                                Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers();
+                                Type::Qualifiers tq2 = destAsRef->base->get_qualifiers();
+                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
                                         PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                         if ( tq1 == tq2 ) {
@@ -120 +120 @@
                                         }
                                 } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
-                                        int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
+                                        int assignResult = func( srcAsRef->base, destAsRef->base, env, indexer );
                                         PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
                                         if ( assignResult > 0 ) {
@@ -138 +138 @@
                         assert( diff == -1 && destAsRef );
                         PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
-                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
+                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
                                 PRINT( std::cerr << "converting compatible base type" << std::endl; )
                                 if ( src->get_lvalue() ) {
@@ -146 +146 @@
                                         )
                                         // lvalue-to-reference conversion:  cv lvalue T => cv T &
-                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
+                                        if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) {
                                                 return Cost::reference; // cost needs to be non-zero to add cast
-                                        } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
+                                        } if ( src->get_qualifiers() < destAsRef->base->get_qualifiers() ) {
                                                 return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
                                         } else {
                                                 return Cost::unsafe;
                                         } // if
-                                } else if ( destAsRef->get_base()->get_const() ) {
+                                } else if ( destAsRef->base->get_const() ) {
                                         PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
                                         // rvalue-to-const-reference conversion: T => const T &
@@ -281 +281 @@
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
-                        Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
-                        Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
-                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                        Type::Qualifiers tq1 = pointerType->base->get_qualifiers();
+                        Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers();
+                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                 if ( tq1 == tq2 ) {
@@ -363 +363 @@
                 EqvClass eqvClass;
                 NamedTypeDecl *namedType;
-                if ( env.lookup( inst->get_name(), eqvClass ) ) {
+                if ( env.lookup( inst->name, eqvClass ) ) {
                         cost = conversionCost( eqvClass.type, dest, indexer, env );
                 } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        if ( inst->get_name() == destAsInst->get_name() ) {
+                        if ( inst->name == destAsInst->name ) {
                                 cost = Cost::zero;
                         }
-                } else if ( ( namedType = indexer.lookupType( inst->get_name() ) ) ) {
+                } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
                         TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                         // all typedefs should be gone by this point
                         assert( type );
-                        if ( type->get_base() ) {
-                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
+                        if ( type->base ) {
+                                cost = conversionCost( type->base, dest, indexer, env ) + Cost::safe;
                         } // if
                 } // if
@@ -382 +382 @@
                 Cost c = Cost::zero;
                 if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
-                        std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin();
-                        std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin();
-                        while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
+                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
+                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
+                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
                                 Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
                                 if ( newCost == Cost::infinity ) {
@@ -391 +391 @@
                                 c += newCost;
                         } // while
-                        if ( destIt != destAsTuple->get_types().end() ) {
+                        if ( destIt != destAsTuple->types.end() ) {
                                 cost = Cost::infinity;
                         } else {