Changeset b1e63ac5 for src/ResolvExpr

Timestamp:

Jul 4, 2017, 9:40:16 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:

208e5be

Parents:

9c951e3 (diff), f7cb0bc (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' into references

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (7 diffs)
• AlternativeFinder.h (modified) (1 diff)
• CastCost.cc (modified) (3 diffs)
• CommonType.cc (modified) (6 diffs)
• ConversionCost.cc (modified) (9 diffs)
• CurrentObject.cc (added)
• CurrentObject.h (added)
• PtrsAssignable.cc (modified) (4 diffs)
• PtrsCastable.cc (modified) (3 diffs)
• Resolver.cc (modified) (9 diffs)
• TypeMap.h (modified) (2 diffs)
• Unify.cc (modified) (12 diffs)
• module.mk (modified) (2 diffs)
• typeops.h (modified) (2 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -97 +97 @@
                 /// Prunes a list of alternatives down to those that have the minimum conversion cost for a given return type; skips ambiguous interpretations
                 template< typename InputIterator, typename OutputIterator >
-                void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
+                void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out ) {
                         // select the alternatives that have the minimum conversion cost for a particular set of result types
                         std::map< std::string, PruneStruct > selected;
@@ -183 +183 @@
                         )
                         AltList::iterator oldBegin = alternatives.begin();
-                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
+                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
                         if ( alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
@@ -604 +604 @@
 //          )
                 SymTab::Indexer decls( indexer );
-                PRINT(
-                        std::cerr << "============= original indexer" << std::endl;
-                        indexer.print( std::cerr );
-                        std::cerr << "============= new indexer" << std::endl;
-                        decls.print( std::cerr );
-                )
+                // PRINT(
+                //      std::cerr << "============= original indexer" << std::endl;
+                //      indexer.print( std::cerr );
+                //      std::cerr << "============= new indexer" << std::endl;
+                //      decls.print( std::cerr );
+                // )
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
@@ -627 +627 @@
                 TypeEnvironment resultEnv;
                 makeUnifiableVars( funcType, openVars, resultNeed );
+                resultEnv.add( funcType->get_forall() ); // add all type variables as open variables now so that those not used in the parameter list are still considered open
                 AltList instantiatedActuals; // filled by instantiate function
                 if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
@@ -808 +809 @@
         }
 
+        Expression * restructureCast( Expression * argExpr, Type * toType ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
+                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                        // more components of the tuple than components in the target type, then excess components do not
+                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                                // expressions which may contain side effects require a single unique instance of the expression.
+                                argExpr = new UniqueExpr( argExpr );
+                        }
+                        std::list< Expression * > componentExprs;
+                        for ( unsigned int i = 0; i < toType->size(); i++ ) {
+                                // cast each component
+                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
+                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
+                        }
+                        delete argExpr;
+                        assert( componentExprs.size() > 0 );
+                        // produce the tuple of casts
+                        return new TupleExpr( componentExprs );
+                } else {
+                        // handle normally
+                        return new CastExpr( argExpr, toType->clone() );
+                }
+        }
+
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
@@ -839 +866 @@
                                 thisCost += Cost( 0, 0, discardedValues );
 
-                                Expression * argExpr = i->expr->clone();
-                                if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
-                                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
-                                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
-                                        // more components of the tuple than components in the target type, then excess components do not
-                                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
-                                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
-                                                // expressions which may contain side effects require a single unique instance of the expression.
-                                                argExpr = new UniqueExpr( argExpr );
-                                        }
-                                        std::list< Expression * > componentExprs;
-                                        for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
-                                                // cast each component
-                                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
-                                                componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
-                                        }
-                                        delete argExpr;
-                                        assert( componentExprs.size() > 0 );
-                                        // produce the tuple of casts
-                                        candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
-                                } else {
-                                        // handle normally
-                                        candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
-                                }
+                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
                         } // if
                 } // for
@@ -1181 +1185 @@
         }
 
+        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
+                // handle each option like a cast
+                AltList candidates;
+                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
+                // O(N^2) checks of d-types with e-types
+                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
+                        Type * toType = resolveTypeof( initAlt.type, indexer );
+                        SymTab::validateType( toType, &indexer );
+                        adjustExprType( toType, env, indexer );
+                        // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else
+                        // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving
+                        // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal.
+                        AlternativeFinder finder( indexer, env );
+                        finder.targetType = toType;
+                        finder.findWithAdjustment( initExpr->get_expr() );
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                TypeEnvironment newEnv( alt.env );
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
+                                PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
+                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
+                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
+                                // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
+                                // to.
+                                int discardedValues = alt.expr->get_result()->size() - toType->size();
+                                if ( discardedValues < 0 ) continue;
+                                // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
+                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
+                                // unification run for side-effects
+                                unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+
+                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
+                                if ( thisCost != Cost::infinity ) {
+                                        // count one safe conversion for each value that is thrown away
+                                        thisCost += Cost( 0, 0, discardedValues );
+                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                }
+                        }
+                }
+
+                // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
+                // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
+                // selects first based on argument cost, then on conversion cost.
+                AltList minArgCost;
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
+                findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -73 +73 @@
                 virtual void visit( UniqueExpr *unqExpr );
                 virtual void visit( StmtExpr *stmtExpr );
+                virtual void visit( UntypedInitExpr *initExpr );
                 /// Runs a new alternative finder on each element in [begin, end)
                 /// and writes each alternative finder to out.

src/ResolvExpr/CastCost.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CastCost.cc -- 
+// CastCost.cc --
 //
 // Author           : Richard C. Bilson
@@ -26 +26 @@
           public:
                 CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-  
+
                 virtual void visit( BasicType *basicType );
                 virtual void visit( PointerType *pointerType );
@@ -36 +36 @@
                         NamedTypeDecl *namedType;
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
-                                return castCost( src, eqvClass.type, indexer, env );
+                                if ( eqvClass.type ) {
+                                        return castCost( src, eqvClass.type, indexer, env );
+                                } else {
+                                        return Cost::infinity;
+                                }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );

src/ResolvExpr/CommonType.cc

@@ -43 +43 @@
 
                 void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer );
-                template< typename RefType > void handleRefType( RefType *inst, Type *other );
 
                 Type *result;
@@ -126 +125 @@
         }
 
-        void CommonType::visit( VoidType *voidType ) {
-        }
+        void CommonType::visit( __attribute((unused)) VoidType *voidType ) {}
 
         void CommonType::visit( BasicType *basicType ) {
@@ -159 +157 @@
         void CommonType::visit( PointerType *pointerType ) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
-                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base(), indexer) ) {
+                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
                                 getCommonWithVoidPointer( otherPointer, pointerType );
-                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base(), indexer) ) {
+                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) {
                                 getCommonWithVoidPointer( pointerType, otherPointer );
                         } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )
@@ -189 +187 @@
         }
 
-        void CommonType::visit( ArrayType *arrayType ) {
-        }
-
-        void CommonType::visit( FunctionType *functionType ) {
-        }
-
-        template< typename RefType > void CommonType::handleRefType( RefType *inst, Type *other ) {
-        }
-
-        void CommonType::visit( StructInstType *aggregateUseType ) {
-        }
-
-        void CommonType::visit( UnionInstType *aggregateUseType ) {
-        }
+        void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
+        void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
+        void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
+        void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType ) {}
 
         void CommonType::visit( EnumInstType *enumInstType ) {
@@ -214 +202 @@
         }
 
-        void CommonType::visit( TraitInstType *aggregateUseType ) {
+        void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType ) {
         }
 
@@ -239 +227 @@
         }
 
-        void CommonType::visit( TupleType *tupleType ) {
-        }
-
-        void CommonType::visit( VarArgsType *varArgsType ) {
-        }
+        void CommonType::visit( __attribute((unused)) TupleType *tupleType ) {}
+        void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType ) {}
 
         void CommonType::visit( ZeroType *zeroType ) {

src/ResolvExpr/ConversionCost.cc

@@ -30 +30 @@
 ///     std::cout << "type inst " << destAsTypeInst->get_name();
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
-                                return conversionCost( src, eqvClass.type, indexer, env );
+                                if ( eqvClass.type ) {
+                                        return conversionCost( src, eqvClass.type, indexer, env );
+                                } else {
+                                        return Cost::infinity;
+                                }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
 ///       std::cout << " found" << std::endl;
@@ -145 +149 @@
         };
 
-        void ConversionCost::visit(VoidType *voidType) {
+        void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) {
                 cost = Cost::infinity;
         }
@@ -182 +186 @@
         }
 
-        void ConversionCost::visit(ArrayType *arrayType) {
-        }
-
-        void ConversionCost::visit(FunctionType *functionType) {
-        }
+        void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
+        void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
 
         void ConversionCost::visit(StructInstType *inst) {
@@ -204 +205 @@
         }
 
-        void ConversionCost::visit(EnumInstType *inst) {
+        void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
@@ -213 +214 @@
         }
 
-        void ConversionCost::visit(TraitInstType *inst) {
+        void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) {
         }
 
@@ -235 +236 @@
         }
 
-        void ConversionCost::visit(TupleType *tupleType) {
+        void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
                 Cost c;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
@@ -255 +256 @@
         }
 
-        void ConversionCost::visit(VarArgsType *varArgsType) {
+        void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
@@ -261 +262 @@
         }
 
-        void ConversionCost::visit(ZeroType *zeroType) {
+        void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) {
                 if ( dynamic_cast< ZeroType* >( dest ) ) {
                         cost = Cost::zero;
@@ -277 +278 @@
         }
 
-        void ConversionCost::visit(OneType *oneType) {
+        void ConversionCost::visit( __attribute((unused)) OneType *oneType) {
                 if ( dynamic_cast< OneType* >( dest ) ) {
                         cost = Cost::zero;

src/ResolvExpr/PtrsAssignable.cc

@@ -63 +63 @@
         }
 
-        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {
-        }
+        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::visit( VoidType *voidType ) {
+        void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
                 if ( dynamic_cast< FunctionType* >( dest ) ) {
                         result = 0;
@@ -74 +73 @@
         }
 
-        void PtrsAssignable::visit( BasicType *basicType ) {
-        }
-
-        void PtrsAssignable::visit( PointerType *pointerType ) {
-        }
-
-        void PtrsAssignable::visit( ArrayType *arrayType ) {
-        }
-
-        void PtrsAssignable::visit( FunctionType *functionType ) {
+        void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {
                 result = -1;
         }
 
-        void PtrsAssignable::visit( StructInstType *inst ) {
-                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
-        }
-
-        void PtrsAssignable::visit( UnionInstType *inst ) {
-                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
-        }
+        void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
 
         void PtrsAssignable::visit( EnumInstType *inst ) {
@@ -103 +91 @@
         }
 
-        void PtrsAssignable::visit( TraitInstType *inst ) {
-                // I definitely don't think we should be doing anything here
-        }
-
+        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
         void PtrsAssignable::visit( TypeInstType *inst ) {
                 EqvClass eqvClass;
@@ -116 +101 @@
         }
 
-        void PtrsAssignable::visit( TupleType *tupleType ) {
-///  // This code doesn't belong here, but it might be useful somewhere else
-///   if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
-///     int ret = 0;
-///     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() ) {
-///       int assignResult = ptrsAssignable( *srcIt++, *destIt++ );
-///       if ( assignResult == 0 ) {
-///         result = assignResult;
-///         return;
-///       } else if ( assignResult < 0 ) {
-///         ret = -1;
-///       } else if ( ret > 0 ) {
-///         ret += assignResult;
-///       }
-///     }
-///     if ( srcIt == tupleType->get_types().end() && destIt == destAsTuple->get_types().end() ) {
-///       result = ret;
-///     } else {
-///       result = 0;
-///     }
-///   }
-        }
-
-        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
-        }
-
-        void PtrsAssignable::visit( ZeroType *zeroType ) {
-        }
-        
-        void PtrsAssignable::visit( OneType *oneType ) {
-        }
+        void PtrsAssignable::visit(  __attribute__((unused)) TupleType *tupleType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
         
 } // namespace ResolvExpr

src/ResolvExpr/PtrsCastable.cc

@@ -92 +92 @@
         }
 
-        void PtrsCastable::visit(VoidType *voidType) {
+        void PtrsCastable::visit( __attribute__((unused)) VoidType *voidType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(BasicType *basicType) {
+        void PtrsCastable::visit( __attribute__((unused)) BasicType *basicType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(PointerType *pointerType) {
+        void PtrsCastable::visit( __attribute__((unused)) PointerType *pointerType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(ArrayType *arrayType) {
+        void PtrsCastable::visit( __attribute__((unused)) ArrayType *arrayType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(FunctionType *functionType) {
+        void PtrsCastable::visit( __attribute__((unused)) FunctionType *functionType) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(StructInstType *inst) {
+        void PtrsCastable::visit( __attribute__((unused)) StructInstType *inst) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(UnionInstType *inst) {
+        void PtrsCastable::visit( __attribute__((unused)) UnionInstType *inst) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(EnumInstType *inst) {
+        void PtrsCastable::visit( __attribute__((unused)) EnumInstType *inst) {
                 if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
@@ -135 +135 @@
         }
 
-        void PtrsCastable::visit(TraitInstType *inst) {
-                // I definitely don't think we should be doing anything here
-        }
+        void PtrsCastable::visit( __attribute__((unused)) TraitInstType *inst ) {}
 
         void PtrsCastable::visit(TypeInstType *inst) {
@@ -144 +142 @@
         }
 
-        void PtrsCastable::visit(TupleType *tupleType) {
+        void PtrsCastable::visit( __attribute__((unused)) TupleType *tupleType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(VarArgsType *varArgsType) {
+        void PtrsCastable::visit( __attribute__((unused)) VarArgsType *varArgsType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(ZeroType *zeroType) {
+        void PtrsCastable::visit( __attribute__((unused)) ZeroType *zeroType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(OneType *oneType) {
+        void PtrsCastable::visit( __attribute__((unused)) OneType *oneType) {
                 result = objectCast( dest, env, indexer );
         }

src/ResolvExpr/Resolver.cc

@@ -14 +14 @@
 //
 
+#include <iostream>
+
+#include "Alternative.h"
+#include "AlternativeFinder.h"
+#include "CurrentObject.h"
+#include "RenameVars.h"
 #include "Resolver.h"
-#include "AlternativeFinder.h"
-#include "Alternative.h"
-#include "RenameVars.h"
 #include "ResolveTypeof.h"
 #include "typeops.h"
+
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
+
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"
-#include "SymTab/Autogen.h"
+
 #include "Common/utility.h"
+
 #include "InitTweak/InitTweak.h"
 
-#include <iostream>
 using namespace std;
 
@@ -39 +45 @@
                         if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
                                 functionReturn = res->functionReturn;
-                                initContext = res->initContext;
+                                currentObject = res->currentObject;
                                 inEnumDecl = res->inEnumDecl;
                         }
@@ -79 +85 @@
 
                 Type * functionReturn = nullptr;
-                Type *initContext = nullptr;
+                CurrentObject currentObject = nullptr;
                 bool inEnumDecl = false;
         };
@@ -124 +130 @@
                         } // if
 #endif
-                        assert( finder.get_alternatives().size() == 1 );
+                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
                         Alternative &choice = finder.get_alternatives().front();
                         Expression *newExpr = choice.expr->clone();
@@ -186 +192 @@
                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
                 // the RHS.
-                Type *temp = initContext;
-                initContext = new_type;
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                ValueGuard<CurrentObject> temp( currentObject );
+                currentObject = CurrentObject( objectDecl->get_type() );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // enumerator initializers should not use the enum type to initialize, since
                         // the enum type is still incomplete at this point. Use signed int instead.
-                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
                 }
                 Parent::visit( objectDecl );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // delete newly created signed int type
-                        delete initContext;
-                }
-                initContext = temp;
+                        // delete currentObject.getType();
+                }
         }
 
@@ -315 +320 @@
 
         void Resolver::visit( SwitchStmt *switchStmt ) {
-                ValueGuard< Type * > oldInitContext( initContext );
+                ValueGuard< CurrentObject > oldCurrentObject( currentObject );
                 Expression *newExpr;
                 newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
@@ -321 +326 @@
                 switchStmt->set_condition( newExpr );
 
-                initContext = newExpr->get_result();
+                currentObject = CurrentObject( newExpr->get_result() );
                 Parent::visit( switchStmt );
         }
@@ -327 +332 @@
         void Resolver::visit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
-                        assert( initContext );
-                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() );
+                        std::list< InitAlternative > initAlts = currentObject.getOptions();
+                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
                         Expression * newExpr = findSingleExpression( castExpr, *this );
                         castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
@@ -370 +376 @@
 
         void Resolver::visit( SingleInit *singleInit ) {
-                if ( singleInit->get_value() ) {
-                        // // find all the d's
-                        // std::list<Expression *> &designators = singleInit->get_designators();
-                        // std::list<Type *> types1{ initContext }, types2;
-                        // for ( Expression * expr: designators ) {
-                        //      cerr << expr << endl;
-                        //      if ( NameExpr * nexpr = dynamic_cast<NameExpr *>( expr ) ) {
-                        //              for ( Type * type: types1 ) {
-                        //                      cerr << type << endl;
-                        //                      ReferenceToType * fred = dynamic_cast<ReferenceToType *>(type);
-                        //                      std::list<Declaration *> members;
-                        //                      if ( fred ) {
-                        //                              fred->lookup( nexpr->get_name(), members ); // concatenate identical field name
-                        //                              for ( Declaration * mem: members ) {
-                        //                                      if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>(mem) ) {
-                        //                                              types2.push_back( dwt->get_type() );
-                        //                                      } // if
-                        //                              } // for
-                        //                      } // if
-                        //              } // for
-                        //              types1 = types2;
-                        //              types2.clear();
-                        //      } // if
-                        // } // for
-                        // // for ( Type * type: types1 ) {
-                        // //   cerr << type << endl;
-                        // // } // for
-                        
-                        // // O(N^2) checks of d-types with f-types
-                        // // find the minimum cost
-                        CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, *this );
-                        delete castExpr;
-                        singleInit->set_value( newExpr );
-
-                        // check if initializing type is char[]
-                        if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                                if ( isCharType( at->get_base() ) ) {
-                                        // check if the resolved type is char *
-                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
-                                                if ( isCharType( pt->get_base() ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
-                                                        CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
-                                                        singleInit->set_value( ce->get_arg() );
-                                                        ce->set_arg( NULL );
-                                                        delete ce;
-                                                }
+                // resolve initialization using the possibilities as determined by the currentObject cursor
+                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
+                Expression * newExpr = findSingleExpression( untyped, *this );
+                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
+
+                // move cursor to the object that is actually initialized
+                currentObject.setNext( initExpr->get_designation() );
+
+                // discard InitExpr wrapper and retain relevant pieces
+                newExpr = initExpr->get_expr();
+                newExpr->set_env( initExpr->get_env() );
+                initExpr->set_expr( nullptr );
+                initExpr->set_env( nullptr );
+                delete initExpr;
+
+                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
+                Type * initContext = currentObject.getCurrentType();
+
+                // check if actual object's type is char[]
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        if ( isCharType( at->get_base() ) ) {
+                                // check if the resolved type is char *
+                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( isCharType( pt->get_base() ) ) {
+                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
+                                                newExpr = ce->get_arg();
+                                                ce->set_arg( nullptr );
+                                                delete ce;
                                         }
                                 }
                         }
-                } // if
-        }
-
-        template< typename AggrInst >
-        TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
-                assert( inst );
-                assert( inst->get_baseParameters() );
-                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
-                std::list< Expression * > typeSubs = inst->get_parameters();
-                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
-                return subs;
-        }
-
-        ReferenceToType * isStructOrUnion( Type * type ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
-                        return sit;
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
-                        return uit;
-                }
-                return nullptr;
-        }
-
-        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
-                DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
-                assert( dt );
-                // need to substitute for generic types, so that casts are to concrete types
-                initContext = dt->get_type()->clone();
-                sub.apply( initContext );
-
-                try {
-                        if ( init == initEnd ) return; // stop when there are no more initializers
-                        (*init)->accept( *this );
-                        ++init; // made it past an initializer
-                } catch( SemanticError & ) {
-                        // need to delve deeper, if you can
-                        if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                                resolveAggrInit( type, init, initEnd );
-                        } else {
-                                // member is not an aggregate type, so can't go any deeper
-
-                                // might need to rethink what is being thrown
-                                throw;
-                        } // if
-                }
-        }
-
-        void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
-                        StructDecl * st = sit->get_baseStruct();
-                        if(st->get_members().empty()) return;
-                        // want to resolve each initializer to the members of the struct,
-                        // but if there are more initializers than members we should stop
-                        list< Declaration * >::iterator it = st->get_members().begin();
-                        for ( ; it != st->get_members().end(); ++it) {
-                                resolveSingleAggrInit( *it, init, initEnd, sub );
-                        }
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( uit );
-                        UnionDecl * un = uit->get_baseUnion();
-                        if(un->get_members().empty()) return;
-                        // only resolve to the first member of a union
-                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
-                } // if
+                }
+
+                // set initializer expr to resolved express
+                singleInit->set_value( newExpr );
+
+                // move cursor to next object in preparation for next initializer
+                currentObject.increment();
         }
 
         void Resolver::visit( ListInit * listInit ) {
-                InitIterator iter = listInit->begin();
-                InitIterator end = listInit->end();
-
-                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                        // resolve each member to the base type of the array
-                        for ( ; iter != end; ++iter ) {
-                                initContext = at->get_base();
-                                (*iter)->accept( *this );
-                        } // for
-                } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
-                        for ( Type * t : *tt ) {
-                                if ( iter == end ) break;
-                                initContext = t;
-                                (*iter++)->accept( *this );
-                        }
-                } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                        resolveAggrInit( type, iter, end );
-                } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
-                        Type * base = tt->get_baseType()->get_base();
-                        if ( base ) {
-                                // know the implementation type, so try using that as the initContext
-                                initContext = base;
-                                visit( listInit );
-                        } else {
-                                // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                                Parent::visit( listInit );
-                        }
-                } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
-                        // basic types are handled here
-                        Parent::visit( listInit );
-                }
-
-#if 0
-                if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
-                        std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
-                        for ( ; iter != listInit->end_initializers(); ++iter ) {
-                                initContext = at->get_base();
-                                (*iter)->accept( *this );
-                        } // for
-                } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
-                        StructDecl *baseStruct = st->get_baseStruct();
-                        std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
-                        std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
-                        for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) {
-                                if ( (*iter2)->get_designators().empty() ) {
-                                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
-                                        initContext = dt->get_type();
-                                        (*iter2)->accept( *this );
-                                        ++iter1;
-                                } else {
-                                        StructDecl *st = baseStruct;
-                                        iter1 = st->get_members().begin();
-                                        std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() );
-                                        for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) {
-                                                NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );
-                                                assert( key );
-                                                for ( ; iter1 != st->get_members().end(); ++iter1 ) {
-                                                        if ( key->get_name() == (*iter1)->get_name() ) {
-                                                                (*iter1)->print( cout );
-                                                                cout << key->get_name() << endl;
-                                                                ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
-                                                                assert( fred );
-                                                                StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() );
-                                                                assert( mary );
-                                                                st = mary->get_baseStruct();
-                                                                iter1 = st->get_members().begin();
-                                                                break;
-                                                        } // if
-                                                }  // for
-                                        } // for
-                                        ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
-                                        assert( fred );
-                                        initContext = fred->get_type();
-                                        (*listInit->begin_initializers())->accept( *this );
-                                } // if
-                        } // for
-                } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
-                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
-                        initContext = dt->get_type();
-                        (*listInit->begin_initializers())->accept( *this );
-                } // if
-#endif
+                // move cursor into brace-enclosed initializer-list
+                currentObject.enterListInit();
+                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
+                std::list<Designation *> newDesignations;
+                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
+                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
+                        // the initializer against that object.
+                        Designation * des = std::get<0>(p);
+                        Initializer * init = std::get<1>(p);
+                        newDesignations.push_back( currentObject.findNext( des ) );
+                        init->accept( *this );
+                }
+                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
+                listInit->get_designations() = newDesignations; // xxx - memory management
+                currentObject.exitListInit();
+
+                // xxx - this part has not be folded into CurrentObject yet
+                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
+                //      Type * base = tt->get_baseType()->get_base();
+                //      if ( base ) {
+                //              // know the implementation type, so try using that as the initContext
+                //              ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
+                //              currentObject = &tmpObj;
+                //              visit( listInit );
+                //      } else {
+                //              // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
+                //              Parent::visit( listInit );
+                //      }
+                // } else {
         }
 

src/ResolvExpr/TypeMap.h

@@ -110 +110 @@
                         }
 
-                        virtual void visit( VoidType *voidType ) {
+                        virtual void visit( __attribute__((unused)) VoidType *voidType ) {
                                 findAndReplace( typeMap.voidValue );
                         }
@@ -138 +138 @@
                         }
 
-                        virtual void visit( FunctionType *functionType ) {
+                        virtual void visit( __attribute__((unused)) FunctionType *functionType ) {
                                 findAndReplace( typeMap.functionPointerValue );
                         }

src/ResolvExpr/Unify.cc

@@ -115 +115 @@
         }
 
-        bool isFtype( Type *type, const SymTab::Indexer &indexer ) {
+        bool isFtype( Type *type ) {
                 if ( dynamic_cast< FunctionType* >( type ) ) {
                         return true;
@@ -124 +124 @@
         }
 
-        bool tyVarCompatible( const TypeDecl::Data & data, Type *type, const SymTab::Indexer &indexer ) {
+        bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
                 switch ( data.kind ) {
                   case TypeDecl::Any:
@@ -132 +132 @@
                         // type must also be complete
                         // xxx - should this also check that type is not a tuple type and that it's not a ttype?
-                        return ! isFtype( type, indexer ) && (! data.isComplete || type->isComplete() );
+                        return ! isFtype( type ) && (! data.isComplete || type->isComplete() );
                   case TypeDecl::Ftype:
-                        return isFtype( type, indexer );
+                        return isFtype( type );
                   case TypeDecl::Ttype:
                         // ttype unifies with any tuple type
@@ -145 +145 @@
                 OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
                 assert( tyvar != openVars.end() );
-                if ( ! tyVarCompatible( tyvar->second, other, indexer ) ) {
+                if ( ! tyVarCompatible( tyvar->second, other ) ) {
                         return false;
                 } // if
@@ -345 +345 @@
                 std::cerr << "unifyInexact type 1 is ";
                 type1->print( std::cerr );
-                std::cerr << "type 2 is ";
+                std::cerr << " type 2 is ";
                 type2->print( std::cerr );
                 std::cerr << std::endl;
@@ -389 +389 @@
         }
 
-        void Unify::visit(VoidType *voidType) {
+        void Unify::visit( __attribute__((unused)) VoidType *voidType) {
                 result = dynamic_cast< VoidType* >( type2 );
         }
@@ -615 +615 @@
                         } else if ( tupleParam ) {
                                 // bundle other parameters into tuple to match
-                                TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( otherParam->get_type()->clone() );
+                                        binderTypes.push_back( otherParam->get_type()->clone() );
                                         ++jt;
 
@@ -627 +627 @@
                                 } while (true);
 
-                                otherParamTy = binder;
+                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
                                 ++it;  // skip ttype parameter for break
                         } else if ( otherTupleParam ) {
                                 // bundle parameters into tuple to match other
-                                TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( param->get_type()->clone() );
+                                        binderTypes.push_back( param->get_type()->clone() );
                                         ++it;
 
@@ -643 +643 @@
                                 } while (true);
 
-                                paramTy = binder;
+                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
                                 ++jt;  // skip ttype parameter for break
                         }
@@ -692 +692 @@
 
         template< typename Iterator1, typename Iterator2 >
-        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 auto get_type = [](Type * t) { return t; };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
@@ -742 +742 @@
                         flatten( flat2.get(), back_inserter( types2 ) );
 
-                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
-                } // if
-        }
-
-        void Unify::visit(VarArgsType *varArgsType) {
+                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, indexer );
+                } // if
+        }
+
+        void Unify::visit( __attribute__((unused)) VarArgsType *varArgsType ) {
                 result = dynamic_cast< VarArgsType* >( type2 );
         }
 
-        void Unify::visit(ZeroType *zeroType) {
+        void Unify::visit( __attribute__((unused)) ZeroType *zeroType ) {
                 result = dynamic_cast< ZeroType* >( type2 );
         }
 
-        void Unify::visit(OneType *oneType) {
+        void Unify::visit( __attribute__((unused)) OneType *oneType ) {
                 result = dynamic_cast< OneType* >( type2 );
         }
@@ -765 +765 @@
                         return function->get_returnVals().front()->get_type()->clone();
                 } else {
-                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
+                        std::list< Type * > types;
                         for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                tupleType->get_types().push_back( decl->get_type()->clone() );
+                                types.push_back( decl->get_type()->clone() );
                         } // for
-                        return tupleType;
+                        return new TupleType( Type::Qualifiers(), types );
                 }
         }

src/ResolvExpr/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk -- 
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
@@ -31 +31 @@
        ResolvExpr/PolyCost.cc \
        ResolvExpr/Occurs.cc \
-       ResolvExpr/TypeEnvironment.cc
+       ResolvExpr/TypeEnvironment.cc \
+       ResolvExpr/CurrentObject.cc

src/ResolvExpr/typeops.h

@@ -118 +118 @@
 
         // in Unify.cc
-        bool isFtype( Type *type, const SymTab::Indexer &indexer );
+        bool isFtype( Type *type );
         bool typesCompatible( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
         bool typesCompatibleIgnoreQualifiers( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
@@ -130 +130 @@
                 TypeEnvironment env;
                 return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
-        }
-
-        template< typename Container1, typename Container2 >
-        bool typesCompatibleList( Container1 &c1, Container2 &c2, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                typename Container1::iterator i1 = c1.begin();
-                typename Container2::iterator i2 = c2.begin();
-                for ( ; i1 != c1.end() && i2 != c2.end(); ++i1, ++i2 ) {
-                        if ( ! typesCompatible( *i1, *i2, indexer ) ) {
-                                return false;
-                        } // if
-                }
-                return ( i1 == c1.end() ) && ( i2 == c2.end() );
         }