Changeset 67130fe for src/ResolvExpr

Timestamp:

Jun 4, 2019, 6:39:23 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

c6a1e8a

Parents:

7564e10 (diff), 1346914 (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:

• AlternativeFinder.cc (modified) (2 diffs)
• CommonType.cc (modified) (12 diffs)
• FindOpenVars.cc (modified) (5 diffs)
• FindOpenVars.h (modified) (1 diff)
• ResolveAssertions.cc (modified) (2 diffs)
• Resolver.cc (modified) (28 diffs)
• Resolver.h (modified) (3 diffs)
• TypeEnvironment.cc (modified) (9 diffs)
• TypeEnvironment.h (modified) (1 diff)
• Unify.cc (modified) (26 diffs)
• Unify.h (modified) (3 diffs)
• WidenMode.h (modified) (1 diff)
• typeops.h (modified) (7 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -28 +28 @@
 #include "Alternative.h"           // for AltList, Alternative
 #include "AlternativeFinder.h"
+#include "AST/Expr.hpp"
+#include "AST/Type.hpp"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for deleteAll, printAll, CodeLocation
@@ -222 +224 @@
                         cost.incReference();
                 }
+        }
+
+        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost ) {
+                if ( expr->result.as< ast::ReferenceType >() ) {
+                        // cast away reference from expr
+                        cost.incReference();
+                        return new ast::CastExpr{ expr->location, expr, expr->result->stripReferences() };
+                }
+                
+                return expr;
         }
 

src/ResolvExpr/CommonType.cc

@@ -18 +18 @@
 #include <utility>                       // for pair
 
+#include "AST/Decl.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
@@ -35 +37 @@
 
 namespace ResolvExpr {
-        struct CommonType : public WithShortCircuiting {
-                CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
+        struct CommonType_old : public WithShortCircuiting {
+                CommonType_old( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
                 Type *get_result() const { return result; }
 
@@ -94 +96 @@
 
         Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
-                PassVisitor<CommonType> visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
+                PassVisitor<CommonType_old> visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
 
                 int depth1 = type1->referenceDepth();
@@ -483 +485 @@
         );
 
-        CommonType::CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
+        CommonType_old::CommonType_old( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
                 : result( 0 ), type2( type2 ), widenFirst( widenFirst ), widenSecond( widenSecond ), indexer( indexer ), env( env ), openVars( openVars ) {
         }
 
-        void CommonType::postvisit( VoidType * ) {}
-
-        void CommonType::postvisit( BasicType *basicType ) {
+        void CommonType_old::postvisit( VoidType * ) {}
+
+        void CommonType_old::postvisit( BasicType *basicType ) {
                 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
                         BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ];
@@ -505 +507 @@
 
         template< typename Pointer >
-        void CommonType::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) {
+        void CommonType_old::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) {
                 if ( TypeInstType* var = dynamic_cast< TypeInstType* >( otherPointer->get_base() ) ) {
                         OpenVarSet::const_iterator entry = openVars.find( var->get_name() );
@@ -518 +520 @@
         }
 
-        void CommonType::postvisit( PointerType *pointerType ) {
+        void CommonType_old::postvisit( PointerType *pointerType ) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
                         // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl;
@@ -553 +555 @@
         }
 
-        void CommonType::postvisit( ArrayType * ) {}
-
-        void CommonType::postvisit( ReferenceType *refType ) {
+        void CommonType_old::postvisit( ArrayType * ) {}
+
+        void CommonType_old::postvisit( ReferenceType *refType ) {
                 if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
                         // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl;
@@ -590 +592 @@
         }
 
-        void CommonType::postvisit( FunctionType * ) {}
-        void CommonType::postvisit( StructInstType * ) {}
-        void CommonType::postvisit( UnionInstType * ) {}
-
-        void CommonType::postvisit( EnumInstType *enumInstType ) {
+        void CommonType_old::postvisit( FunctionType * ) {}
+        void CommonType_old::postvisit( StructInstType * ) {}
+        void CommonType_old::postvisit( UnionInstType * ) {}
+
+        void CommonType_old::postvisit( EnumInstType *enumInstType ) {
                 if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
@@ -601 +603 @@
         }
 
-        void CommonType::postvisit( TraitInstType * ) {
-        }
-
-        void CommonType::postvisit( TypeInstType *inst ) {
+        void CommonType_old::postvisit( TraitInstType * ) {
+        }
+
+        void CommonType_old::postvisit( TypeInstType *inst ) {
                 if ( widenFirst ) {
                         NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
@@ -626 +628 @@
         }
 
-        void CommonType::postvisit( TupleType * ) {}
-        void CommonType::postvisit( VarArgsType * ) {}
-
-        void CommonType::postvisit( ZeroType *zeroType ) {
+        void CommonType_old::postvisit( TupleType * ) {}
+        void CommonType_old::postvisit( VarArgsType * ) {}
+
+        void CommonType_old::postvisit( ZeroType *zeroType ) {
                 if ( widenFirst ) {
                         if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
@@ -643 +645 @@
         }
 
-        void CommonType::postvisit( OneType *oneType ) {
+        void CommonType_old::postvisit( OneType *oneType ) {
                 if ( widenFirst ) {
                         if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
@@ -656 +658 @@
                 }
         }
+
+        class CommonType_new final : public ast::WithShortCircuiting {
+                const ast::Type * type2;
+                WidenMode widen;
+                const ast::SymbolTable & symtab;
+                ast::TypeEnvironment & tenv;
+                const ast::OpenVarSet & open;
+        public:
+                ast::ptr< ast::Type > result;
+
+                CommonType_new( 
+                        const ast::Type * t2, WidenMode w, const ast::SymbolTable & st, 
+                        ast::TypeEnvironment & env, const ast::OpenVarSet & o )
+                : type2( t2 ), widen( w ), symtab( st ), tenv( env ), open( o ), result() {}
+
+                void previsit( const ast::Node * ) { visit_children = false; }
+
+                void postvisit( const ast::VoidType * ) {}
+
+                void postvisit( const ast::BasicType * basic ) {
+                        if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
+                                #warning remove casts when `commonTypes` moved to new AST
+                                ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
+                                if ( 
+                                        ( ( kind == basic->kind && basic->qualifiers >= basic2->qualifiers ) 
+                                                || widen.first ) 
+                                        && ( ( kind == basic2->kind && basic->qualifiers <= basic2->qualifiers ) 
+                                                || widen.second ) 
+                                ) {
+                                        result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
+                                }
+                        } else if ( 
+                                dynamic_cast< const ast::EnumInstType * >( type2 ) 
+                                || dynamic_cast< const ast::ZeroType * >( type2 )
+                                || dynamic_cast< const ast::OneType * >( type2 )
+                        ) {
+                                #warning remove casts when `commonTypes` moved to new AST
+                                ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
+                                if ( 
+                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers ) 
+                                                || widen.first ) 
+                                        && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers ) 
+                                                || widen.second ) 
+                                ) {
+                                        result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
+                                }
+                        }
+                }
+
+        private:
+                template< typename Pointer >
+                void getCommonWithVoidPointer( const Pointer * voidPtr, const Pointer * oPtr ) {
+                        const ast::Type * base = oPtr->base;
+                        if ( auto var = dynamic_cast< const ast::TypeInstType * >( base ) ) {
+                                auto entry = open.find( var->name );
+                                if ( entry != open.end() ) {
+                                        ast::AssertionSet need, have;
+                                        if ( ! tenv.bindVar( 
+                                                var, voidPtr->base, entry->second, need, have, open, widen, symtab ) 
+                                        ) return;
+                                }
+                        }
+                        result = voidPtr;
+                        add_qualifiers( result, oPtr->qualifiers );
+                }
+
+        public:
+                void postvisit( const ast::PointerType * pointer ) {
+                        if ( auto pointer2 = dynamic_cast< const ast::PointerType * >( type2 ) ) {
+                                if ( 
+                                        widen.first 
+                                        && pointer2->base.as< ast::VoidType >() 
+                                        && ! ast::isFtype( pointer->base ) 
+                                ) {
+                                        getCommonWithVoidPointer( pointer2, pointer );
+                                } else if ( 
+                                        widen.second 
+                                        && pointer->base.as< ast::VoidType >() 
+                                        && ! ast::isFtype( pointer2->base ) 
+                                ) {
+                                        getCommonWithVoidPointer( pointer, pointer2 );
+                                } else if (
+                                        ( pointer->base->qualifiers >= pointer2->base->qualifiers || widen.first )
+                                        && ( pointer->base->qualifiers <= pointer2->base->qualifiers || widen.second )
+                                ) {
+                                        ast::CV::Qualifiers q1 = pointer->base->qualifiers;
+                                        ast::CV::Qualifiers q2 = pointer2->base->qualifiers;
+
+                                        // force t{1,2} to be cloned if their qualifiers must be stripped, so that 
+                                        // pointer{,2}->base are unchanged
+                                        ast::ptr< ast::Type > t1{ pointer->base }, t2{ pointer2->base };
+                                        reset_qualifiers( t1 );
+                                        reset_qualifiers( t2 );
+                                        
+                                        ast::AssertionSet have, need;
+                                        ast::OpenVarSet newOpen{ open };
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                                result = pointer;
+                                                if ( q1.val != q2.val ) {
+                                                        // reset result->base->qualifiers to be union of two base qualifiers
+                                                        strict_dynamic_cast< ast::PointerType * >( 
+                                                                result.get_and_mutate() 
+                                                        )->base.get_and_mutate()->qualifiers = q1 | q2;
+                                                }
+                                        }
+                                }
+                        } else if ( widen.second && dynamic_cast< const ast::ZeroType * >( type2 ) ) {
+                                result = pointer;
+                                add_qualifiers( result, type2->qualifiers );
+                        }
+                }
+
+                void postvisit( const ast::ArrayType * ) {}
+
+                void postvisit( const ast::ReferenceType * ref ) {
+                        if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
+                                if (
+                                        widen.first && ref2->base.as< ast::VoidType >() && ! ast::isFtype( ref->base ) 
+                                ) {
+                                        getCommonWithVoidPointer( ref2, ref );
+                                } else if ( 
+                                        widen.second && ref->base.as< ast::VoidType>() && ! ast::isFtype( ref2->base ) 
+                                ) {
+                                        getCommonWithVoidPointer( ref, ref2 );
+                                } else if (
+                                        ( ref->base->qualifiers >= ref2->base->qualifiers || widen.first )
+                                        && ( ref->base->qualifiers <= ref2->base->qualifiers || widen.second )
+                                ) {
+                                        ast::CV::Qualifiers q1 = ref->base->qualifiers, q2 = ref2->base->qualifiers;
+
+                                        // force t{1,2} to be cloned if their qualifiers must be stripped, so that 
+                                        // ref{,2}->base are unchanged
+                                        ast::ptr< ast::Type > t1{ ref->base }, t2{ ref2->base };
+                                        reset_qualifiers( t1 );
+                                        reset_qualifiers( t2 );
+
+                                        ast::AssertionSet have, need;
+                                        ast::OpenVarSet newOpen{ open };
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                                result = ref;
+                                                if ( q1.val != q2.val ) {
+                                                        // reset result->base->qualifiers to be union of two base qualifiers
+                                                        strict_dynamic_cast< ast::ReferenceType * >( 
+                                                                result.get_and_mutate() 
+                                                        )->base.get_and_mutate()->qualifiers = q1 | q2;
+                                                }
+                                        }
+                                }
+                        } else if ( widen.second && dynamic_cast< const ast::ZeroType * >( type2 ) ) {
+                                result = ref;
+                                add_qualifiers( result, type2->qualifiers );
+                        }
+                }
+
+                void postvisit( const ast::FunctionType * ) {}
+
+                void postvisit( const ast::StructInstType * ) {}
+
+                void postvisit( const ast::UnionInstType * ) {}
+
+                void postvisit( const ast::EnumInstType * enumInst ) {
+                        if ( 
+                                dynamic_cast< const ast::BasicType * >( type2 ) 
+                                || dynamic_cast< const ast::ZeroType * >( type2 )
+                                || dynamic_cast< const ast::OneType * >( type2 )
+                        ) {
+                                // reuse BasicType/EnumInstType common type by swapping
+                                result = commonType( type2, enumInst, widen, symtab, tenv, open );
+                        }
+                }
+
+                void postvisit( const ast::TraitInstType * ) {}
+
+                void postvisit( const ast::TypeInstType * inst ) {
+                        if ( ! widen.first ) return;
+                        if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) {
+                                if ( const ast::Type * base = 
+                                                strict_dynamic_cast< const ast::TypeDecl * >( nt )->base 
+                                ) {
+                                        ast::CV::Qualifiers q1 = inst->qualifiers, q2 = type2->qualifiers;
+
+                                        // force t{1,2} to be cloned if their qualifiers must be mutated
+                                        ast::ptr< ast::Type > t1{ base }, t2{ type2 };
+                                        reset_qualifiers( t1, q1 );
+                                        reset_qualifiers( t2 );
+
+                                        ast::AssertionSet have, need;
+                                        ast::OpenVarSet newOpen{ open };
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                                result = type2;
+                                                reset_qualifiers( result, q1 | q2 );
+                                        }
+                                }
+                        }
+                }
+
+                void postvisit( const ast::TupleType * ) {}
+
+                void postvisit( const ast::VarArgsType * ) {}
+
+                void postvisit( const ast::ZeroType * zero ) {
+                        if ( ! widen.first ) return;
+                        if ( 
+                                dynamic_cast< const ast::BasicType * >( type2 )
+                                || dynamic_cast< const ast::PointerType * >( type2 )
+                                || dynamic_cast< const ast::EnumInstType * >( type2 )
+                        ) {
+                                if ( widen.second || zero->qualifiers <= type2->qualifiers ) {
+                                        result = type2;
+                                        add_qualifiers( result, zero->qualifiers );
+                                }
+                        } else if ( widen.second && dynamic_cast< const ast::OneType * >( type2 ) ) {
+                                result = new ast::BasicType{ 
+                                        ast::BasicType::SignedInt, zero->qualifiers | type2->qualifiers };
+                        }
+                }
+
+                void postvisit( const ast::OneType * one ) {
+                        if ( ! widen.first ) return;
+                        if ( 
+                                dynamic_cast< const ast::BasicType * >( type2 )
+                                || dynamic_cast< const ast::EnumInstType * >( type2 )
+                        ) {
+                                if ( widen.second || one->qualifiers <= type2->qualifiers ) {
+                                        result = type2;
+                                        add_qualifiers( result, one->qualifiers );
+                                }
+                        } else if ( widen.second && dynamic_cast< const ast::ZeroType * >( type2 ) ) {
+                                result = new ast::BasicType{ 
+                                        ast::BasicType::SignedInt, one->qualifiers | type2->qualifiers };
+                        }
+                }
+
+        };
+
+        namespace {
+                ast::ptr< ast::Type > handleReference( 
+                        const ast::ptr< ast::Type > & t1, const ast::ptr< ast::Type > & t2, WidenMode widen, 
+                        const ast::SymbolTable & symtab, ast::TypeEnvironment & env, 
+                        const ast::OpenVarSet & open 
+                ) {
+                        ast::ptr<ast::Type> common;
+                        ast::AssertionSet have, need;
+                        ast::OpenVarSet newOpen{ open };
+
+                        // need unify to bind type variables
+                        if ( unify( t1, t2, env, have, need, newOpen, symtab, common ) ) {
+                                ast::CV::Qualifiers q1 = t1->qualifiers, q2 = t2->qualifiers;
+                                PRINT(
+                                        std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
+                                )
+                                if ( ( widen.first || q2 <= q1 ) && ( widen.second || q1 <= q2 ) ) {
+                                        PRINT(
+                                                std::cerr << "widen okay" << std::endl;
+                                        )
+                                        add_qualifiers( common, q1 | q2 );
+                                        return common;
+                                }
+                        }
+
+                        PRINT(
+                                std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
+                        )
+                        return { nullptr };
+                }
+        }
+
+        ast::ptr< ast::Type > commonType(
+                        const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, 
+                        WidenMode widen, const ast::SymbolTable & symtab, ast::TypeEnvironment & env, 
+                        const ast::OpenVarSet & open 
+        ) {
+                unsigned depth1 = type1->referenceDepth();
+                unsigned depth2 = type2->referenceDepth();
+
+                if ( depth1 != depth2 ) {  // implies depth1 > 0 || depth2 > 0
+                        PRINT(
+                                std::cerr << "reference depth diff: " << (depth1-depth2) << std::endl;
+                        )
+                        ast::ptr< ast::Type > result;
+                        const ast::ReferenceType * ref1 = type1.as< ast::ReferenceType >();
+                        const ast::ReferenceType * ref2 = type1.as< ast::ReferenceType >();
+                        
+                        if ( depth1 > depth2 ) {
+                                assert( ref1 );
+                                result = handleReference( ref1->base, type2, widen, symtab, env, open );
+                        } else {  // implies depth1 < depth2
+                                assert( ref2 );
+                                result = handleReference( type1, ref2->base, widen, symtab, env, open );
+                        }
+
+                        if ( result && ref1 ) {
+                                // formal is reference, so result should be reference
+                                PRINT(
+                                        std::cerr << "formal is reference; result should be reference" << std::endl;
+                                )
+                                result = new ast::ReferenceType{ result, ref1->qualifiers };
+                        }
+
+                        PRINT(
+                                std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is "
+                                "[" << result << "]" << std::endl;
+                        )
+                        return result;
+                }
+                // otherwise both are reference types of the same depth and this is handled by the visitor
+                ast::Pass<CommonType_new> visitor{ type2, widen, symtab, env, open };
+                type1->accept( visitor );
+                ast::ptr< ast::Type > result = visitor.pass.result;
+
+                // handling for opaque type declarations (?)
+                if ( ! result && widen.second ) {
+                        if ( const ast::TypeInstType * inst = type2.as< ast::TypeInstType >() ) {
+                                if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) {
+                                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( nt );
+                                        if ( type->base ) {
+                                                ast::CV::Qualifiers q1 = type1->qualifiers, q2 = type2->qualifiers;
+                                                ast::AssertionSet have, need;
+                                                ast::OpenVarSet newOpen{ open };
+
+                                                // force t{1,2} to be cloned if its qualifiers must be stripped, so that 
+                                                // type1 and type->base are left unchanged; calling convention forces 
+                                                // {type1,type->base}->strong_ref >= 1
+                                                ast::ptr<ast::Type> t1{ type1 }, t2{ type->base };
+                                                reset_qualifiers( t1 );
+                                                reset_qualifiers( t2, q1 );
+                                                
+                                                if ( unifyExact( t1, t2, env, have, need, newOpen, noWiden(), symtab ) ) {
+                                                        result = t1;
+                                                        reset_qualifiers( result, q1 | q2 );
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                return result;
+        }
+
 } // namespace ResolvExpr
 

src/ResolvExpr/FindOpenVars.cc

@@ -19 +19 @@
 #include <map>                    // for map<>::mapped_type
 
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
@@ -24 +26 @@
 
 namespace ResolvExpr {
-        struct FindOpenVars : public WithGuards {
-                FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
+        struct FindOpenVars_old : public WithGuards {
+                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
 
                 void previsit( PointerType * pointerType );
@@ -40 +42 @@
 
         void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
-                PassVisitor<FindOpenVars> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
+                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
                 type->accept( finder );
         }
 
-        FindOpenVars::FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
+        FindOpenVars_old::FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
                 : openVars( openVars ), closedVars( closedVars ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), nextIsOpen( firstIsOpen ) {
         }
 
-        void FindOpenVars::common_action( Type *type ) {
+        void FindOpenVars_old::common_action( Type *type ) {
                 if ( nextIsOpen ) {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
@@ -76 +78 @@
         }
 
-        void FindOpenVars::previsit(PointerType *pointerType) {
+        void FindOpenVars_old::previsit(PointerType *pointerType) {
                 common_action( pointerType );
         }
 
-        void FindOpenVars::previsit(ArrayType *arrayType) {
+        void FindOpenVars_old::previsit(ArrayType *arrayType) {
                 common_action( arrayType );
         }
 
-        void FindOpenVars::previsit(FunctionType *functionType) {
+        void FindOpenVars_old::previsit(FunctionType *functionType) {
                 common_action( functionType );
                 nextIsOpen = ! nextIsOpen;
@@ -90 +92 @@
         }
 
-        void FindOpenVars::previsit(TupleType *tupleType) {
+        void FindOpenVars_old::previsit(TupleType *tupleType) {
                 common_action( tupleType );
+        }
+
+        namespace {
+                struct FindOpenVars_new final : public ast::WithGuards {
+                        ast::OpenVarSet & open;
+                        ast::OpenVarSet & closed;
+                        ast::AssertionSet & need;
+                        ast::AssertionSet & have;
+                        bool nextIsOpen;
+
+                        FindOpenVars_new( 
+                                ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n, 
+                                ast::AssertionSet & h, FirstMode firstIsOpen )
+                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
+
+                        void previsit( const ast::FunctionType * type ) {
+                                // mark open/closed variables
+                                if ( nextIsOpen ) {
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                open[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        need[ assert ].isUsed = false;
+                                                }
+                                        }
+                                } else {
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                closed[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        have[ assert ].isUsed = false;
+                                                }
+                                        }
+                                }
+
+                                // flip open variables for contained function types
+                                nextIsOpen = ! nextIsOpen;
+                                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
+                        }
+
+                };
+        }
+
+        void findOpenVars( 
+                        const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, 
+                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
+                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
+                type->accept( finder );
         }
 } // namespace ResolvExpr

src/ResolvExpr/FindOpenVars.h

@@ -16 +16 @@
 #pragma once
 
+#include "AST/TypeEnvironment.hpp"  // for AssertionSet, OpenVarSet
 #include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
 
 class Type;
+namespace ast {
+        class Type;
+}
 
 namespace ResolvExpr {
         // Updates open and closed variables and their associated assertions
         void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
+
+        enum FirstMode { FirstClosed, FirstOpen };
+
+        // Updates open and closed variables and their associated assertions
+        void findOpenVars( 
+                const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, 
+                ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen );
 } // namespace ResolvExpr
 

src/ResolvExpr/ResolveAssertions.cc

@@ -30 +30 @@
 #include "Common/Indenter.h"        // for Indenter
 #include "Common/utility.h"         // for sort_mins
+#include "GenPoly/GenPoly.h"        // for getFunctionType
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
 #include "SymTab/Indexer.h"         // for Indexer
@@ -154 +155 @@
                         Cost k = Cost::zero;
                         for ( const auto& assn : x.assns ) {
+                                // compute conversion cost from satisfying decl to assertion
                                 k += computeConversionCost( 
                                         assn.match.adjType, assn.decl->get_type(), indexer, x.env );
                                 
                                 // mark vars+specialization cost on function-type assertions
-                                Type* assnType = assn.match.cdata.id->get_type();
-                                FunctionType* func;
-                                if ( PointerType* ptr = dynamic_cast< PointerType* >( assnType ) ) {
-                                        func = dynamic_cast< FunctionType* >( ptr->base );
-                                } else {
-                                        func = dynamic_cast< FunctionType* >( assnType );
-                                }
+                                FunctionType* func = GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
                                 if ( ! func ) continue;
                                 

src/ResolvExpr/Resolver.cc

@@ -7 +7 @@
 // Resolver.cc --
 //
-// Author           : Richard C. Bilson
+// Author           : Aaron B. Moss
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 19 18:09:56 2019
-// Update Count     : 240
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed May 29 11:00:00 2019
+// Update Count     : 241
 //
 
@@ -21 +21 @@
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
+#include "CurrentObject.h"               // for CurrentObject
+#include "RenameVars.h"                  // for RenameVars, global_renamer
+#include "Resolver.h"
+#include "ResolvMode.h"                  // for ResolvMode
+#include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
+#include "AST/Pass.hpp"
+#include "AST/SymbolTable.hpp"
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/utility.h"              // for ValueGuard, group_iterate
-#include "CurrentObject.h"               // for CurrentObject
 #include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
-#include "RenameVars.h"                  // for RenameVars, global_renamer
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
-#include "Resolver.h"
-#include "ResolvMode.h"                  // for ResolvMode
 #include "SymTab/Autogen.h"              // for SizeType
 #include "SymTab/Indexer.h"              // for Indexer
@@ -41 +45 @@
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "Tuples/Tuples.h"
-#include "typeops.h"                     // for extractResultType
-#include "Unify.h"                       // for unify
 #include "Validate/FindSpecialDecls.h"   // for SizeType
 
@@ -48 +50 @@
 
 namespace ResolvExpr {
-        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting, public WithStmtsToAdd {
-                Resolver() {}
-                Resolver( const SymTab::Indexer & other ) {
+        struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver_old>, public WithShortCircuiting, public WithStmtsToAdd {
+                Resolver_old() {}
+                Resolver_old( const SymTab::Indexer & other ) {
                         indexer = other;
                 }
@@ -101 +103 @@
 
         void resolve( std::list< Declaration * > translationUnit ) {
-                PassVisitor<Resolver> resolver;
+                PassVisitor<Resolver_old> resolver;
                 acceptAll( translationUnit, resolver );
         }
 
         void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
-                PassVisitor<Resolver> resolver( indexer );
+                PassVisitor<Resolver_old> resolver( indexer );
                 maybeAccept( decl, resolver );
         }
@@ -402 +404 @@
         }
 
-        void Resolver::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
-                // class-variable initContext is changed multiple time because the LHS is analysed twice.
-                // The second analysis changes initContext because of a function type can contain object
-                // declarations in the return and parameter types. So each value of initContext is
+        void Resolver_old::previsit( ObjectDecl * objectDecl ) {
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
+                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
+                // The second analysis changes initContext because of a function type can contain object 
+                // declarations in the return and parameter types. So each value of initContext is 
                 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
                 GuardValue( currentObject );
@@ -418 +420 @@
 
         template< typename PtrType >
-        void Resolver::handlePtrType( PtrType * type ) {
+        void Resolver_old::handlePtrType( PtrType * type ) {
                 if ( type->get_dimension() ) {
                         findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
@@ -424 +426 @@
         }
 
-        void Resolver::previsit( ArrayType * at ) {
+        void Resolver_old::previsit( ArrayType * at ) {
                 handlePtrType( at );
         }
 
-        void Resolver::previsit( PointerType * pt ) {
+        void Resolver_old::previsit( PointerType * pt ) {
                 handlePtrType( pt );
         }
 
-        void Resolver::previsit( FunctionDecl * functionDecl ) {
+        void Resolver_old::previsit( FunctionDecl * functionDecl ) {
 #if 0
                 std::cerr << "resolver visiting functiondecl ";
@@ -442 +444 @@
         }
 
-        void Resolver::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up
+        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
+                // default value expressions have an environment which shouldn't be there and trips up 
                 // later passes.
                 // xxx - it might be necessary to somehow keep the information from this environment, but I
@@ -457 +459 @@
         }
 
-        void Resolver::previsit( EnumDecl * ) {
+        void Resolver_old::previsit( EnumDecl * ) {
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
@@ -463 +465 @@
         }
 
-        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
+        void Resolver_old::previsit( StaticAssertDecl * assertDecl ) {
                 findIntegralExpression( assertDecl->condition, indexer );
         }
 
-        void Resolver::previsit( ExprStmt * exprStmt ) {
+        void Resolver_old::previsit( ExprStmt * exprStmt ) {
                 visit_children = false;
                 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
@@ -473 +475 @@
         }
 
-        void Resolver::previsit( AsmExpr * asmExpr ) {
+        void Resolver_old::previsit( AsmExpr * asmExpr ) {
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
@@ -481 +483 @@
         }
 
-        void Resolver::previsit( AsmStmt * asmStmt ) {
+        void Resolver_old::previsit( AsmStmt * asmStmt ) {
                 visit_children = false;
                 acceptAll( asmStmt->get_input(), *visitor );
@@ -487 +489 @@
         }
 
-        void Resolver::previsit( IfStmt * ifStmt ) {
+        void Resolver_old::previsit( IfStmt * ifStmt ) {
                 findIntegralExpression( ifStmt->condition, indexer );
         }
 
-        void Resolver::previsit( WhileStmt * whileStmt ) {
+        void Resolver_old::previsit( WhileStmt * whileStmt ) {
                 findIntegralExpression( whileStmt->condition, indexer );
         }
 
-        void Resolver::previsit( ForStmt * forStmt ) {
+        void Resolver_old::previsit( ForStmt * forStmt ) {
                 if ( forStmt->condition ) {
                         findIntegralExpression( forStmt->condition, indexer );
@@ -505 +507 @@
         }
 
-        void Resolver::previsit( SwitchStmt * switchStmt ) {
+        void Resolver_old::previsit( SwitchStmt * switchStmt ) {
                 GuardValue( currentObject );
                 findIntegralExpression( switchStmt->condition, indexer );
@@ -512 +514 @@
         }
 
-        void Resolver::previsit( CaseStmt * caseStmt ) {
+        void Resolver_old::previsit( CaseStmt * caseStmt ) {
                 if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
@@ -531 +533 @@
         }
 
-        void Resolver::previsit( BranchStmt * branchStmt ) {
+        void Resolver_old::previsit( BranchStmt * branchStmt ) {
                 visit_children = false;
                 // must resolve the argument for a computed goto
@@ -542 +544 @@
         }
 
-        void Resolver::previsit( ReturnStmt * returnStmt ) {
+        void Resolver_old::previsit( ReturnStmt * returnStmt ) {
                 visit_children = false;
                 if ( returnStmt->expr ) {
@@ -549 +551 @@
         }
 
-        void Resolver::previsit( ThrowStmt * throwStmt ) {
+        void Resolver_old::previsit( ThrowStmt * throwStmt ) {
                 visit_children = false;
                 // TODO: Replace *exception type with &exception type.
@@ -561 +563 @@
         }
 
-        void Resolver::previsit( CatchStmt * catchStmt ) {
+        void Resolver_old::previsit( CatchStmt * catchStmt ) {
                 if ( catchStmt->cond ) {
                         findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
@@ -576 +578 @@
         }
 
-        void Resolver::previsit( WaitForStmt * stmt ) {
+        void Resolver_old::previsit( WaitForStmt * stmt ) {
                 visit_children = false;
 
@@ -782 +784 @@
         }
 
-        void Resolver::previsit( SingleInit * singleInit ) {
+        void Resolver_old::previsit( SingleInit * singleInit ) {
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
@@ -834 +836 @@
         }
 
-        void Resolver::previsit( ListInit * listInit ) {
+        void Resolver_old::previsit( ListInit * listInit ) {
                 visit_children = false;
                 // move cursor into brace-enclosed initializer-list
@@ -869 +871 @@
 
         // ConstructorInit - fall back on C-style initializer
-        void Resolver::fallbackInit( ConstructorInit * ctorInit ) {
+        void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) {
                 // could not find valid constructor, or found an intrinsic constructor
                 // fall back on C-style initializer
@@ -882 +884 @@
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
                 assert( ctorInit );
-                PassVisitor<Resolver> resolver( indexer );
+                PassVisitor<Resolver_old> resolver( indexer );
                 ctorInit->accept( resolver );
         }
@@ -888 +890 @@
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
                 assert( stmtExpr );
-                PassVisitor<Resolver> resolver( indexer );
+                PassVisitor<Resolver_old> resolver( indexer );
                 stmtExpr->accept( resolver );
                 stmtExpr->computeResult();
@@ -894 +896 @@
         }
 
-        void Resolver::previsit( ConstructorInit * ctorInit ) {
+        void Resolver_old::previsit( ConstructorInit * ctorInit ) {
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
@@ -928 +930 @@
                 // }
         }
+
+        ///////////////////////////////////////////////////////////////////////////
+        //
+        // *** NEW RESOLVER ***
+        //
+        ///////////////////////////////////////////////////////////////////////////
+
+        class Resolver_new final 
+        : public ast::WithIndexer, public ast::WithGuards, public ast::WithVisitorRef<Resolver_new>, 
+          public ast::WithShortCircuiting, public ast::WithStmtsToAdd<> {
+                  
+        public: 
+                Resolver_new() = default;
+                Resolver_new( const ast::SymbolTable & syms ) { /*symtab = syms;*/ }
+
+                void previsit( ast::FunctionDecl * functionDecl );
+                ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl );
+                void previsit( ast::ObjectDecl * objectDecl );
+                void previsit( ast::EnumDecl * enumDecl );
+                void previsit( ast::StaticAssertDecl * assertDecl );
+
+                void previsit( ast::ArrayType * at );
+                void previsit( ast::PointerType * pt );
+
+                void previsit( ast::ExprStmt * exprStmt );
+                void previsit( ast::AsmExpr * asmExpr );
+                void previsit( ast::AsmStmt * asmStmt );
+                void previsit( ast::IfStmt * ifStmt );
+                void previsit( ast::WhileStmt * whileStmt );
+                void previsit( ast::ForStmt * forStmt );
+                void previsit( ast::SwitchStmt * switchStmt );
+                void previsit( ast::CaseStmt * caseStmt );
+                void previsit( ast::BranchStmt * branchStmt );
+                void previsit( ast::ReturnStmt * returnStmt );
+                void previsit( ast::ThrowStmt * throwStmt );
+                void previsit( ast::CatchStmt * catchStmt );
+                void previsit( ast::WaitForStmt * stmt );
+
+                void previsit( ast::SingleInit * singleInit );
+                void previsit( ast::ListInit * listInit );
+                void previsit( ast::ConstructorInit * ctorInit );
+        };
+
+        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
+                ast::Pass<Resolver_new> resolver;
+                accept_all( translationUnit, resolver );
+        }
+
+        void previsit( ast::FunctionDecl * functionDecl ) {
+                #warning unimplemented; Resolver port in progress
+                (void)functionDecl;
+                assert(false);
+        }
+
+        ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl ) {
+                #warning unimplemented; Resolver port in progress
+                (void)functionDecl;
+                assert(false);
+                return nullptr;
+        }
+
+        void previsit( ast::ObjectDecl * objectDecl ) {
+                #warning unimplemented; Resolver port in progress
+                (void)objectDecl;
+                assert(false);
+        }
+
+        void previsit( ast::EnumDecl * enumDecl ) {
+                #warning unimplemented; Resolver port in progress
+                (void)enumDecl;
+                assert(false);
+        }
+
+        void previsit( ast::StaticAssertDecl * assertDecl ) {
+                #warning unimplemented; Resolver port in progress
+                (void)assertDecl;
+                assert(false);
+        }
+
+        void previsit( ast::ArrayType * at ) {
+                #warning unimplemented; Resolver port in progress
+                (void)at;
+                assert(false);
+        }
+
+        void previsit( ast::PointerType * pt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)pt;
+                assert(false);
+        }
+
+        void previsit( ast::ExprStmt * exprStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)exprStmt;
+                assert(false);
+        }
+
+        void previsit( ast::AsmExpr * asmExpr ) {
+                #warning unimplemented; Resolver port in progress
+                (void)asmExpr;
+                assert(false);
+        }
+
+        void previsit( ast::AsmStmt * asmStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)asmStmt;
+                assert(false);
+        }
+
+        void previsit( ast::IfStmt * ifStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)ifStmt;
+                assert(false);
+        }
+
+        void previsit( ast::WhileStmt * whileStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)whileStmt;
+                assert(false);
+        }
+
+        void previsit( ast::ForStmt * forStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)forStmt;
+                assert(false);
+        }
+
+        void previsit( ast::SwitchStmt * switchStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)switchStmt;
+                assert(false);
+        }
+
+        void previsit( ast::CaseStmt * caseStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)caseStmt;
+                assert(false);
+        }
+
+        void previsit( ast::BranchStmt * branchStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)branchStmt;
+                assert(false);
+        }
+
+        void previsit( ast::ReturnStmt * returnStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)returnStmt;
+                assert(false);
+        }
+
+        void previsit( ast::ThrowStmt * throwStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)throwStmt;
+                assert(false);
+        }
+
+        void previsit( ast::CatchStmt * catchStmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)catchStmt;
+                assert(false);
+        }
+
+        void previsit( ast::WaitForStmt * stmt ) {
+                #warning unimplemented; Resolver port in progress
+                (void)stmt;
+                assert(false);
+        }
+
+        void previsit( ast::SingleInit * singleInit ) {
+                #warning unimplemented; Resolver port in progress
+                (void)singleInit;
+                assert(false);
+        }
+
+        void previsit( ast::ListInit * listInit ) {
+                #warning unimplemented; Resolver port in progress
+                (void)listInit;
+                assert(false);
+        }
+
+        void previsit( ast::ConstructorInit * ctorInit ) {
+                #warning unimplemented; Resolver port in progress
+                (void)ctorInit;
+                assert(false);
+        }
+
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.h

@@ -16 +16 @@
 #pragma once
 
-#include <list>  // for list
+#include <list>          // for list
+#include <AST/Node.hpp>  // for ptr
 
 class ConstructorInit;
@@ -23 +24 @@
 class StmtExpr;
 namespace SymTab {
-class Indexer;
-}  // namespace SymTab
+        class Indexer;
+} // namespace SymTab
+
+namespace ast {
+        class Decl;
+} // namespace ast
 
 namespace ResolvExpr {
@@ -40 +45 @@
         /// Resolves with-stmts and with-clauses on functions
         void resolveWithExprs( std::list< Declaration * > & translationUnit );
+
+        /// Checks types and binds syntactic constructs to typed representations
+        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit );
 } // namespace ResolvExpr
 

src/ResolvExpr/TypeEnvironment.cc

@@ -205 +205 @@
                                 // attempt to unify bound types
                                 std::unique_ptr<Type> toType{ to.type->clone() }, fromType{ from.type->clone() };
-                                WidenMode widenMode{ to.allowWidening, from.allowWidening };
+                                WidenMode widen{ to.allowWidening, from.allowWidening };
                                 Type* common = nullptr;
                                 AssertionSet need, have;
-                                if ( unifyInexact( toType.get(), fromType.get(), *this, need, have, openVars, widenMode, indexer, common ) ) {
+                                if ( unifyInexact( toType.get(), fromType.get(), *this, need, have, openVars, widen, indexer, common ) ) {
                                         // unifies, set common type if necessary
                                         if ( common ) {
@@ -343 +343 @@
         }
 
-        bool TypeEnvironment::bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool TypeEnvironment::bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
 
                 // remove references from other, so that type variables can only bind to value types
@@ -362 +362 @@
                                 std::unique_ptr< Type > newType( curClass->type->clone() );
                                 newType->get_qualifiers() = typeInst->get_qualifiers();
-                                if ( unifyInexact( newType.get(), bindTo, *this, need, have, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
+                                if ( unifyInexact( newType.get(), bindTo, *this, need, have, openVars, widen & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
                                         if ( common ) {
                                                 common->get_qualifiers() = Type::Qualifiers{};
@@ -372 +372 @@
                                 newType->get_qualifiers() = Type::Qualifiers{};
                                 curClass->set_type( newType );
-                                curClass->allowWidening = widenMode.widenFirst && widenMode.widenSecond;
+                                curClass->allowWidening = widen.first && widen.second;
                         } // if
                 } else {
@@ -379 +379 @@
                         newClass.type = bindTo->clone();
                         newClass.type->get_qualifiers() = Type::Qualifiers();
-                        newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
+                        newClass.allowWidening = widen.first && widen.second;
                         newClass.data = data;
                         env.push_back( std::move(newClass) );
@@ -388 +388 @@
         bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2, 
                         TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, 
-                        const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+                        const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
 
                 auto class1 = internal_lookup( var1->get_name() );
@@ -395 +395 @@
                 // exit early if variables already bound together
                 if ( class1 != env.end() && class1 == class2 ) {
-                        class1->allowWidening &= widenMode;
+                        class1->allowWidening &= widen;
                         return true;
                 }
@@ -408 +408 @@
                                 type1 = class1->type;
                         } // if
-                        widen1 = widenMode.widenFirst && class1->allowWidening;
+                        widen1 = widen.first && class1->allowWidening;
                 } // if
                 if ( class2 != env.end() ) {
@@ -415 +415 @@
                                 type2 = class2->type;
                         } // if
-                        widen2 = widenMode.widenSecond && class2->allowWidening;
+                        widen2 = widen.second && class2->allowWidening;
                 } // if
 

src/ResolvExpr/TypeEnvironment.h

@@ -136 +136 @@
                 /// Binds the type class represented by `typeInst` to the type `bindTo`; will add 
                 /// the class if needed. Returns false on failure.
-                bool bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+                bool bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
                 
                 /// Binds the type classes represented by `var1` and `var2` together; will add 
                 /// one or both classes if needed. Returns false on failure.
-                bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+                bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
 
                 /// Disallows widening for all bindings in the environment

src/ResolvExpr/Unify.cc

@@ -14 +14 @@
 //
 
-#include <cassert>                // for assertf, assert
-#include <iterator>               // for back_insert_iterator, back_inserter
-#include <map>                    // for _Rb_tree_const_iterator, _Rb_tree_i...
-#include <memory>                 // for unique_ptr
-#include <set>                    // for set
-#include <string>                 // for string, operator==, operator!=, bas...
-#include <utility>                // for pair, move
+#include "Unify.h"
+
+#include <cassert>                  // for assertf, assert
+#include <iterator>                 // for back_insert_iterator, back_inserter
+#include <map>                      // for _Rb_tree_const_iterator, _Rb_tree_i...
+#include <memory>                   // for unique_ptr
+#include <set>                      // for set
+#include <string>                   // for string, operator==, operator!=, bas...
+#include <utility>                  // for pair, move
 #include <vector>
 
+#include "AST/Decl.hpp"
 #include "AST/Node.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"   // for PassVisitor
-#include "FindOpenVars.h"         // for findOpenVars
-#include "Parser/LinkageSpec.h"   // for C
-#include "SynTree/Constant.h"     // for Constant
-#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Data, Declarati...
-#include "SynTree/Expression.h"   // for TypeExpr, Expression, ConstantExpr
-#include "SynTree/Mutator.h"      // for Mutator
-#include "SynTree/Type.h"         // for Type, TypeInstType, FunctionType
-#include "SynTree/Visitor.h"      // for Visitor
-#include "Tuples/Tuples.h"        // for isTtype
-#include "TypeEnvironment.h"      // for EqvClass, AssertionSet, OpenVarSet
-#include "Unify.h"
-#include "typeops.h"              // for flatten, occurs, commonType
+#include "AST/TypeEnvironment.hpp"
+#include "Common/PassVisitor.h"     // for PassVisitor
+#include "FindOpenVars.h"           // for findOpenVars
+#include "Parser/LinkageSpec.h"     // for C
+#include "SynTree/Constant.h"       // for Constant
+#include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
+#include "SynTree/Expression.h"     // for TypeExpr, Expression, ConstantExpr
+#include "SynTree/Mutator.h"        // for Mutator
+#include "SynTree/Type.h"           // for Type, TypeInstType, FunctionType
+#include "SynTree/Visitor.h"        // for Visitor
+#include "Tuples/Tuples.h"          // for isTtype
+#include "TypeEnvironment.h"        // for EqvClass, AssertionSet, OpenVarSet
+#include "typeops.h"                // for flatten, occurs, commonType
+
+namespace ast {
+        class SymbolTable;
+}
 
 namespace SymTab {
@@ -47 +55 @@
 namespace ResolvExpr {
 
-        struct Unify : public WithShortCircuiting {
-                Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+        struct Unify_old : public WithShortCircuiting {
+                Unify_old( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
 
                 bool get_result() const { return result; }
@@ -80 +88 @@
                 AssertionSet &haveAssertions;
                 const OpenVarSet &openVars;
-                WidenMode widenMode;
+                WidenMode widen;
                 const SymTab::Indexer &indexer;
         };
@@ -86 +94 @@
         /// Attempts an inexact unification of type1 and type2.
         /// Returns false if no such unification; if the types can be unified, sets common (unless they unify exactly and have identical type qualifiers)
-        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common );
-        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
+        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
+
+        bool unifyExact( 
+                const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
+                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
+                WidenMode widen, const ast::SymbolTable & symtab );
 
         bool typesCompatible( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
@@ -106 +119 @@
                 delete newSecond;
                 return result;
+        }
+
+        bool typesCompatible( 
+                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, 
+                        const ast::TypeEnvironment & env ) {
+                ast::TypeEnvironment newEnv;
+                ast::OpenVarSet open, closed;
+                ast::AssertionSet need, have;
+
+                ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
+                env.apply( newFirst );
+                env.apply( newSecond );
+
+                findOpenVars( newFirst, open, closed, need, have, FirstClosed );
+                findOpenVars( newSecond, open, closed, need, have, FirstOpen );
+
+                return unifyExact( 
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -132 +163 @@
         }
 
+        bool typesCompatibleIgnoreQualifiers( 
+                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, 
+                        const ast::TypeEnvironment & env ) {
+                ast::TypeEnvironment newEnv;
+                ast::OpenVarSet open;
+                ast::AssertionSet need, have;
+                
+                ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
+                env.apply( newFirst );
+                env.apply( newSecond );
+                reset_qualifiers( newFirst );
+                reset_qualifiers( newSecond );
+
+                return unifyExact( 
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+        }
+
         bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 OpenVarSet closedVars;
@@ -154 +202 @@
         }
 
-        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
 #ifdef DEBUG
                 TypeEnvironment debugEnv( env );
@@ -181 +229 @@
                                 result = env.bindVarToVar(
                                         var1, var2, TypeDecl::Data{ entry1->second, entry2->second }, needAssertions,
-                                        haveAssertions, openVars, widenMode, indexer );
+                                        haveAssertions, openVars, widen, indexer );
                         }
                 } else if ( isopen1 ) {
-                        result = env.bindVar( var1, type2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
-                } else if ( isopen2 ) { // TODO: swap widenMode values in call, since type positions are flipped?
-                        result = env.bindVar( var2, type1, entry2->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                        result = env.bindVar( var1, type2, entry1->second, needAssertions, haveAssertions, openVars, widen, indexer );
+                } else if ( isopen2 ) { // TODO: swap widen values in call, since type positions are flipped?
+                        result = env.bindVar( var2, type1, entry2->second, needAssertions, haveAssertions, openVars, widen, indexer );
                 } else {
-                        PassVisitor<Unify> comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                        PassVisitor<Unify_old> comparator( type2, env, needAssertions, haveAssertions, openVars, widen, indexer );
                         type1->accept( comparator );
                         result = comparator.pass.get_result();
@@ -213 +261 @@
         }
 
-        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common ) {
+        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common ) {
                 Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
                 type1->get_qualifiers() = Type::Qualifiers();
@@ -225 +273 @@
                 std::cerr << std::endl;
 #endif
-                if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ) ) {
+                if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widen, indexer ) ) {
 #ifdef DEBUG
                         std::cerr << "unifyInexact: no exact unification found" << std::endl;
 #endif
-                        if ( ( common = commonType( type1, type2, widenMode.widenFirst, widenMode.widenSecond, indexer, env, openVars ) ) ) {
+                        if ( ( common = commonType( type1, type2, widen.first, widen.second, indexer, env, openVars ) ) ) {
                                 common->get_qualifiers() = tq1 | tq2;
 #ifdef DEBUG
@@ -245 +293 @@
                 } else {
                         if ( tq1 != tq2 ) {
-                                if ( ( tq1 > tq2 || widenMode.widenFirst ) && ( tq2 > tq1 || widenMode.widenSecond ) ) {
+                                if ( ( tq1 > tq2 || widen.first ) && ( tq2 > tq1 || widen.second ) ) {
                                         common = type1->clone();
                                         common->get_qualifiers() = tq1 | tq2;
@@ -263 +311 @@
         }
 
-        Unify::Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer )
-                : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widenMode( widenMode ), indexer( indexer ) {
-        }
-
-        void Unify::postvisit( __attribute__((unused)) VoidType *voidType) {
+        Unify_old::Unify_old( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer )
+                : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widen( widen ), indexer( indexer ) {
+        }
+
+        void Unify_old::postvisit( __attribute__((unused)) VoidType *voidType) {
                 result = dynamic_cast< VoidType* >( type2 );
         }
 
-        void Unify::postvisit(BasicType *basicType) {
+        void Unify_old::postvisit(BasicType *basicType) {
                 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
                         result = basicType->get_kind() == otherBasic->get_kind();
@@ -299 +347 @@
         }
 
-        void Unify::postvisit(PointerType *pointerType) {
+        void Unify_old::postvisit(PointerType *pointerType) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
                         result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
@@ -307 +355 @@
         }
 
-        void Unify::postvisit(ReferenceType *refType) {
+        void Unify_old::postvisit(ReferenceType *refType) {
                 if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
                         result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
@@ -315 +363 @@
         }
 
-        void Unify::postvisit(ArrayType *arrayType) {
+        void Unify_old::postvisit(ArrayType *arrayType) {
                 ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
                 // to unify, array types must both be VLA or both not VLA
@@ -395 +443 @@
         /// If this isn't done then argument lists can have wildly different
         /// size and structure, when they should be compatible.
-        struct TtypeExpander : public WithShortCircuiting {
+        struct TtypeExpander_old : public WithShortCircuiting {
                 TypeEnvironment & tenv;
-                TtypeExpander( TypeEnvironment & tenv ) : tenv( tenv ) {}
+                TtypeExpander_old( TypeEnvironment & tenv ) : tenv( tenv ) {}
                 void premutate( TypeInstType * ) { visit_children = false; }
                 Type * postmutate( TypeInstType * typeInst ) {
@@ -416 +464 @@
                 dst.clear();
                 for ( DeclarationWithType * dcl : src ) {
-                        PassVisitor<TtypeExpander> expander( env );
+                        PassVisitor<TtypeExpander_old> expander( env );
                         dcl->acceptMutator( expander );
                         std::list< Type * > types;
@@ -431 +479 @@
         }
 
-        void Unify::postvisit(FunctionType *functionType) {
+        void Unify_old::postvisit(FunctionType *functionType) {
                 FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
                 if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
@@ -442 +490 @@
 
                         // 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->parameters.size() == flatOther->parameters.size() && flatFunc->returnVals.size() == flatOther->returnVals.size()) || flatFunc->isTtype() || flatOther->isTtype() ) {
+                        if ( 
+                                        (flatFunc->parameters.size() == flatOther->parameters.size() && 
+                                                flatFunc->returnVals.size() == flatOther->returnVals.size()) 
+                                        || flatFunc->isTtype() 
+                                        || flatOther->isTtype() 
+                        ) {
                                 if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
                                         if ( unifyDeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
@@ -458 +511 @@
 
         template< typename RefType >
-        void Unify::handleRefType( RefType *inst, Type *other ) {
+        void Unify_old::handleRefType( RefType *inst, Type *other ) {
                 // check that other type is compatible and named the same
                 RefType *otherStruct = dynamic_cast< RefType* >( other );
@@ -465 +518 @@
 
         template< typename RefType >
-        void Unify::handleGenericRefType( RefType *inst, Type *other ) {
+        void Unify_old::handleGenericRefType( RefType *inst, Type *other ) {
                 // Check that other type is compatible and named the same
                 handleRefType( inst, other );
@@ -533 +586 @@
         }
 
-        void Unify::postvisit(StructInstType *structInst) {
+        void Unify_old::postvisit(StructInstType *structInst) {
                 handleGenericRefType( structInst, type2 );
         }
 
-        void Unify::postvisit(UnionInstType *unionInst) {
+        void Unify_old::postvisit(UnionInstType *unionInst) {
                 handleGenericRefType( unionInst, type2 );
         }
 
-        void Unify::postvisit(EnumInstType *enumInst) {
+        void Unify_old::postvisit(EnumInstType *enumInst) {
                 handleRefType( enumInst, type2 );
         }
 
-        void Unify::postvisit(TraitInstType *contextInst) {
+        void Unify_old::postvisit(TraitInstType *contextInst) {
                 handleRefType( contextInst, type2 );
         }
 
-        void Unify::postvisit(TypeInstType *typeInst) {
+        void Unify_old::postvisit(TypeInstType *typeInst) {
                 assert( openVars.find( typeInst->get_name() ) == openVars.end() );
                 TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 );
@@ -604 +657 @@
         }
 
-        void Unify::postvisit(TupleType *tupleType) {
+        void Unify_old::postvisit(TupleType *tupleType) {
                 if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
                         std::unique_ptr<TupleType> flat1( tupleType->clone() );
@@ -610 +663 @@
                         std::list<Type *> types1, types2;
 
-                        PassVisitor<TtypeExpander> expander( env );
+                        PassVisitor<TtypeExpander_old> expander( env );
                         flat1->acceptMutator( expander );
                         flat2->acceptMutator( expander );
@@ -621 +674 @@
         }
 
-        void Unify::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {
+        void Unify_old::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {
                 result = dynamic_cast< VarArgsType* >( type2 );
         }
 
-        void Unify::postvisit( __attribute__((unused)) ZeroType *zeroType ) {
+        void Unify_old::postvisit( __attribute__((unused)) ZeroType *zeroType ) {
                 result = dynamic_cast< ZeroType* >( type2 );
         }
 
-        void Unify::postvisit( __attribute__((unused)) OneType *oneType ) {
+        void Unify_old::postvisit( __attribute__((unused)) OneType *oneType ) {
                 result = dynamic_cast< OneType* >( type2 );
         }
@@ -647 +700 @@
         }
 
+        class Unify_new final : public ast::WithShortCircuiting {
+                const ast::Type * type2;
+                ast::TypeEnvironment & tenv;
+                ast::AssertionSet & need;
+                ast::AssertionSet & have;
+                const ast::OpenVarSet & open;
+                WidenMode widen;
+                const ast::SymbolTable & symtab;
+        public:
+                bool result;
+
+                Unify_new( 
+                        const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need, 
+                        ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen, 
+                        const ast::SymbolTable & symtab )
+                : type2(type2), tenv(env), need(need), have(have), open(open), widen(widen), 
+                  symtab(symtab), result(false) {}
+
+                void previsit( const ast::Node * ) { visit_children = false; }
+                
+                void postvisit( const ast::VoidType * ) {
+                        result = dynamic_cast< const ast::VoidType * >( type2 );
+                }
+
+                void postvisit( const ast::BasicType * basic ) {
+                        if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
+                                result = basic->kind == basic2->kind;
+                        }
+                }
+
+                void postvisit( const ast::PointerType * pointer ) {
+                        if ( auto pointer2 = dynamic_cast< const ast::PointerType * >( type2 ) ) {
+                                result = unifyExact( 
+                                        pointer->base, pointer2->base, tenv, need, have, open, 
+                                        noWiden(), symtab );
+                        }
+                }
+
+                void postvisit( const ast::ArrayType * array ) {
+                        auto array2 = dynamic_cast< const ast::ArrayType * >( type2 );
+                        if ( ! array2 ) return;
+
+                        // to unify, array types must both be VLA or both not VLA and both must have a 
+                        // dimension expression or not have a dimension
+                        if ( array->isVarLen != array2->isVarLen ) return;
+                        if ( ! array->isVarLen && ! array2->isVarLen 
+                                        && array->dimension && array2->dimension ) {
+                                auto ce1 = array->dimension.as< ast::ConstantExpr >();
+                                auto ce2 = array2->dimension.as< ast::ConstantExpr >();
+
+                                // see C11 Reference Manual 6.7.6.2.6
+                                // two array types with size specifiers that are integer constant expressions are 
+                                // compatible if both size specifiers have the same constant value
+                                if ( ce1 && ce2 && ce1->intValue() != ce2->intValue() ) return;
+                        }
+
+                        result = unifyExact( 
+                                array->base, array2->base, tenv, need, have, open, noWiden(), 
+                                symtab );
+                }
+
+                void postvisit( const ast::ReferenceType * ref ) {
+                        if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
+                                result = unifyExact( 
+                                        ref->base, ref2->base, tenv, need, have, open, noWiden(), 
+                                        symtab );
+                        }
+                }
+
+        private:
+                /// Replaces ttype variables with their bound types.
+                /// If this isn't done when satifying ttype assertions, then argument lists can have 
+                /// different size and structure when they should be compatible.
+                struct TtypeExpander_new : public ast::WithShortCircuiting {
+                        ast::TypeEnvironment & tenv;
+
+                        TtypeExpander_new( ast::TypeEnvironment & env ) : tenv( env ) {}
+
+                        const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
+                                if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
+                                        // expand ttype parameter into its actual type
+                                        if ( clz->data.kind == ast::TypeVar::Ttype && clz->bound ) {
+                                                return clz->bound;
+                                        }
+                                }
+                                return typeInst;
+                        }
+                };
+
+                /// returns flattened version of `src`
+                static std::vector< ast::ptr< ast::DeclWithType > > flattenList(
+                        const std::vector< ast::ptr< ast::DeclWithType > > & src, ast::TypeEnvironment & env
+                ) {
+                        std::vector< ast::ptr< ast::DeclWithType > > dst;
+                        dst.reserve( src.size() );
+                        for ( const ast::DeclWithType * d : src ) {
+                                ast::Pass<TtypeExpander_new> expander{ env };
+                                d = d->accept( expander );
+                                auto types = flatten( d->get_type() );
+                                for ( ast::ptr< ast::Type > & t : types ) {
+                                        // outermost const, volatile, _Atomic qualifiers in parameters should not play 
+                                        // a role in the unification of function types, since they do not determine 
+                                        // whether a function is callable.
+                                        // NOTE: **must** consider at least mutex qualifier, since functions can be 
+                                        // overloaded on outermost mutex and a mutex function has different 
+                                        // requirements than a non-mutex function
+                                        remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
+                                        dst.emplace_back( new ast::ObjectDecl{ d->location, "", t } );
+                                }
+                        }
+                        return dst;
+                }
+
+                /// Creates a tuple type based on a list of DeclWithType
+                template< typename Iter >
+                static ast::ptr< ast::Type > tupleFromDecls( Iter crnt, Iter end ) {
+                        std::vector< ast::ptr< ast::Type > > types;
+                        while ( crnt != end ) {
+                                // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure 
+                                // that this results in a flat tuple
+                                flatten( (*crnt)->get_type(), types );
+
+                                ++crnt;
+                        }
+
+                        return { new ast::TupleType{ std::move(types) } };
+                }
+
+                template< typename Iter >
+                static bool unifyDeclList( 
+                        Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env, 
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
+                        const ast::SymbolTable & symtab
+                ) {
+                        while ( crnt1 != end1 && crnt2 != end2 ) {
+                                const ast::Type * t1 = (*crnt1)->get_type();
+                                const ast::Type * t2 = (*crnt2)->get_type();
+                                bool isTuple1 = Tuples::isTtype( t1 );
+                                bool isTuple2 = Tuples::isTtype( t2 );
+
+                                // assumes here that ttype *must* be last parameter
+                                if ( isTuple1 && ! isTuple2 ) {
+                                        // combine remainder of list2, then unify
+                                        return unifyExact( 
+                                                t1, tupleFromDecls( crnt2, end2 ), env, need, have, open, 
+                                                noWiden(), symtab );
+                                } else if ( ! isTuple1 && isTuple2 ) {
+                                        // combine remainder of list1, then unify
+                                        return unifyExact( 
+                                                tupleFromDecls( crnt1, end1 ), t2, env, need, have, open, 
+                                                noWiden(), symtab );
+                                }
+
+                                if ( ! unifyExact( 
+                                        t1, t2, env, need, have, open, noWiden(), symtab ) 
+                                ) return false;
+
+                                ++crnt1; ++crnt2;
+                        }
+
+                        // May get to the end of one argument list before the other. This is only okay if the 
+                        // other is a ttype
+                        if ( crnt1 != end1 ) {
+                                // try unifying empty tuple with ttype
+                                const ast::Type * t1 = (*crnt1)->get_type();
+                                if ( ! Tuples::isTtype( t1 ) ) return false;
+                                return unifyExact( 
+                                        t1, tupleFromDecls( crnt2, end2 ), env, need, have, open, 
+                                        noWiden(), symtab );
+                        } else if ( crnt2 != end2 ) {
+                                // try unifying empty tuple with ttype
+                                const ast::Type * t2 = (*crnt2)->get_type();
+                                if ( ! Tuples::isTtype( t2 ) ) return false;
+                                return unifyExact( 
+                                        tupleFromDecls( crnt1, end1 ), t2, env, need, have, open, 
+                                        noWiden(), symtab );
+                        }
+
+                        return true;
+                }
+
+                static bool unifyDeclList( 
+                        const std::vector< ast::ptr< ast::DeclWithType > > & list1, 
+                        const std::vector< ast::ptr< ast::DeclWithType > > & list2, 
+                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                        const ast::OpenVarSet & open, const ast::SymbolTable & symtab
+                ) {
+                        return unifyDeclList( 
+                                list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open, 
+                                symtab );
+                }
+
+                static void markAssertionSet( ast::AssertionSet & assns, const ast::DeclWithType * assn ) {
+                        auto i = assns.find( assn );
+                        if ( i != assns.end() ) {
+                                i->second.isUsed = true;
+                        }
+                }
+
+                /// mark all assertions in `type` used in both `assn1` and `assn2`
+                static void markAssertions( 
+                        ast::AssertionSet & assn1, ast::AssertionSet & assn2, 
+                        const ast::ParameterizedType * type 
+                ) {
+                        for ( const auto & tyvar : type->forall ) {
+                                for ( const ast::DeclWithType * assert : tyvar->assertions ) {
+                                        markAssertionSet( assn1, assert );
+                                        markAssertionSet( assn2, assert );
+                                }
+                        }
+                }
+
+        public:
+                void postvisit( const ast::FunctionType * func ) {
+                        auto func2 = dynamic_cast< const ast::FunctionType * >( type2 );
+                        if ( ! func2 ) return;
+
+                        if ( func->isVarArgs != func2->isVarArgs ) return;
+                        
+                        // Flatten the parameter lists for both functions so that tuple structure does not 
+                        // affect unification. Does not actually mutate function parameters.
+                        auto params = flattenList( func->params, tenv );
+                        auto params2 = flattenList( func2->params, tenv );
+
+                        // sizes don't have to match if ttypes are involved; need to be more precise w.r.t. 
+                        // where the ttype is to prevent errors
+                        if ( 
+                                ( params.size() != params2.size() || func->returns.size() != func2->returns.size() )
+                                && ! func->isTtype()
+                                && ! func2->isTtype()
+                        ) return;
+
+                        if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
+                        if ( ! unifyDeclList( 
+                                func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
+                        
+                        markAssertions( have, need, func );
+                        markAssertions( have, need, func2 );
+
+                        result = true;
+                }
+        
+        private:
+                template< typename RefType >
+                const RefType * handleRefType( const RefType * inst, const ast::Type * other ) {
+                        // check that the other type is compatible and named the same
+                        auto otherInst = dynamic_cast< const RefType * >( other );
+                        result = otherInst && inst->name == otherInst->name;
+                        return otherInst;
+                }
+
+                /// Creates a tuple type based on a list of TypeExpr
+                template< typename Iter >
+                static const ast::Type * tupleFromExprs( 
+                        const ast::TypeExpr * param, Iter & crnt, Iter end, ast::CV::Qualifiers qs
+                ) {
+                        std::vector< ast::ptr< ast::Type > > types;
+                        do {
+                                types.emplace_back( param->type );
+
+                                ++crnt;
+                                if ( crnt == end ) break;
+                                param = strict_dynamic_cast< const ast::TypeExpr * >( crnt->get() );
+                        } while(true);
+
+                        return new ast::TupleType{ std::move(types), qs };
+                }
+
+                template< typename RefType >
+                void handleGenericRefType( const RefType * inst, const ast::Type * other ) {
+                        // check that other type is compatible and named the same
+                        const RefType * inst2 = handleRefType( inst, other );
+                        if ( ! inst2 ) return;
+                        
+                        // check that parameters of types unify, if any
+                        const std::vector< ast::ptr< ast::Expr > > & params = inst->params;
+                        const std::vector< ast::ptr< ast::Expr > > & params2 = inst2->params;
+
+                        auto it = params.begin();
+                        auto jt = params2.begin();
+                        for ( ; it != params.end() && jt != params2.end(); ++it, ++jt ) {
+                                auto param = strict_dynamic_cast< const ast::TypeExpr * >( it->get() );
+                                auto param2 = strict_dynamic_cast< const ast::TypeExpr * >( jt->get() );
+
+                                ast::ptr< ast::Type > pty = param->type;
+                                ast::ptr< ast::Type > pty2 = param2->type;
+
+                                bool isTuple = Tuples::isTtype( pty );
+                                bool isTuple2 = Tuples::isTtype( pty2 );
+
+                                if ( isTuple && isTuple2 ) {
+                                        ++it; ++jt;  // skip ttype parameters before break
+                                } else if ( isTuple ) {
+                                        // bundle remaining params into tuple
+                                        pty2 = tupleFromExprs( param2, jt, params2.end(), pty->qualifiers );
+                                        ++it;  // skip ttype parameter for break
+                                } else if ( isTuple2 ) {
+                                        // bundle remaining params into tuple
+                                        pty = tupleFromExprs( param, it, params.end(), pty2->qualifiers );
+                                        ++jt;  // skip ttype parameter for break
+                                }
+
+                                if ( ! unifyExact( 
+                                                pty, pty2, tenv, need, have, open, noWiden(), symtab ) ) {
+                                        result = false;
+                                        return;
+                                }
+
+                                // ttype parameter should be last
+                                if ( isTuple || isTuple2 ) break;
+                        }
+                        result = it == params.end() && jt == params2.end();
+                }
+
+        public:
+                void postvisit( const ast::StructInstType * aggrType ) {
+                        handleGenericRefType( aggrType, type2 );
+                }
+
+                void postvisit( const ast::UnionInstType * aggrType ) {
+                        handleGenericRefType( aggrType, type2 );
+                }
+
+                void postvisit( const ast::EnumInstType * aggrType ) {
+                        handleRefType( aggrType, type2 );
+                }
+
+                void postvisit( const ast::TraitInstType * aggrType ) {
+                        handleRefType( aggrType, type2 );
+                }
+
+                void postvisit( const ast::TypeInstType * typeInst ) {
+                        assert( open.find( typeInst->name ) == open.end() );
+                        handleRefType( typeInst, type2 );
+                }
+
+        private:
+                /// Creates a tuple type based on a list of Type
+                static ast::ptr< ast::Type > tupleFromTypes( 
+                        const std::vector< ast::ptr< ast::Type > > & tys
+                ) {
+                        std::vector< ast::ptr< ast::Type > > out;
+                        for ( const ast::Type * ty : tys ) {
+                                // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure 
+                                // that this results in a flat tuple
+                                flatten( ty, out );
+                        }
+
+                        return { new ast::TupleType{ std::move(out) } };
+                }
+
+                static bool unifyList( 
+                        const std::vector< ast::ptr< ast::Type > > & list1, 
+                        const std::vector< ast::ptr< ast::Type > > & list2, ast::TypeEnvironment & env, 
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
+                        const ast::SymbolTable & symtab
+                ) {
+                        auto crnt1 = list1.begin();
+                        auto crnt2 = list2.begin();
+                        while ( crnt1 != list1.end() && crnt2 != list2.end() ) {
+                                const ast::Type * t1 = *crnt1;
+                                const ast::Type * t2 = *crnt2;
+                                bool isTuple1 = Tuples::isTtype( t1 );
+                                bool isTuple2 = Tuples::isTtype( t2 );
+
+                                // assumes ttype must be last parameter
+                                if ( isTuple1 && ! isTuple2 ) {
+                                        // combine entirety of list2, then unify
+                                        return unifyExact( 
+                                                t1, tupleFromTypes( list2 ), env, need, have, open, 
+                                                noWiden(), symtab );
+                                } else if ( ! isTuple1 && isTuple2 ) {
+                                        // combine entirety of list1, then unify
+                                        return unifyExact(
+                                                tupleFromTypes( list1 ), t2, env, need, have, open, 
+                                                noWiden(), symtab );
+                                }
+
+                                if ( ! unifyExact( 
+                                        t1, t2, env, need, have, open, noWiden(), symtab ) 
+                                ) return false;
+
+                                ++crnt1; ++crnt2;
+                        }
+
+                        if ( crnt1 != list1.end() ) {
+                                // try unifying empty tuple type with ttype
+                                const ast::Type * t1 = *crnt1;
+                                if ( ! Tuples::isTtype( t1 ) ) return false;
+                                // xxx - this doesn't generate an empty tuple, contrary to comment; both ported 
+                                // from Rob's code
+                                return unifyExact( 
+                                                t1, tupleFromTypes( list2 ), env, need, have, open, 
+                                                noWiden(), symtab );
+                        } else if ( crnt2 != list2.end() ) {
+                                // try unifying empty tuple with ttype
+                                const ast::Type * t2 = *crnt2;
+                                if ( ! Tuples::isTtype( t2 ) ) return false;
+                                // xxx - this doesn't generate an empty tuple, contrary to comment; both ported 
+                                // from Rob's code
+                                return unifyExact(
+                                                tupleFromTypes( list1 ), t2, env, need, have, open, 
+                                                noWiden(), symtab );
+                        }
+
+                        return true;
+                }
+
+        public:
+                void postvisit( const ast::TupleType * tuple ) {
+                        auto tuple2 = dynamic_cast< const ast::TupleType * >( type2 );
+                        if ( ! tuple2 ) return;
+
+                        ast::Pass<TtypeExpander_new> expander{ tenv };
+                        const ast::Type * flat = tuple->accept( expander );
+                        const ast::Type * flat2 = tuple2->accept( expander );
+
+                        auto types = flatten( flat );
+                        auto types2 = flatten( flat2 );
+
+                        result = unifyList( types, types2, tenv, need, have, open, symtab );
+                }
+
+                void postvisit( const ast::VarArgsType * ) {
+                        result = dynamic_cast< const ast::VarArgsType * >( type2 );
+                }
+
+                void postvisit( const ast::ZeroType * ) {
+                        result = dynamic_cast< const ast::ZeroType * >( type2 );
+                }
+
+                void postvisit( const ast::OneType * ) {
+                        result = dynamic_cast< const ast::OneType * >( type2 );
+                }       
+
+          private:
+                template< typename RefType > void handleRefType( RefType *inst, Type *other );
+                template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
+        };
+
+        bool unify( 
+                        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                        ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common 
+        ) {
+                ast::OpenVarSet closed;
+                findOpenVars( type1, open, closed, need, have, FirstClosed );
+                findOpenVars( type2, open, closed, need, have, FirstOpen );
+                return unifyInexact( 
+                        type1, type2, env, need, have, open, WidenMode{ true, true }, symtab, common );
+        }
+
+        bool unifyExact( 
+                        const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
+                        WidenMode widen, const ast::SymbolTable & symtab
+        ) {
+                if ( type1->qualifiers != type2->qualifiers ) return false;
+
+                auto var1 = dynamic_cast< const ast::TypeInstType * >( type1 );
+                auto var2 = dynamic_cast< const ast::TypeInstType * >( type2 );
+                ast::OpenVarSet::const_iterator 
+                        entry1 = var1 ? open.find( var1->name ) : open.end(), 
+                        entry2 = var2 ? open.find( var2->name ) : open.end();
+                bool isopen1 = entry1 != open.end();
+                bool isopen2 = entry2 != open.end();
+
+                if ( isopen1 && isopen2 ) {
+                        if ( entry1->second.kind != entry2->second.kind ) return false;
+                        return env.bindVarToVar( 
+                                var1, var2, ast::TypeDecl::Data{ entry1->second, entry2->second }, need, have, 
+                                open, widen, symtab );
+                } else if ( isopen1 ) {
+                        return env.bindVar( var1, type2, entry1->second, need, have, open, widen, symtab );
+                } else if ( isopen2 ) {
+                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
+                } else {
+                        ast::Pass<Unify_new> comparator{ type2, env, need, have, open, widen, symtab };
+                        type1->accept( comparator );
+                        return comparator.pass.result;
+                }
+        }
+
+        bool unifyInexact( 
+                        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab, 
+                        ast::ptr<ast::Type> & common 
+        ) {
+                ast::CV::Qualifiers q1 = type1->qualifiers, q2 = type2->qualifiers;
+                
+                // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and 
+                // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
+                ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
+                reset_qualifiers( t1 );
+                reset_qualifiers( t2 );
+                
+                if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
+                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
+
+                        // if exact unification on unqualified types, try to merge qualifiers
+                        if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
+                                common = type1;
+                                reset_qualifiers( common, q1 | q2 );
+                                return true;
+                        } else {
+                                return false;
+                        }
+
+                } else if (( common = commonType( t1, t2, widen, symtab, env, open ) )) {
+                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
+
+                        // no exact unification, but common type
+                        reset_qualifiers( common, q1 | q2 );
+                        return true;
+                } else {
+                        return false;
+                }
+        }
+
         ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
                 if ( func->returns.empty() ) return new ast::VoidType{};

src/ResolvExpr/Unify.h

@@ -18 +18 @@
 #include <list>                   // for list
 
+#include "AST/Node.hpp"             // for ptr
+#include "AST/TypeEnvironment.hpp"  // for TypeEnvironment, AssertionSet, OpenVarSet
 #include "Common/utility.h"       // for deleteAll
 #include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Data
 #include "TypeEnvironment.h"      // for AssertionSet, OpenVarSet
-#include "WidenMode.h"            // for WidenMode
+#include "WidenMode.h"              // for WidenMode
 
 class Type;
 class TypeInstType;
 namespace SymTab {
-class Indexer;
-}  // namespace SymTab
+        class Indexer;
+}
+
+namespace ast {
+        class SymbolTable;
+        class Type;
+}
 
 namespace ResolvExpr {
@@ -33 +40 @@
         bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType );
         bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
-        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common );
+        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
 
         template< typename Iterator1, typename Iterator2 >
@@ -62 +69 @@
         }
 
+        bool unify( 
+                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common );
+
+        bool unifyExact( 
+                const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
+                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
+                WidenMode widen, const ast::SymbolTable & symtab );
+
+        bool unifyInexact( 
+                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab, 
+                ast::ptr<ast::Type> & common );
+
 } // namespace ResolvExpr
 

src/ResolvExpr/WidenMode.h

@@ -18 +18 @@
 namespace ResolvExpr {
         struct WidenMode {
-                WidenMode( bool widenFirst, bool widenSecond ): widenFirst( widenFirst ), widenSecond( widenSecond ) {}
-                WidenMode &operator|=( const WidenMode &other ) { widenFirst |= other.widenFirst; widenSecond |= other.widenSecond; return *this; }
-                WidenMode &operator&=( const WidenMode &other ) { widenFirst &= other.widenFirst; widenSecond &= other.widenSecond; return *this; }
-                WidenMode operator|( const WidenMode &other ) { WidenMode newWM( *this ); newWM |= other; return newWM; }
-                WidenMode operator&( const WidenMode &other ) { WidenMode newWM( *this ); newWM &= other; return newWM; }
-                operator bool() { return widenFirst && widenSecond; }
+                WidenMode( bool first, bool second ): first( first ), second( second ) {}
+                
+                WidenMode &operator|=( const WidenMode &other ) {
+                        first |= other.first; second |= other.second; return *this;
+                }
 
-                bool widenFirst : 1, widenSecond : 1;
+                WidenMode &operator&=( const WidenMode &other ) {
+                        first &= other.first; second &= other.second; return *this;
+                }
+
+                WidenMode operator|( const WidenMode &other ) {
+                        WidenMode newWM( *this ); newWM |= other; return newWM;
+                }
+
+                WidenMode operator&( const WidenMode &other ) {
+                        WidenMode newWM( *this ); newWM &= other; return newWM;
+                }
+                
+                operator bool() { return first && second; }
+
+                bool first : 1, second : 1;
         };
+
+        static inline WidenMode noWiden() { return { false, false }; }
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -18 +18 @@
 #include <vector>
 
+#include "Cost.h"
+#include "TypeEnvironment.h"
+#include "WidenMode.h"
+#include "AST/Fwd.hpp"
 #include "AST/Node.hpp"
+#include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "AST/TypeEnvironment.hpp"
 #include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
 #include "SymTab/Indexer.h"
-#include "Cost.h"
-#include "TypeEnvironment.h"
 
 namespace ResolvExpr {
@@ -85 +89 @@
 
         // in Unify.cc
-        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 );
@@ -99 +102 @@
         }
 
+        bool typesCompatible( 
+                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
+                const ast::TypeEnvironment & env = {} );
+        
+        bool typesCompatibleIgnoreQualifiers(
+                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
+                const ast::TypeEnvironment & env = {} );
+
         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
         Type * extractResultType( FunctionType * functionType );
@@ -106 +117 @@
         // in CommonType.cc
         Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
+        ast::ptr< ast::Type > commonType(
+                const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, WidenMode widen, 
+                const ast::SymbolTable & symtab, ast::TypeEnvironment & env, const ast::OpenVarSet & open );
 
         // in PolyCost.cc
@@ -115 +129 @@
         // in Occurs.cc
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
+        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
 
         template<typename Iter> 
@@ -127 +142 @@
         // in AlternativeFinder.cc
         void referenceToRvalueConversion( Expression *& expr, Cost & cost );
+        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost );
 
-        // flatten tuple type into list of types
+        /// flatten tuple type into list of types
         template< typename OutputIterator >
         void flatten( Type * type, OutputIterator out ) {
@@ -139 +155 @@
                 }
         }
+
+        /// flatten tuple type into existing list of types
+        static inline void flatten( 
+                const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out 
+        ) {
+                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {        
+                        for ( const ast::Type * t : tupleType->types ) {
+                                flatten( t, out );
+                        }
+                } else {
+                        out.emplace_back( type );
+                }
+        }
+
+        /// flatten tuple type into list of types
+        static inline std::vector< ast::ptr< ast::Type > > flatten( const ast::Type * type ) {
+                std::vector< ast::ptr< ast::Type > > out;
+                out.reserve( type->size() );
+                flatten( type, out );
+                return out;
+        }
+
+        // in TypeEnvironment.cc
+        bool isFtype( Type *type );
 } // namespace ResolvExpr
+
+namespace ast {
+        // in TypeEnvironment.cpp
+        bool isFtype( const ast::Type * type );
+} // namespace ast
 
 // Local Variables: //