Changeset 9cdfb4d0 for src/ResolvExpr

Timestamp:

Jan 22, 2018, 3:09:01 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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:

e23d20b

Parents:

326cd2b (diff), 4bf3b2b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/ResolvExpr

Files:

• CastCost.cc (modified) (4 diffs)
• CommonType.cc (modified) (6 diffs)
• ConversionCost.cc (modified) (22 diffs)
• ConversionCost.h (modified) (3 diffs)
• CurrentObject.cc (modified) (4 diffs)
• FindOpenVars.cc (modified) (3 diffs)
• Occurs.cc (modified) (3 diffs)
• PolyCost.cc (modified) (1 diff)
• PtrsAssignable.cc (modified) (1 diff)
• Resolver.cc (modified) (5 diffs)
• Resolver.h (modified) (1 diff)

src/ResolvExpr/CastCost.cc

@@ -31 +31 @@
 
 namespace ResolvExpr {
-        class CastCost : public ConversionCost {
+        struct CastCost : public ConversionCost {
           public:
-                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
 
-                virtual void visit( BasicType *basicType );
-                virtual void visit( PointerType *pointerType );
+                using ConversionCost::previsit;
+                using ConversionCost::postvisit;
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
         };
 
@@ -52 +54 @@
                                 // all typedefs should be gone by this point
                                 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
-                                if ( type->get_base() ) {
-                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
+                                if ( type->base ) {
+                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -74 +76 @@
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
                                 return ptrsCastable( t1, t2, env, indexer );
                         });
                 } else {
-                        CastCost converter( dest, indexer, env );
+                        PassVisitor<CastCost> converter( dest, indexer, env, castCost );
                         src->accept( converter );
-                        if ( converter.get_cost() == Cost::infinity ) {
+                        if ( converter.pass.get_cost() == Cost::infinity ) {
                                 return Cost::infinity;
                         } else {
                                 // xxx - why are we adding cost 0 here?
-                                return converter.get_cost() + Cost::zero;
+                                return converter.pass.get_cost() + Cost::zero;
                         } // if
                 } // if
         }
 
-        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-                : ConversionCost( dest, indexer, env ) {
+        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : ConversionCost( dest, indexer, env, costFunc ) {
         }
 
-        void CastCost::visit( BasicType *basicType ) {
+        void CastCost::postvisit( BasicType *basicType ) {
                 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
@@ -103 +105 @@
         }
 
-        void CastCost::visit( PointerType *pointerType ) {
+        void CastCost::postvisit( PointerType *pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 cost = Cost::safe;
                         } else {
                                 TypeEnvironment newEnv( env );
-                                newEnv.add( pointerType->get_forall() );
-                                newEnv.add( pointerType->get_base()->get_forall() );
-                                int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
+                                newEnv.add( pointerType->forall );
+                                newEnv.add( pointerType->base->forall );
+                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
                                 if ( castResult > 0 ) {
                                         cost = Cost::safe;

src/ResolvExpr/CommonType.cc

@@ -91 +91 @@
                         // special case where one type has a reference depth of 1 larger than the other
                         if ( diff > 0 || diff < 0 ) {
+                                // std::cerr << "reference depth diff: " << diff << std::endl;
                                 Type * result = nullptr;
-                                if ( ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ) ) {
+                                ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 );
+                                ReferenceType * ref2 = dynamic_cast< ReferenceType * >( type2 );
+                                if ( diff > 0 ) {
+                                        // deeper on the left
+                                        assert( ref1 );
+                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
+                                } else {
+                                        // deeper on the right
+                                        assert( ref2 );
+                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
+                                }
+                                if ( result && ref1 ) {
                                         // formal is reference, so result should be reference
-                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
-                                        if ( result ) result = new ReferenceType( ref1->get_qualifiers(), result );
-                                } else {
-                                        // formal is value, so result should be value
-                                        ReferenceType * ref2 = strict_dynamic_cast< ReferenceType * > ( type2 );
-                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
+                                        // std::cerr << "formal is reference; result should be reference" << std::endl;
+                                        result = new ReferenceType( ref1->get_qualifiers(), result );
                                 }
                                 // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
@@ -180 +188 @@
         }
 
-        void CommonType::visit( __attribute((unused)) VoidType *voidType ) {}
+        void CommonType::visit( VoidType * ) {}
 
         void CommonType::visit( BasicType *basicType ) {
@@ -246 +254 @@
         }
 
-        void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
+        void CommonType::visit( ArrayType * ) {}
 
         void CommonType::visit( ReferenceType *refType ) {
@@ -283 +291 @@
         }
 
-        void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
-        void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
-        void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType ) {}
+        void CommonType::visit( FunctionType * ) {}
+        void CommonType::visit( StructInstType * ) {}
+        void CommonType::visit( UnionInstType * ) {}
 
         void CommonType::visit( EnumInstType *enumInstType ) {
@@ -296 +304 @@
         }
 
-        void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType ) {
+        void CommonType::visit( TraitInstType * ) {
         }
 
@@ -321 +329 @@
         }
 
-        void CommonType::visit( __attribute((unused)) TupleType *tupleType ) {}
-        void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType ) {}
+        void CommonType::visit( TupleType * ) {}
+        void CommonType::visit( VarArgsType * ) {}
 
         void CommonType::visit( ZeroType *zeroType ) {

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
@@ -77 +77 @@
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
                                 return ptrsAssignable( t1, t2, env );
                         });
                 } else {
-                        ConversionCost converter( dest, indexer, env );
+                        PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
                         src->accept( converter );
-                        if ( converter.get_cost() == Cost::infinity ) {
+                        if ( converter.pass.get_cost() == Cost::infinity ) {
                                 return Cost::infinity;
                         } else {
-                                return converter.get_cost() + Cost::zero;
+                                return converter.pass.get_cost() + Cost::zero;
                         } // if
                 } // if
@@ -92 +92 @@
 
         Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
-                PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; )
+                PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
                 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; )
-                                if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
-                                        return Cost::safe;
+                                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 ) {
+                                                // types are the same
+                                                return Cost::zero;
+                                        } else {
+                                                // types are the same, except otherPointer has more qualifiers
+                                                return Cost::safe;
+                                        }
                                 } 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, indexer, env );
                                         PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
                                         if ( assignResult > 0 ) {
@@ -121 +130 @@
                         } else {
                                 PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
-                                ConversionCost converter( dest, indexer, env );
+                                PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
                                 src->accept( converter );
-                                return converter.get_cost();
+                                return converter.pass.get_cost();
                         } // if
                 } else {
@@ -129 +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() ) {
@@ -137 +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 &
@@ -164 +173 @@
         }
 
-        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ) {
+        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
         }
 
@@ -248 +257 @@
         };
 
-        void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) {
+        void ConversionCost::postvisit( VoidType * ) {
                 cost = Cost::infinity;
         }
 
-        void ConversionCost::visit(BasicType *basicType) {
+        void ConversionCost::postvisit(BasicType *basicType) {
                 if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
                         int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
@@ -269 +278 @@
         }
 
-        void ConversionCost::visit( PointerType * pointerType ) {
+        void ConversionCost::postvisit( PointerType * pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
-                        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 ) ) {
+                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
+                        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 ) {
                                         // types are the same
@@ -280 +290 @@
                                 } else {
                                         // types are the same, except otherPointer has more qualifiers
-                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                         cost = Cost::safe;
                                 }
-                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
+                        } else {
                                 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() ) {
-                                        cost = Cost::safe;
+                                if ( assignResult > 0 && tq1 <= tq2 ) {
+                                        // xxx - want the case where qualifiers are added to be more expensive than the case where qualifiers are the same. Is 1 safe vs. 2 safe correct?
+                                        if ( tq1 == tq2 ) {
+                                                cost = Cost::safe;
+                                        } else if ( tq1 < tq2 ) {
+                                                cost = Cost::safe+Cost::safe;
+                                        }
                                 } else if ( assignResult < 0 ) {
                                         cost = Cost::unsafe;
@@ -298 +312 @@
         }
 
-        void ConversionCost::visit( ArrayType * ) {}
-
-        void ConversionCost::visit( ReferenceType * refType ) {
+        void ConversionCost::postvisit( ArrayType * ) {}
+
+        void ConversionCost::postvisit( ReferenceType * refType ) {
                 // Note: dest can never be a reference, since it would have been caught in an earlier check
                 assert( ! dynamic_cast< ReferenceType * >( dest ) );
@@ -306 +320 @@
                 // recursively compute conversion cost from T1 to T2.
                 // cv can be safely dropped because of 'implicit dereference' behavior.
-                refType->base->accept( *this );
+                cost = costFunc( refType->base, dest, indexer, env );
                 if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) {
                         cost.incReference();  // prefer exact qualifiers
@@ -317 +331 @@
         }
 
-        void ConversionCost::visit( FunctionType * ) {}
-
-        void ConversionCost::visit( StructInstType * inst ) {
+        void ConversionCost::postvisit( FunctionType * ) {}
+
+        void ConversionCost::postvisit( StructInstType * inst ) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -327 +341 @@
         }
 
-        void ConversionCost::visit( UnionInstType * inst ) {
+        void ConversionCost::postvisit( UnionInstType * inst ) {
                 if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -335 +349 @@
         }
 
-        void ConversionCost::visit( EnumInstType * ) {
+        void ConversionCost::postvisit( EnumInstType * ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
-                integer.accept( *this );  // safe if dest >= int
+                cost = costFunc( &integer, dest, indexer, env );  // safe if dest >= int
                 if ( cost < Cost::unsafe ) {
                         cost.incSafe();
@@ -344 +358 @@
         }
 
-        void ConversionCost::visit( TraitInstType * ) {}
-
-        void ConversionCost::visit( TypeInstType *inst ) {
+        void ConversionCost::postvisit( TraitInstType * ) {}
+
+        void ConversionCost::postvisit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 NamedTypeDecl *namedType;
-                if ( env.lookup( inst->get_name(), eqvClass ) ) {
-                        cost = conversionCost( eqvClass.type, dest, indexer, env );
+                if ( env.lookup( inst->name, eqvClass ) ) {
+                        cost = costFunc( 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
-                } // if
-        }
-
-        void ConversionCost::visit( TupleType * tupleType ) {
+                        if ( type->base ) {
+                                cost = costFunc( type->base, dest, indexer, env ) + Cost::safe;
+                        } // if
+                } // if
+        }
+
+        void ConversionCost::postvisit( 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();
-                        while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
-                                Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
+                        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 = costFunc( *srcIt++, *destIt++, indexer, env );
                                 if ( newCost == Cost::infinity ) {
                                         return;
@@ -377 +391 @@
                                 c += newCost;
                         } // while
-                        if ( destIt != destAsTuple->get_types().end() ) {
+                        if ( destIt != destAsTuple->types.end() ) {
                                 cost = Cost::infinity;
                         } else {
@@ -385 +399 @@
         }
 
-        void ConversionCost::visit( VarArgsType * ) {
+        void ConversionCost::postvisit( VarArgsType * ) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
@@ -391 +405 @@
         }
 
-        void ConversionCost::visit( ZeroType * ) {
+        void ConversionCost::postvisit( ZeroType * ) {
                 if ( dynamic_cast< ZeroType * >( dest ) ) {
                         cost = Cost::zero;
@@ -408 +422 @@
         }
 
-        void ConversionCost::visit( OneType * ) {
+        void ConversionCost::postvisit( OneType * ) {
                 if ( dynamic_cast< OneType * >( dest ) ) {
                         cost = Cost::zero;

src/ResolvExpr/ConversionCost.h

@@ -19 +19 @@
 
 #include "Cost.h"             // for Cost
+
+#include "Common/PassVisitor.h"
 #include "SynTree/Visitor.h"  // for Visitor
 #include "SynTree/SynTree.h"  // for Visitor Nodes
@@ -29 +31 @@
         class TypeEnvironment;
 
-        class ConversionCost : public Visitor {
+        typedef std::function<Cost(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
+        struct ConversionCost : public WithShortCircuiting {
           public:
-                ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+                ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
 
                 Cost get_cost() const { return cost; }
 
-                virtual void visit(VoidType *voidType);
-                virtual void visit(BasicType *basicType);
-                virtual void visit(PointerType *pointerType);
-                virtual void visit(ArrayType *arrayType);
-                virtual void visit(ReferenceType *refType);
-                virtual void visit(FunctionType *functionType);
-                virtual void visit(StructInstType *aggregateUseType);
-                virtual void visit(UnionInstType *aggregateUseType);
-                virtual void visit(EnumInstType *aggregateUseType);
-                virtual void visit(TraitInstType *aggregateUseType);
-                virtual void visit(TypeInstType *aggregateUseType);
-                virtual void visit(TupleType *tupleType);
-                virtual void visit(VarArgsType *varArgsType);
-                virtual void visit(ZeroType *zeroType);
-                virtual void visit(OneType *oneType);
+                void previsit( BaseSyntaxNode * ) { visit_children = false; }
+
+                void postvisit( VoidType * voidType );
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
+                void postvisit( ArrayType * arrayType );
+                void postvisit( ReferenceType * refType );
+                void postvisit( FunctionType * functionType );
+                void postvisit( StructInstType * aggregateUseType );
+                void postvisit( UnionInstType * aggregateUseType );
+                void postvisit( EnumInstType * aggregateUseType );
+                void postvisit( TraitInstType * aggregateUseType );
+                void postvisit( TypeInstType * aggregateUseType );
+                void postvisit( TupleType * tupleType );
+                void postvisit( VarArgsType * varArgsType );
+                void postvisit( ZeroType * zeroType );
+                void postvisit( OneType * oneType );
           protected:
                 Type *dest;
@@ -55 +60 @@
                 Cost cost;
                 const TypeEnvironment &env;
+                CostFunction costFunc;
         };
 
-        typedef std::function<int(Type *, Type *, const TypeEnvironment &, const SymTab::Indexer &)> PtrsFunction;
+        typedef std::function<int(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction;
         Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
 } // namespace ResolvExpr

src/ResolvExpr/CurrentObject.cc

@@ -38 +38 @@
 
 namespace ResolvExpr {
-        long long int getConstValue( ConstantExpr * constExpr ) {
-                if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) {
-                        if ( basicType->isInteger() ) {
-                                return constExpr->get_constant()->get_ival();
-                        } else {
-                                assertf( false, "Non-integer constant expression in getConstValue %s", toString( constExpr ).c_str() ); // xxx - might be semantic error
-                        }
-                } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {
-                        return 1;
-                } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) {
-                        return 0;
-                } else {
-                        assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
-                }
-        }
-
         template< typename AggrInst >
         TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
@@ -141 +125 @@
                         base = at->get_base();
                         memberIter = createMemberIterator( base );
+                        if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
                         setSize( at->get_dimension() );
                 }
@@ -151 +136 @@
                 void setSize( Expression * expr ) {
                         if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                                size = getConstValue( constExpr );
-                                PRINT( std::cerr << "array type with size: " << size << std::endl; )
+                                try {
+                                        size = constExpr->intValue();
+                                        PRINT( std::cerr << "array type with size: " << size << std::endl; )
+                                } catch ( SemanticError & ) {
+                                        throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr );
+                                }
                         }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast
+                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
+                                if ( EnumInstType * inst = dynamic_cast< EnumInstType * > ( varExpr->result ) ) {
+                                        long long int value;
+                                        if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
+                                                size = value;
+                                        }
+                                }
                         } else {
                                 assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this
@@ -164 +160 @@
                         // need to permit integer-constant-expressions, including: integer constants, enumeration constants, character constants, sizeof expressions, _Alignof expressions, cast expressions
                         if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                                index = getConstValue( constExpr );
+                                try {
+                                        index = constExpr->intValue();
+                                } catch( SemanticError & ) {
+                                        throw SemanticError( "Constant expression of non-integral type in array designator: ", expr );
+                                }
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 setPosition( castExpr->get_arg() );
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
-                                index = 0; // xxx - get actual value of enum constant
+                                EnumInstType * inst = dynamic_cast<EnumInstType *>( varExpr->get_result() );
+                                assertf( inst, "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
+                                long long int value;
+                                if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
+                                        index = value;
+                                }
                         } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) {
                                 index = 0; // xxx - get actual sizeof/alignof value?

src/ResolvExpr/FindOpenVars.cc

@@ -19 +19 @@
 #include <map>                    // for map<>::mapped_type
 
+#include "Common/PassVisitor.h"
 #include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
 #include "SynTree/Type.h"         // for Type, Type::ForallList, ArrayType
-#include "SynTree/Visitor.h"      // for Visitor
 
 namespace ResolvExpr {
-        class FindOpenVars : public Visitor {
-          public:
+        struct FindOpenVars : public WithGuards {
                 FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
 
-          private:
-                virtual void visit(PointerType *pointerType);
-                virtual void visit(ArrayType *arrayType);
-                virtual void visit(FunctionType *functionType);
-                virtual void visit(TupleType *tupleType);
+                void previsit( PointerType * pointerType );
+                void previsit( ArrayType * arrayType );
+                void previsit( FunctionType * functionType );
+                void previsit( TupleType * tupleType );
 
                 void common_action( Type *type );
@@ -42 +40 @@
 
         void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
-                FindOpenVars finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
+                PassVisitor<FindOpenVars> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
                 type->accept( finder );
         }
@@ -70 +68 @@
                         } // for
                 } // if
-///   std::cout << "type is ";
-///   type->print( std::cout );
-///   std::cout << std::endl << "need is" << std::endl;
-///   printAssertionSet( needAssertions, std::cout );
-///   std::cout << std::endl << "have is" << std::endl;
-///   printAssertionSet( haveAssertions, std::cout );
+///   std::cerr << "type is ";
+///   type->print( std::cerr );
+///   std::cerr << std::endl << "need is" << std::endl;
+///   printAssertionSet( needAssertions, std::cerr );
+///   std::cerr << std::endl << "have is" << std::endl;
+///   printAssertionSet( haveAssertions, std::cerr );
         }
 
-        void FindOpenVars::visit(PointerType *pointerType) {
+        void FindOpenVars::previsit(PointerType *pointerType) {
                 common_action( pointerType );
-                Visitor::visit( pointerType );
         }
 
-        void FindOpenVars::visit(ArrayType *arrayType) {
+        void FindOpenVars::previsit(ArrayType *arrayType) {
                 common_action( arrayType );
-                Visitor::visit( arrayType );
         }
 
-        void FindOpenVars::visit(FunctionType *functionType) {
+        void FindOpenVars::previsit(FunctionType *functionType) {
                 common_action( functionType );
                 nextIsOpen = ! nextIsOpen;
-                Visitor::visit( functionType );
-                nextIsOpen = ! nextIsOpen;
+                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
         }
 
-        void FindOpenVars::visit(TupleType *tupleType) {
+        void FindOpenVars::previsit(TupleType *tupleType) {
                 common_action( tupleType );
-                Visitor::visit( tupleType );
         }
 } // namespace ResolvExpr

src/ResolvExpr/Occurs.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Occurs.cc -- 
+// Occurs.cc --
 //
 // Author           : Richard C. Bilson
@@ -17 +17 @@
 #include <string>             // for string
 
+#include "Common/PassVisitor.h"
 #include "SynTree/Type.h"     // for TypeInstType, Type
-#include "SynTree/Visitor.h"  // for Visitor
 #include "TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 
 namespace ResolvExpr {
-        class Occurs : public Visitor {
-          public:
+        struct Occurs : public WithVisitorRef<Occurs> {
                 Occurs( std::string varName, const TypeEnvironment &env );
-                bool get_result() const { return result; }
-                virtual void visit( TypeInstType *typeInst );
-          private:
+                void previsit( TypeInstType * typeInst );
+
                 bool result;
                 std::set< std::string > eqvVars;
-                const TypeEnvironment &env;
+                const TypeEnvironment &tenv;
         };
 
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env ) {
-                Occurs occur( varName, env );
+                PassVisitor<Occurs> occur( varName, env );
                 type->accept( occur );
-                return occur.get_result();
+                return occur.pass.result;
         }
 
-        Occurs::Occurs( std::string varName, const TypeEnvironment &env ) : result( false ), env( env ) {
+        Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ), tenv( env ) {
                 EqvClass eqvClass;
-                if ( env.lookup( varName, eqvClass ) ) {
+                if ( tenv.lookup( varName, eqvClass ) ) {
                         eqvVars = eqvClass.vars;
                 } else {
@@ -48 +46 @@
         }
 
-        void Occurs::visit( TypeInstType *typeInst ) {
+        void Occurs::previsit( TypeInstType * typeInst ) {
                 EqvClass eqvClass;
-///   std::cout << "searching for vars: ";
-///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cout, " " ) );
-///   std::cout << std::endl;
+///   std::cerr << "searching for vars: ";
+///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) );
+///   std::cerr << std::endl;
                 if ( eqvVars.find( typeInst->get_name() ) != eqvVars.end() ) {
                         result = true;
-                } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
+                } else if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
                         if ( eqvClass.type ) {
-///       std::cout << typeInst->get_name() << " is bound to";
-///       eqvClass.type->print( std::cout );
-///       std::cout << std::endl;
-                                eqvClass.type->accept( *this );
+///       std::cerr << typeInst->get_name() << " is bound to";
+///       eqvClass.type->print( std::cerr );
+///       std::cerr << std::endl;
+                                eqvClass.type->accept( *visitor );
                         } // if
                 } // if

src/ResolvExpr/PolyCost.cc

@@ -14 +14 @@
 //
 
+#include "Common/PassVisitor.h"
 #include "SymTab/Indexer.h"   // for Indexer
 #include "SynTree/Type.h"     // for TypeInstType, Type
-#include "SynTree/Visitor.h"  // for Visitor
 #include "TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 
 namespace ResolvExpr {
-        class PolyCost : public Visitor {
-          public:
+        struct PolyCost {
                 PolyCost( const TypeEnvironment &env, const SymTab::Indexer &indexer );
-                int get_result() const { return result; }
-          private:
-                virtual void visit(TypeInstType *aggregateUseType);
+
+                void previsit( TypeInstType * aggregateUseType );
                 int result;
-                const TypeEnvironment &env;
+                const TypeEnvironment &tenv;
                 const SymTab::Indexer &indexer;
         };
 
         int polyCost( Type *type, const TypeEnvironment & env, const SymTab::Indexer &indexer ) {
-                PolyCost coster( env, indexer );
+                PassVisitor<PolyCost> coster( env, indexer );
                 type->accept( coster );
-                return coster.get_result();
+                return coster.pass.result;
         }
 
-        PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), env( env ), indexer( indexer ) {
+        PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), tenv( env ), indexer( indexer ) {
         }
 
-        void PolyCost::visit(TypeInstType * typeInst) {
+        void PolyCost::previsit(TypeInstType * typeInst) {
                 EqvClass eqvClass;
-                if ( env.lookup( typeInst->name, eqvClass ) ) {
+                if ( tenv.lookup( typeInst->name, eqvClass ) ) {
                         if ( eqvClass.type ) {
                                 if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) {

src/ResolvExpr/PtrsAssignable.cc

@@ -67 +67 @@
         PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
+        void PtrsAssignable::visit( VoidType * ) {
                 // T * = void * is disallowed - this is a change from C, where any
                 // void * can be assigned or passed to a non-void pointer without a cast.

src/ResolvExpr/Resolver.cc

@@ -155 +155 @@
                 } // if
                 #endif
-                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end: (%zd) %s", finder.get_alternatives().size(), toString( untyped ).c_str() );
                 Alternative &choice = finder.get_alternatives().front();
                 Expression *newExpr = choice.expr->clone();
@@ -171 +171 @@
 
         namespace {
+                /// resolve `untyped` to the expression whose type satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
+                template<typename Pred>
+                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, Pred pred) {
+                        TypeEnvironment env;
+                        AlternativeFinder finder( indexer, env );
+                        finder.findWithAdjustment( untyped );
+
+                        AltList candidates;
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                if ( pred( alt.expr->result ) ) {
+                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
+
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
+                                throw SemanticError( "No reasonable alternatives for " + kindStr + " expression: ", untyped );
+                        } else if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " + kindStr +  " expression\n";
+                                untyped->print( stream );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
+                                throw SemanticError( stream.str() );
+                        }
+
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & alt = winners.front();
+                        finishExpr( alt.expr, alt.env, untyped->env );
+                        delete untyped;
+                        untyped = alt.expr;
+                        alt.expr = nullptr;
+                }
+
                 bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
@@ -184 +220 @@
 
                 void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        Expression *newExpr = 0;
-                        const TypeEnvironment *newEnv = 0;
-                        for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
-                                        if ( newExpr ) {
-                                                throw SemanticError( "Too many interpretations for case control expression", untyped );
-                                        } else {
-                                                newExpr = i->expr->clone();
-                                                newEnv = &i->env;
-                                        } // if
-                                } // if
-                        } // for
-                        if ( ! newExpr ) {
-                                throw SemanticError( "No interpretations for case control expression", untyped );
-                        } // if
-                        finishExpr( newExpr, *newEnv, untyped->env );
-                        delete untyped;
-                        untyped = newExpr;
-                }
-
+                        findKindExpression( untyped, indexer, "condition", isIntegralType );
+                }
         }
 
@@ -311 +316 @@
 
         void Resolver::previsit( IfStmt *ifStmt ) {
-                findSingleExpression( ifStmt->condition, indexer );
+                findIntegralExpression( ifStmt->condition, indexer );
         }
 
         void Resolver::previsit( WhileStmt *whileStmt ) {
-                findSingleExpression( whileStmt->condition, indexer );
+                findIntegralExpression( whileStmt->condition, indexer );
         }
 
         void Resolver::previsit( ForStmt *forStmt ) {
                 if ( forStmt->condition ) {
-                        findSingleExpression( forStmt->condition, indexer );
+                        findIntegralExpression( forStmt->condition, indexer );
                 } // if
 
@@ -579 +584 @@
         }
 
+
         void Resolver::previsit( WithStmt * withStmt ) {
                 for ( Expression *& expr : withStmt->exprs )  {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.findWithAdjustment( expr );
-
                         // only struct- and union-typed expressions are viable candidates
-                        AltList candidates;
-                        for ( Alternative & alt : finder.get_alternatives() ) {
-                                if ( isStructOrUnion( alt.expr->result ) ) {
-                                        candidates.push_back( std::move( alt ) );
-                                }
-                        }
-
-                        // choose the lowest cost expression among the candidates
-                        AltList winners;
-                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
-                        if ( winners.size() == 0 ) {
-                                throw SemanticError( "No reasonable alternatives for with statement expression: ", expr );
-                        } else if ( winners.size() != 1 ) {
-                                std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n";
-                                expr->print( stream );
-                                stream << "Alternatives are:\n";
-                                printAlts( winners, stream, 1 );
-                                throw SemanticError( stream.str() );
-                        }
-
-                        // there is one unambiguous interpretation - move the expression into the with statement
-                        Alternative & alt = winners.front();
-                        finishExpr( alt.expr, alt.env, expr->env );
-                        delete expr;
-                        expr = alt.expr;
-                        alt.expr = nullptr;
+                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
 
                         // if with expression might be impure, create a temporary so that it is evaluated once

src/ResolvExpr/Resolver.h

@@ -33 +33 @@
         void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
         void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
+        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );