Changeset b0837e4 for src/ResolvExpr/ConversionCost.cc

Timestamp:

Oct 30, 2017, 2:02:21 PM (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:

f0ecf9b

Parents:

598f50e

Message:

Minor cleanup in conversion code

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -28 +28 @@
 
 namespace ResolvExpr {
-        const Cost Cost::zero = Cost( 0, 0, 0, 0 );
-        const Cost Cost::infinity = Cost( -1, -1, -1, -1 );
-        const Cost Cost::unsafe = Cost( 1, 0, 0, 0 );
-        const Cost Cost::poly = Cost( 0, 1, 0, 0 );
-        const Cost Cost::safe = Cost( 0, 0, 1, 0 );
-        const Cost Cost::reference = Cost( 0, 0, 0, 1 );
+        const Cost Cost::zero =      Cost(  0,  0,  0,  0 );
+        const Cost Cost::infinity =  Cost( -1, -1, -1, -1 );
+        const Cost Cost::unsafe =    Cost(  1,  0,  0,  0 );
+        const Cost Cost::poly =      Cost(  0,  1,  0,  0 );
+        const Cost Cost::safe =      Cost(  0,  0,  1,  0 );
+        const Cost Cost::reference = Cost(  0,  0,  0,  1 );
 
 #if 0
@@ -113 +113 @@
                                         int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
                                         PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
-                                        if ( assignResult < 0 ) {
+                                        if ( assignResult > 0 ) {
                                                 return Cost::safe;
-                                        } else if ( assignResult > 0 ) {
+                                        } else if ( assignResult < 0 ) {
                                                 return Cost::unsafe;
                                         } // if
@@ -269 +269 @@
         }
 
-        void ConversionCost::visit(PointerType *pointerType) {
+        void ConversionCost::visit( PointerType * pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
@@ -284 +284 @@
                                 }
                         } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
-                                int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
+                                int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
                                 PRINT( std::cerr << " :: " << assignResult << std::endl; )
-                                if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
+                                if ( assignResult > 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
                                         cost = Cost::safe;
-                                } else if ( assignResult > 0 ) {
+                                } else if ( assignResult < 0 ) {
                                         cost = Cost::unsafe;
                                 } // if
                                 // assignResult == 0 means Cost::Infinity
                         } // if
-                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                } else if ( dynamic_cast< ZeroType * >( dest ) ) {
                         cost = Cost::unsafe;
                 } // if
         }
 
-        void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
-
-        void ConversionCost::visit(ReferenceType *refType) {
+        void ConversionCost::visit( ArrayType * ) {}
+
+        void ConversionCost::visit( ReferenceType * refType ) {
                 // Note: dest can never be a reference, since it would have been caught in an earlier check
                 assert( ! dynamic_cast< ReferenceType * >( dest ) );
@@ -317 +317 @@
         }
 
-        void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
-
-        void ConversionCost::visit(StructInstType *inst) {
+        void ConversionCost::visit( FunctionType * ) {}
+
+        void ConversionCost::visit( StructInstType * inst ) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -327 +327 @@
         }
 
-        void ConversionCost::visit(UnionInstType *inst) {
+        void ConversionCost::visit( UnionInstType * inst ) {
                 if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -335 +335 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) {
+        void ConversionCost::visit( EnumInstType * ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
@@ -344 +344 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) {
-        }
-
-        void ConversionCost::visit(TypeInstType *inst) {
+        void ConversionCost::visit( TraitInstType * ) {}
+
+        void ConversionCost::visit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 NamedTypeDecl *namedType;
@@ -366 +365 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
+        void ConversionCost::visit( TupleType * tupleType ) {
                 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();
+                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() ) {
                                 Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
@@ -386 +385 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) {
+        void ConversionCost::visit( VarArgsType * ) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
@@ -392 +391 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) {
-                if ( dynamic_cast< ZeroType* >( dest ) ) {
+        void ConversionCost::visit( ZeroType * ) {
+                if ( dynamic_cast< ZeroType * >( dest ) ) {
                         cost = Cost::zero;
                 } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
@@ -409 +408 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) OneType *oneType) {
-                if ( dynamic_cast< OneType* >( dest ) ) {
+        void ConversionCost::visit( OneType * ) {
+                if ( dynamic_cast< OneType * >( dest ) ) {
                         cost = Cost::zero;
                 } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {