Changeset 2162c2c for src/ResolvExpr

Timestamp:

Jan 11, 2017, 4:11:02 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

075734f

Parents:

bb82c03 (diff), d3a85240 (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:

• AdjustExprType.cc (modified) (1 diff)
• AlternativeFinder.cc (modified) (12 diffs)
• AlternativeFinder.h (modified) (1 diff)
• FindOpenVars.cc (modified) (2 diffs)
• TypeEnvironment.cc (modified) (1 diff)
• TypeEnvironment.h (modified) (1 diff)
• Unify.cc (modified) (5 diffs)
• typeops.h (modified) (1 diff)

src/ResolvExpr/AdjustExprType.cc

@@ -22 +22 @@
         class AdjustExprType : public Mutator {
                 typedef Mutator Parent;
+                using Parent::mutate;
           public:
                 AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );

src/ResolvExpr/AlternativeFinder.cc

@@ -267 +267 @@
                 std::list< Expression* >& actuals = appExpr->get_args();
 
-                std::list< Type * > formalTypes;
-                std::list< Type * >::iterator formalType = formalTypes.end();
-
                 for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
-
+                        Type * actualType = (*actualExpr)->get_result();
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
                                 (*actualExpr)->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
-                                (*actualExpr)->get_result()->print( std::cerr, 8 );
-                        )
-                        std::list< DeclarationWithType* >::iterator startFormal = formal;
+                                actualType->print( std::cerr, 8 );
+                        )
                         Cost actualCost;
-                        std::list< Type * > flatActualTypes;
-                        flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
-                        for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
-
-
-                                // tuple handling code
-                                if ( formalType == formalTypes.end() ) {
-                                        // the type of the formal parameter may be a tuple type. To make this easier to work with,
-                                        // flatten the tuple type and traverse the resulting list of types, incrementing the formal
-                                        // iterator once its types have been extracted. Once a particular formal parameter's type has
-                                        // been exhausted load the next formal parameter's type.
-                                        if ( formal == formals.end() ) {
-                                                if ( function->get_isVarArgs() ) {
-                                                        convCost += Cost( 1, 0, 0 );
-                                                        break;
-                                                } else {
-                                                        return Cost::infinity;
-                                                }
-                                        }
-                                        formalTypes.clear();
-                                        flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
-                                        formalType = formalTypes.begin();
-                                        ++formal;
+                        if ( formal == formals.end() ) {
+                                if ( function->get_isVarArgs() ) {
+                                        convCost += Cost( 1, 0, 0 );
+                                        continue;
+                                } else {
+                                        return Cost::infinity;
                                 }
-
-                                PRINT(
-                                        std::cerr << std::endl << "converting ";
-                                        (*actualType)->print( std::cerr, 8 );
-                                        std::cerr << std::endl << " to ";
-                                        (*formalType)->print( std::cerr, 8 );
-                                )
-                                Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
-                                PRINT(
-                                        std::cerr << std::endl << "cost is" << newCost << std::endl;
-                                )
-
-                                if ( newCost == Cost::infinity ) {
-                                        return newCost;
-                                }
-                                convCost += newCost;
-                                actualCost += newCost;
-
-                                convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
-
-                                formalType++;
-                        }
+                        }
+                        Type * formalType = (*formal)->get_type();
+                        PRINT(
+                                std::cerr << std::endl << "converting ";
+                                actualType->print( std::cerr, 8 );
+                                std::cerr << std::endl << " to ";
+                                formalType->print( std::cerr, 8 );
+                        )
+                        Cost newCost = conversionCost( actualType, formalType, indexer, alt.env );
+                        PRINT(
+                                std::cerr << std::endl << "cost is" << newCost << std::endl;
+                        )
+
+                        if ( newCost == Cost::infinity ) {
+                                return newCost;
+                        }
+                        convCost += newCost;
+                        actualCost += newCost;
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
-                                std::list< DeclarationWithType* >::iterator startFormalPlusOne = startFormal;
-                                startFormalPlusOne++;
-                                if ( formal == startFormalPlusOne ) {
-                                        // not a tuple type
-                                        Type *newType = (*startFormal)->get_type()->clone();
-                                        alt.env.apply( newType );
-                                        *actualExpr = new CastExpr( *actualExpr, newType );
-                                } else {
-                                        TupleType *newType = new TupleType( Type::Qualifiers() );
-                                        for ( std::list< DeclarationWithType* >::iterator i = startFormal; i != formal; ++i ) {
-                                                newType->get_types().push_back( (*i)->get_type()->clone() );
-                                        }
-                                        alt.env.apply( newType );
-                                        *actualExpr = new CastExpr( *actualExpr, newType );
-                                }
-                        }
-
+                                Type *newType = formalType->clone();
+                                alt.env.apply( newType );
+                                *actualExpr = new CastExpr( *actualExpr, newType );
+                        }
+                        convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 );
+                        ++formal; // can't be in for-loop update because of the continue
                 }
                 if ( formal != formals.end() ) {
@@ -364 +328 @@
                         }
                         convCost += newCost;
-
                         convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
                 }
@@ -376 +339 @@
                         unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar };
                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
-                                needAssertions[ *assert ] = true;
+                                needAssertions[ *assert ].isUsed = true;
                         }
 ///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
@@ -388 +351 @@
                 if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
                         // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
-                        TupleExpr * tupleExpr = new TupleExpr();
+                        std::list< Expression * > exprs;
                         for ( Type * type : *tupleType ) {
-                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
-                                        delete tupleExpr;
+                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( exprs ) ) ) {
+                                        deleteAll( exprs );
                                         return false;
                                 }
                         }
-                        tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
-                        *out++ = tupleExpr;
+                        *out++ = new TupleExpr( exprs );
+                } else if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
+                        // xxx - mixing default arguments with variadic??
+                        std::list< Expression * > exprs;
+                        for ( ; actualIt != actualEnd; ++actualIt ) {
+                                exprs.push_back( actualIt->expr->clone() );
+                                cost += actualIt->cost;
+                        }
+                        Expression * arg = nullptr;
+                        if ( exprs.size() == 1 && Tuples::isTtype( exprs.front()->get_result() ) ) {
+                                // the case where a ttype value is passed directly is special, e.g. for argument forwarding purposes
+                                // xxx - what if passing multiple arguments, last of which is ttype?
+                                // xxx - what would happen if unify was changed so that unifying tuple types flattened both before unifying lists? then pass in TupleType(ttype) below.
+                                arg = exprs.front();
+                        } else {
+                                arg = new TupleExpr( exprs );
+                        }
+                        assert( arg && arg->get_result() );
+                        if ( ! unify( ttype, arg->get_result(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                return false;
+                        }
+                        *out++ = arg;
                 } else if ( actualIt != actualEnd ) {
                         // both actualType and formalType are atomic (non-tuple) types - if they unify
@@ -483 +466 @@
         void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
                 for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
-                        if ( i->second == true ) {
+                        if ( i->second.isUsed ) {
                                 i->first->accept( indexer );
                         }
@@ -494 +477 @@
                 if ( begin == end ) {
                         if ( newNeed.empty() ) {
+                                PRINT(
+                                        std::cerr << "all assertions satisfied, output alternative: ";
+                                        newAlt.print( std::cerr );
+                                        std::cerr << std::endl;
+                                );
                                 *out++ = newAlt;
                                 return;
@@ -510 +498 @@
 
                 ForwardIterator cur = begin++;
-                if ( ! cur->second ) {
+                if ( ! cur->second.isUsed ) {
                         inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
                         return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
@@ -554 +542 @@
                                 assert( (*candidate)->get_uniqueId() );
                                 DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
+
+                                // everything with an empty idChain was pulled in by the current assertion.
+                                // add current assertion's idChain + current assertion's ID so that the correct inferParameters can be found.
+                                for ( auto & a : newerNeed ) {
+                                        if ( a.second.idChain.empty() ) {
+                                                a.second.idChain = cur->second.idChain;
+                                                a.second.idChain.push_back( curDecl->get_uniqueId() );
+                                        }
+                                }
+
                                 //AssertionParentSet newNeedParents( needParents );
                                 // skip repeatingly-self-recursive assertion satisfaction
@@ -569 +567 @@
                                 )
                                 ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
+                                // follow the current assertion's ID chain to find the correct set of inferred parameters to add the candidate to (i.e. the set of inferred parameters belonging to the entity which requested the assertion parameter).
+                                InferredParams * inferParameters = &appExpr->get_inferParams();
+                                for ( UniqueId id : cur->second.idChain ) {
+                                        inferParameters = (*inferParameters)[ id ].inferParams.get();
+                                }
                                 // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
-                                appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
+                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
                                 inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
                         } else {
@@ -609 +612 @@
                 makeUnifiableVars( funcType, openVars, resultNeed );
                 AltList instantiatedActuals; // filled by instantiate function
-                if ( targetType && ! targetType->isVoid() ) {
+                if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
                         // attempt to narrow based on expected target type
                         Type * returnType = funcType->get_returnVals().front()->get_type();
@@ -1075 +1078 @@
         }
 
-        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
+        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
                 std::list< AlternativeFinder > subExprAlternatives;
                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
@@ -1081 +1084 @@
                 combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
                 for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
-                        TupleExpr *newExpr = new TupleExpr;
-                        makeExprList( *i, newExpr->get_exprs() );
-                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
+                        std::list< Expression * > exprs;
+                        makeExprList( *i, exprs );
 
                         TypeEnvironment compositeEnv;
                         simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
-                        alternatives.push_back( Alternative( newExpr, compositeEnv, sumCost( *i ) ) );
+                        alternatives.push_back( Alternative( new TupleExpr( exprs ) , compositeEnv, sumCost( *i ) ) );
                 } // for
+        }
+
+        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
+                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }
 

src/ResolvExpr/AlternativeFinder.h

@@ -64 +64 @@
                 virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( CommaExpr *commaExpr );
-                virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
                 virtual void visit( ConstructorExpr * ctorExpr );
+                virtual void visit( UntypedTupleExpr *tupleExpr );
+                virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( TupleIndexExpr *tupleExpr );
                 virtual void visit( TupleAssignExpr *tupleExpr );

src/ResolvExpr/FindOpenVars.cc

@@ -50 +50 @@
                                 openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
-                                        needAssertions[ *assert ] = false;
+                                        needAssertions[ *assert ].isUsed = false;
                                 }
 ///       cloneAll( (*i)->get_assertions(), needAssertions );
@@ -59 +59 @@
                                 closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
-                                        haveAssertions[ *assert ] = false;
+                                        haveAssertions[ *assert ].isUsed = false;
                                 }
 ///       cloneAll( (*i)->get_assertions(), haveAssertions );

src/ResolvExpr/TypeEnvironment.cc

@@ -75 +75 @@
                 for ( AssertionSet::const_iterator i = assertions.begin(); i != assertions.end(); ++i ) {
                         i->first->print( os, indent );
-                        if ( i->second ) {
+                        if ( i->second.isUsed ) {
                                 os << "(used)";
                         } else {

src/ResolvExpr/TypeEnvironment.h

@@ -31 +31 @@
                 bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const;
         };
-        typedef std::map< DeclarationWithType*, bool, AssertCompare > AssertionSet;
+        struct AssertionSetValue {
+                bool isUsed;
+                // chain of Unique IDs of the assertion declarations. The first ID in the chain is the ID of an assertion on the current type,
+                // with each successive ID being the ID of an assertion pulled in by the previous ID. The last ID in the chain is
+                // the ID of the assertion that pulled in the current assertion.
+                std::list< UniqueId > idChain;
+        };
+        typedef std::map< DeclarationWithType*, AssertionSetValue, AssertCompare > AssertionSet;
         typedef std::map< std::string, TypeDecl::Data > OpenVarSet;
 

src/ResolvExpr/Unify.cc

@@ -26 +26 @@
 #include "SymTab/Indexer.h"
 #include "Common/utility.h"
-
+#include "Tuples/Tuples.h"
 
 // #define DEBUG
@@ -157 +157 @@
                         // if the type variable is specified to be a complete type then the incoming
                         // 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 || isComplete( type ));
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
+                        case TypeDecl::Ttype:
+                        // ttype unifies with any tuple type
+                        return dynamic_cast< TupleType * >( type );
                 } // switch
-                assert( false );
                 return false;
         }
@@ -431 +434 @@
                 if ( i != assertions.end() ) {
 ///     std::cerr << "found it!" << std::endl;
-                        i->second = true;
+                        i->second.isUsed = true;
                 } // if
         }
@@ -485 +488 @@
         }
 
+        template< typename Iterator >
+        std::unique_ptr<Type> combineTypes( Iterator begin, Iterator end ) {
+                std::list< Type * > types;
+                for ( ; begin != end; ++begin ) {
+                        // it's guaranteed that a ttype variable will be bound to a flat tuple, so ensure that this results in a flat tuple
+                        flatten( (*begin)->get_type(), back_inserter( types ) );
+                }
+                return std::unique_ptr<Type>( new TupleType( Type::Qualifiers(), types ) );
+        }
+
         template< typename Iterator1, typename Iterator2 >
         bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
-                        // Type * commonType;
-                        // if ( ! unifyInexact( (*list1Begin)->get_type(), (*list2Begin)->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) {
-                        if ( ! unifyExact( (*list1Begin)->get_type(), (*list2Begin)->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
+                        Type * t1 = (*list1Begin)->get_type();
+                        Type * t2 = (*list2Begin)->get_type();
+                        bool isTtype1 = Tuples::isTtype( t1 );
+                        bool isTtype2 = Tuples::isTtype( t2 );
+                        // xxx - assumes ttype must be last parameter
+                        // xxx - there may be a nice way to refactor this, but be careful because the argument positioning might matter in some cases.
+                        if ( isTtype1 && ! isTtype2 ) {
+                                // combine all of the things in list2, then unify
+                                return unifyExact( t1, combineTypes( list2Begin, list2End ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else if ( isTtype2 && ! isTtype1 ) {
+                                // combine all of the things in list1, then unify
+                                return unifyExact( combineTypes( list1Begin, list1End ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
                                 return false;
                         } // if
                 } // for
-                if ( list1Begin != list1End || list2Begin != list2End ) {
-                        return false;
+                // may get to the end of one argument list before the end of the other. This is only okay when the other is a ttype
+                if ( list1Begin != list1End ) {
+                        // try unifying empty tuple type with ttype
+                        Type * t1 = (*list1Begin)->get_type();
+                        if ( Tuples::isTtype( t1 ) ) {
+                                return unifyExact( t1, combineTypes( list2Begin, list2End ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else return false;
+                } else if ( list2Begin != list2End ) {
+                        // try unifying empty tuple type with ttype
+                        Type * t2 = (*list2Begin)->get_type();
+                        if ( Tuples::isTtype( t2 ) ) {
+                                return unifyExact( combineTypes( list1Begin, list1End ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else return false;
                 } else {
                         return true;
                 } // if
+        }
+
+        /// Finds ttypes and replaces them with their expansion, if known.
+        /// This needs to be done so that satisfying ttype assertions is easier.
+        /// If this isn't done then argument lists can have wildly different
+        /// size and structure, when they should be compatible.
+        struct TtypeExpander : public Mutator {
+                TypeEnvironment & env;
+                TtypeExpander( TypeEnvironment & env ) : env( env ) {}
+                Type * mutate( TypeInstType * typeInst ) {
+                        EqvClass eqvClass;
+                        if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
+                                if ( eqvClass.data.kind == TypeDecl::Ttype ) {
+                                        // expand ttype parameter into its actual type
+                                        if ( eqvClass.type ) {
+                                                delete typeInst;
+                                                return eqvClass.type->clone();
+                                        }
+                                }
+                        }
+                        return typeInst;
+                }
+        };
+
+        /// flattens a list of declarations, so that each tuple type has a single declaration.
+        /// makes use of TtypeExpander to ensure ttypes are flat as well.
+        void flattenList( std::list< DeclarationWithType * > src, std::list< DeclarationWithType * > & dst, TypeEnvironment & env ) {
+                dst.clear();
+                for ( DeclarationWithType * dcl : src ) {
+                        TtypeExpander expander( env );
+                        dcl->acceptMutator( expander );
+                        std::list< Type * > types;
+                        flatten( dcl->get_type(), back_inserter( types ) );
+                        for ( Type * t : types ) {
+                                dst.push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t, nullptr ) );
+                        }
+                        delete dcl;
+                }
         }
 
@@ -504 +576 @@
                 FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
                 if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
-                        if ( functionType->get_parameters().size() == otherFunction->get_parameters().size() && functionType->get_returnVals().size() == otherFunction->get_returnVals().size() ) {
-                                if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-                                        if ( unifyDeclList( functionType->get_returnVals().begin(), functionType->get_returnVals().end(), otherFunction->get_returnVals().begin(), otherFunction->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-
+                        // flatten the parameter lists for both functions so that tuple structure
+                        // doesn't affect unification. Must be a clone so that the types don't change.
+                        std::unique_ptr<FunctionType> flatFunc( functionType->clone() );
+                        std::unique_ptr<FunctionType> flatOther( otherFunction->clone() );
+                        flattenList( flatFunc->get_parameters(), flatFunc->get_parameters(), env );
+                        flattenList( flatOther->get_parameters(), flatOther->get_parameters(), env );
+
+                        // sizes don't have to match if ttypes are involved; need to be more precise wrt where the ttype is to prevent errors
+                        if ( (flatFunc->get_parameters().size() == flatOther->get_parameters().size() && flatFunc->get_returnVals().size() == flatOther->get_returnVals().size()) || flatFunc->isTtype() || flatOther->isTtype() ) {
+                                if ( unifyDeclList( flatFunc->get_parameters().begin(), flatFunc->get_parameters().end(), flatOther->get_parameters().begin(), flatOther->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                        if ( unifyDeclList( flatFunc->get_returnVals().begin(), flatFunc->get_returnVals().end(), flatOther->get_returnVals().begin(), flatOther->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+
+                                                // the original types must be used in mark assertions, since pointer comparisons are used
                                                 markAssertions( haveAssertions, needAssertions, functionType );
                                                 markAssertions( haveAssertions, needAssertions, otherFunction );

src/ResolvExpr/typeops.h

@@ -164 +164 @@
                         }
                 } else {
-                        *out++ = type;
+                        *out++ = type->clone();
                 }
         }