Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/Unify.cc

    r3315e3d r00ac42e  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:27:10 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Sep  4 10:00:00 2019
    13 // Update Count     : 44
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Mar 16 16:22:54 2017
     13// Update Count     : 42
    1414//
    1515
     16#include <cassert>                // for assertf, assert
     17#include <iterator>               // for back_insert_iterator, back_inserter
     18#include <map>                    // for _Rb_tree_const_iterator, _Rb_tree_i...
     19#include <memory>                 // for unique_ptr
     20#include <set>                    // for set
     21#include <string>                 // for string, operator==, operator!=, bas...
     22#include <utility>                // for pair, move
     23
     24#include "Common/PassVisitor.h"   // for PassVisitor
     25#include "FindOpenVars.h"         // for findOpenVars
     26#include "Parser/LinkageSpec.h"   // for C
     27#include "SynTree/Constant.h"     // for Constant
     28#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Data, Declarati...
     29#include "SynTree/Expression.h"   // for TypeExpr, Expression, ConstantExpr
     30#include "SynTree/Mutator.h"      // for Mutator
     31#include "SynTree/Type.h"         // for Type, TypeInstType, FunctionType
     32#include "SynTree/Visitor.h"      // for Visitor
     33#include "Tuples/Tuples.h"        // for isTtype
     34#include "TypeEnvironment.h"      // for EqvClass, AssertionSet, OpenVarSet
    1635#include "Unify.h"
    17 
    18 #include <cassert>                  // for assertf, assert
    19 #include <iterator>                 // for back_insert_iterator, back_inserter
    20 #include <map>                      // for _Rb_tree_const_iterator, _Rb_tree_i...
    21 #include <memory>                   // for unique_ptr
    22 #include <set>                      // for set
    23 #include <string>                   // for string, operator==, operator!=, bas...
    24 #include <utility>                  // for pair, move
    25 #include <vector>
    26 
    27 #include "AST/Decl.hpp"
    28 #include "AST/Node.hpp"
    29 #include "AST/Pass.hpp"
    30 #include "AST/Type.hpp"
    31 #include "AST/TypeEnvironment.hpp"
    32 #include "Common/PassVisitor.h"     // for PassVisitor
    33 #include "FindOpenVars.h"           // for findOpenVars
    34 #include "Parser/LinkageSpec.h"     // for C
    35 #include "SynTree/Constant.h"       // for Constant
    36 #include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
    37 #include "SynTree/Expression.h"     // for TypeExpr, Expression, ConstantExpr
    38 #include "SynTree/Mutator.h"        // for Mutator
    39 #include "SynTree/Type.h"           // for Type, TypeInstType, FunctionType
    40 #include "SynTree/Visitor.h"        // for Visitor
    41 #include "Tuples/Tuples.h"          // for isTtype
    42 #include "TypeEnvironment.h"        // for EqvClass, AssertionSet, OpenVarSet
    43 #include "typeops.h"                // for flatten, occurs, commonType
    44 
    45 namespace ast {
    46         class SymbolTable;
    47 }
     36#include "typeops.h"              // for flatten, occurs, commonType
    4837
    4938namespace SymTab {
    … …  
    5544namespace ResolvExpr {
    5645
    57         struct Unify_old : public WithShortCircuiting {
    58                 Unify_old( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
     46        struct Unify : public WithShortCircuiting {
     47                Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
    5948
    6049                bool get_result() const { return result; }
    … …  
    8877                AssertionSet &haveAssertions;
    8978                const OpenVarSet &openVars;
    90                 WidenMode widen;
     79                WidenMode widenMode;
    9180                const SymTab::Indexer &indexer;
    9281        };
    … …  
    9483        /// Attempts an inexact unification of type1 and type2.
    9584        /// Returns false if no such unification; if the types can be unified, sets common (unless they unify exactly and have identical type qualifiers)
    96         bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
    97         bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
    98 
    99         bool unifyExact(
    100                 const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
    101                 ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
    102                 WidenMode widen, const ast::SymbolTable & symtab );
    103 
    104         bool typesCompatible( const Type * first, const Type * second, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
     85        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common );
     86        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
     87
     88        bool typesCompatible( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    10589                TypeEnvironment newEnv;
    10690                OpenVarSet openVars, closedVars; // added closedVars
    10791                AssertionSet needAssertions, haveAssertions;
    108                 Type * newFirst = first->clone(), * newSecond = second->clone();
     92                Type *newFirst = first->clone(), *newSecond = second->clone();
    10993                env.apply( newFirst );
    11094                env.apply( newSecond );
    … …  
    121105        }
    122106
    123         bool typesCompatible(
    124                         const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
    125                         const ast::TypeEnvironment & env ) {
    126                 ast::TypeEnvironment newEnv;
    127                 ast::OpenVarSet open, closed;
    128                 ast::AssertionSet need, have;
    129 
    130                 ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
    131                 env.apply( newFirst );
    132                 env.apply( newSecond );
    133 
    134                 findOpenVars( newFirst, open, closed, need, have, FirstClosed );
    135                 findOpenVars( newSecond, open, closed, need, have, FirstOpen );
    136 
    137                 return unifyExact(
    138                         newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
    139         }
    140 
    141         bool typesCompatibleIgnoreQualifiers( const Type * first, const Type * second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
     107        bool typesCompatibleIgnoreQualifiers( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    142108                TypeEnvironment newEnv;
    143109                OpenVarSet openVars;
    … …  
    163129        }
    164130
    165         bool typesCompatibleIgnoreQualifiers(
    166                         const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
    167                         const ast::TypeEnvironment & env ) {
    168                 ast::TypeEnvironment newEnv;
    169                 ast::OpenVarSet open;
    170                 ast::AssertionSet need, have;
    171 
    172                 ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
    173                 env.apply( newFirst );
    174                 env.apply( newSecond );
    175                 reset_qualifiers( newFirst );
    176                 reset_qualifiers( newSecond );
    177 
    178                 return unifyExact(
    179                         newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
     131        bool isFtype( Type *type ) {
     132                if ( dynamic_cast< FunctionType* >( type ) ) {
     133                        return true;
     134                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
     135                        return typeInst->get_isFtype();
     136                } // if
     137                return false;
     138        }
     139
     140        bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
     141                switch ( data.kind ) {
     142                  case TypeDecl::Dtype:
     143                        // to bind to an object type variable, the type must not be a function type.
     144                        // if the type variable is specified to be a complete type then the incoming
     145                        // type must also be complete
     146                        // xxx - should this also check that type is not a tuple type and that it's not a ttype?
     147                        return ! isFtype( type ) && (! data.isComplete || type->isComplete() );
     148                  case TypeDecl::Ftype:
     149                        return isFtype( type );
     150                  case TypeDecl::Ttype:
     151                        // ttype unifies with any tuple type
     152                        return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
     153                } // switch
     154                return false;
     155        }
     156
     157        bool bindVar( TypeInstType *typeInst, Type *other, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
     158                // remove references from other, so that type variables can only bind to value types
     159                other = other->stripReferences();
     160                OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
     161                assert( tyvar != openVars.end() );
     162                if ( ! tyVarCompatible( tyvar->second, other ) ) {
     163                        return false;
     164                } // if
     165                if ( occurs( other, typeInst->get_name(), env ) ) {
     166                        return false;
     167                } // if
     168                if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
     169                        if ( curClass->type ) {
     170                                Type *common = 0;
     171                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
     172                                std::unique_ptr< Type > newType( curClass->type->clone() );
     173                                newType->get_qualifiers() = typeInst->get_qualifiers();
     174                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
     175                                        if ( common ) {
     176                                                common->get_qualifiers() = Type::Qualifiers();
     177                                                env.add( EqvClass{ *curClass, common } );
     178                                        } // if
     179                                        return true;
     180                                } else {
     181                                        return false;
     182                                } // if
     183                        } else {
     184                                EqvClass newClass { *curClass, other };
     185                                newClass.type->get_qualifiers() = Type::Qualifiers();
     186                                newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
     187                                env.add( std::move(newClass) );
     188                        } // if
     189                } else {
     190                        EqvClass newClass;
     191                        newClass.vars.insert( typeInst->get_name() );
     192                        newClass.type = other->clone();
     193                        newClass.type->get_qualifiers() = Type::Qualifiers();
     194                        newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
     195                        newClass.data = data;
     196                        env.add( newClass );
     197                } // if
     198                return true;
     199        }
     200
     201        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
     202                bool result = true;
     203                const EqvClass *class1 = env.lookup( var1->get_name() );
     204                const EqvClass *class2 = env.lookup( var2->get_name() );
     205                bool widen1 = false, widen2 = false;
     206                Type *type1 = nullptr, *type2 = nullptr;
     207
     208                if ( class1 ) {
     209                        if ( class1->type ) {
     210                                if ( occurs( class1->type, var2->get_name(), env ) ) {
     211                                        return false;
     212                                } // if
     213                                type1 = class1->type->clone();
     214                        } // if
     215                        widen1 = widenMode.widenFirst && class1->allowWidening;
     216                } // if
     217                if ( class2 ) {
     218                        if ( class2->type ) {
     219                                if ( occurs( class2->type, var1->get_name(), env ) ) {
     220                                        return false;
     221                                } // if
     222                                type2 = class2->type->clone();
     223                        } // if
     224                        widen2 = widenMode.widenSecond && class2->allowWidening;
     225                } // if
     226
     227                if ( type1 && type2 ) {
     228//    std::cerr << "has type1 && type2" << std::endl;
     229                        WidenMode newWidenMode ( widen1, widen2 );
     230                        Type *common = 0;
     231                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
     232                                EqvClass newClass1 = *class1;
     233                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     234                                newClass1.allowWidening = widen1 && widen2;
     235                                if ( common ) {
     236                                        common->get_qualifiers() = Type::Qualifiers();
     237                                        delete newClass1.type;
     238                                        newClass1.type = common;
     239                                } // if
     240                                env.add( std::move(newClass1) );
     241                        } else {
     242                                result = false;
     243                        } // if
     244                } else if ( class1 && class2 ) {
     245                        if ( type1 ) {
     246                                EqvClass newClass1 = *class1;
     247                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     248                                newClass1.allowWidening = widen1;
     249                                env.add( std::move(newClass1) );
     250                        } else {
     251                                EqvClass newClass2 = *class2;
     252                                newClass2.vars.insert( class1->vars.begin(), class1->vars.end() );
     253                                newClass2.allowWidening = widen2;
     254                                env.add( std::move(newClass2) );
     255                        } // if
     256                } else if ( class1 ) {
     257                        EqvClass newClass1 = *class1;
     258                        newClass1.vars.insert( var2->get_name() );
     259                        newClass1.allowWidening = widen1;
     260                        env.add( std::move(newClass1) );
     261                } else if ( class2 ) {
     262                        EqvClass newClass2 = *class2;
     263                        newClass2.vars.insert( var1->get_name() );
     264                        newClass2.allowWidening = widen2;
     265                        env.add( std::move(newClass2) );
     266                } else {
     267                        EqvClass newClass;
     268                        newClass.vars.insert( var1->get_name() );
     269                        newClass.vars.insert( var2->get_name() );
     270                        newClass.allowWidening = widen1 && widen2;
     271                        newClass.data = data;
     272                        env.add( newClass );
     273                } // if
     274                delete type1;
     275                delete type2;
     276                return result;
    180277        }
    181278
    … …  
    202299        }
    203300
    204         bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
     301        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
    205302#ifdef DEBUG
    206303                TypeEnvironment debugEnv( env );
    … …  
    223320                bool isopen2 = var2 && ( entry2 != openVars.end() );
    224321
    225                 if ( isopen1 && isopen2 ) {
    226                         if ( entry1->second.kind != entry2->second.kind ) {
    227                                 result = false;
    228                         } else {
    229                                 result = env.bindVarToVar(
    230                                         var1, var2, TypeDecl::Data{ entry1->second, entry2->second }, needAssertions,
    231                                         haveAssertions, openVars, widen, indexer );
    232                         }
     322                if ( isopen1 && isopen2 && entry1->second == entry2->second ) {
     323                        result = bindVarToVar( var1, var2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
    233324                } else if ( isopen1 ) {
    234                         result = env.bindVar( var1, type2, entry1->second, needAssertions, haveAssertions, openVars, widen, indexer );
    235                 } else if ( isopen2 ) { // TODO: swap widen values in call, since type positions are flipped?
    236                         result = env.bindVar( var2, type1, entry2->second, needAssertions, haveAssertions, openVars, widen, indexer );
     325                        result = bindVar( var1, type2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
     326                } else if ( isopen2 ) { // TODO: swap widenMode values in call, since type positions are flipped?
     327                        result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
    237328                } else {
    238                         PassVisitor<Unify_old> comparator( type2, env, needAssertions, haveAssertions, openVars, widen, indexer );
     329                        PassVisitor<Unify> comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
    239330                        type1->accept( comparator );
    240331                        result = comparator.pass.get_result();
    … …  
    261352        }
    262353
    263         bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common ) {
     354        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common ) {
    264355                Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
    265356                type1->get_qualifiers() = Type::Qualifiers();
    … …  
    273364                std::cerr << std::endl;
    274365#endif
    275                 if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widen, indexer ) ) {
     366                if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ) ) {
    276367#ifdef DEBUG
    277368                        std::cerr << "unifyInexact: no exact unification found" << std::endl;
    278369#endif
    279                         if ( ( common = commonType( type1, type2, widen.first, widen.second, indexer, env, openVars ) ) ) {
    280                                 common->tq = tq1.unify( tq2 );
     370                        if ( ( common = commonType( type1, type2, widenMode.widenFirst, widenMode.widenSecond, indexer, env, openVars ) ) ) {
     371                                common->get_qualifiers() = tq1 | tq2;
    281372#ifdef DEBUG
    282373                                std::cerr << "unifyInexact: common type is ";
    … …  
    293384                } else {
    294385                        if ( tq1 != tq2 ) {
    295                                 if ( ( tq1 > tq2 || widen.first ) && ( tq2 > tq1 || widen.second ) ) {
     386                                if ( ( tq1 > tq2 || widenMode.widenFirst ) && ( tq2 > tq1 || widenMode.widenSecond ) ) {
    296387                                        common = type1->clone();
    297                                         common->tq = tq1.unify( tq2 );
     388                                        common->get_qualifiers() = tq1 | tq2;
    298389                                        result = true;
    299390                                } else {
    … …  
    302393                        } else {
    303394                                common = type1->clone();
    304                                 common->tq = tq1.unify( tq2 );
     395                                common->get_qualifiers() = tq1 | tq2;
    305396                                result = true;
    306397                        } // if
    … …  
    311402        }
    312403
    313         Unify_old::Unify_old( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer )
    314                 : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widen( widen ), indexer( indexer ) {
    315         }
    316 
    317         void Unify_old::postvisit( __attribute__((unused)) VoidType *voidType) {
     404        Unify::Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer )
     405                : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widenMode( widenMode ), indexer( indexer ) {
     406        }
     407
     408        void Unify::postvisit( __attribute__((unused)) VoidType *voidType) {
    318409                result = dynamic_cast< VoidType* >( type2 );
    319410        }
    320411
    321         void Unify_old::postvisit(BasicType *basicType) {
     412        void Unify::postvisit(BasicType *basicType) {
    322413                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
    323414                        result = basicType->get_kind() == otherBasic->get_kind();
    … …  
    347438        }
    348439
    349         void Unify_old::postvisit(PointerType *pointerType) {
     440        void Unify::postvisit(PointerType *pointerType) {
    350441                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
    351442                        result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    … …  
    355446        }
    356447
    357         void Unify_old::postvisit(ReferenceType *refType) {
     448        void Unify::postvisit(ReferenceType *refType) {
    358449                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
    359450                        result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    … …  
    363454        }
    364455
    365         void Unify_old::postvisit(ArrayType *arrayType) {
     456        void Unify::postvisit(ArrayType *arrayType) {
    366457                ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
    367458                // to unify, array types must both be VLA or both not VLA
    … …  
    443534        /// If this isn't done then argument lists can have wildly different
    444535        /// size and structure, when they should be compatible.
    445         struct TtypeExpander_old : public WithShortCircuiting {
     536        struct TtypeExpander : public WithShortCircuiting {
    446537                TypeEnvironment & tenv;
    447                 TtypeExpander_old( TypeEnvironment & tenv ) : tenv( tenv ) {}
     538                TtypeExpander( TypeEnvironment & tenv ) : tenv( tenv ) {}
    448539                void premutate( TypeInstType * ) { visit_children = false; }
    449540                Type * postmutate( TypeInstType * typeInst ) {
    … …  
    464555                dst.clear();
    465556                for ( DeclarationWithType * dcl : src ) {
    466                         PassVisitor<TtypeExpander_old> expander( env );
     557                        PassVisitor<TtypeExpander> expander( env );
    467558                        dcl->acceptMutator( expander );
    468559                        std::list< Type * > types;
    … …  
    479570        }
    480571
    481         void Unify_old::postvisit(FunctionType *functionType) {
     572        void Unify::postvisit(FunctionType *functionType) {
    482573                FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
    483574                if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
    … …  
    490581
    491582                        // sizes don't have to match if ttypes are involved; need to be more precise wrt where the ttype is to prevent errors
    492                         if (
    493                                         (flatFunc->parameters.size() == flatOther->parameters.size() &&
    494                                                 flatFunc->returnVals.size() == flatOther->returnVals.size())
    495                                         || flatFunc->isTtype()
    496                                         || flatOther->isTtype()
    497                         ) {
     583                        if ( (flatFunc->parameters.size() == flatOther->parameters.size() && flatFunc->returnVals.size() == flatOther->returnVals.size()) || flatFunc->isTtype() || flatOther->isTtype() ) {
    498584                                if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
    499585                                        if ( unifyDeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
    … …  
    511597
    512598        template< typename RefType >
    513         void Unify_old::handleRefType( RefType *inst, Type *other ) {
     599        void Unify::handleRefType( RefType *inst, Type *other ) {
    514600                // check that other type is compatible and named the same
    515601                RefType *otherStruct = dynamic_cast< RefType* >( other );
    … …  
    518604
    519605        template< typename RefType >
    520         void Unify_old::handleGenericRefType( RefType *inst, Type *other ) {
     606        void Unify::handleGenericRefType( RefType *inst, Type *other ) {
    521607                // Check that other type is compatible and named the same
    522608                handleRefType( inst, other );
    … …  
    586672        }
    587673
    588         void Unify_old::postvisit(StructInstType *structInst) {
     674        void Unify::postvisit(StructInstType *structInst) {
    589675                handleGenericRefType( structInst, type2 );
    590676        }
    591677
    592         void Unify_old::postvisit(UnionInstType *unionInst) {
     678        void Unify::postvisit(UnionInstType *unionInst) {
    593679                handleGenericRefType( unionInst, type2 );
    594680        }
    595681
    596         void Unify_old::postvisit(EnumInstType *enumInst) {
     682        void Unify::postvisit(EnumInstType *enumInst) {
    597683                handleRefType( enumInst, type2 );
    598684        }
    599685
    600         void Unify_old::postvisit(TraitInstType *contextInst) {
     686        void Unify::postvisit(TraitInstType *contextInst) {
    601687                handleRefType( contextInst, type2 );
    602688        }
    603689
    604         void Unify_old::postvisit(TypeInstType *typeInst) {
     690        void Unify::postvisit(TypeInstType *typeInst) {
    605691                assert( openVars.find( typeInst->get_name() ) == openVars.end() );
    606692                TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 );
    … …  
    657743        }
    658744
    659         void Unify_old::postvisit(TupleType *tupleType) {
     745        void Unify::postvisit(TupleType *tupleType) {
    660746                if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
    661747                        std::unique_ptr<TupleType> flat1( tupleType->clone() );
    … …  
    663749                        std::list<Type *> types1, types2;
    664750
    665                         PassVisitor<TtypeExpander_old> expander( env );
     751                        PassVisitor<TtypeExpander> expander( env );
    666752                        flat1->acceptMutator( expander );
    667753                        flat2->acceptMutator( expander );
    … …  
    674760        }
    675761
    676         void Unify_old::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {
     762        void Unify::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {
    677763                result = dynamic_cast< VarArgsType* >( type2 );
    678764        }
    679765
    680         void Unify_old::postvisit( __attribute__((unused)) ZeroType *zeroType ) {
     766        void Unify::postvisit( __attribute__((unused)) ZeroType *zeroType ) {
    681767                result = dynamic_cast< ZeroType* >( type2 );
    682768        }
    683769
    684         void Unify_old::postvisit( __attribute__((unused)) OneType *oneType ) {
     770        void Unify::postvisit( __attribute__((unused)) OneType *oneType ) {
    685771                result = dynamic_cast< OneType* >( type2 );
    686772        }
    687773
     774        // xxx - compute once and store in the FunctionType?
    688775        Type * extractResultType( FunctionType * function ) {
    689776                if ( function->get_returnVals().size() == 0 ) {
    … …  
    699786                }
    700787        }
    701 
    702         class Unify_new final : public ast::WithShortCircuiting {
    703                 const ast::Type * type2;
    704                 ast::TypeEnvironment & tenv;
    705                 ast::AssertionSet & need;
    706                 ast::AssertionSet & have;
    707                 const ast::OpenVarSet & open;
    708                 WidenMode widen;
    709                 const ast::SymbolTable & symtab;
    710         public:
    711                 bool result;
    712 
    713                 Unify_new(
    714                         const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need,
    715                         ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen,
    716                         const ast::SymbolTable & symtab )
    717                 : type2(type2), tenv(env), need(need), have(have), open(open), widen(widen),
    718                   symtab(symtab), result(false) {}
    719 
    720                 void previsit( const ast::Node * ) { visit_children = false; }
    721 
    722                 void postvisit( const ast::VoidType * ) {
    723                         result = dynamic_cast< const ast::VoidType * >( type2 );
    724                 }
    725 
    726                 void postvisit( const ast::BasicType * basic ) {
    727                         if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
    728                                 result = basic->kind == basic2->kind;
    729                         }
    730                 }
    731 
    732                 void postvisit( const ast::PointerType * pointer ) {
    733                         if ( auto pointer2 = dynamic_cast< const ast::PointerType * >( type2 ) ) {
    734                                 result = unifyExact(
    735                                         pointer->base, pointer2->base, tenv, need, have, open,
    736                                         noWiden(), symtab );
    737                         }
    738                 }
    739 
    740                 void postvisit( const ast::ArrayType * array ) {
    741                         auto array2 = dynamic_cast< const ast::ArrayType * >( type2 );
    742                         if ( ! array2 ) return;
    743 
    744                         // to unify, array types must both be VLA or both not VLA and both must have a
    745                         // dimension expression or not have a dimension
    746                         if ( array->isVarLen != array2->isVarLen ) return;
    747                         if ( ! array->isVarLen && ! array2->isVarLen
    748                                         && array->dimension && array2->dimension ) {
    749                                 auto ce1 = array->dimension.as< ast::ConstantExpr >();
    750                                 auto ce2 = array2->dimension.as< ast::ConstantExpr >();
    751 
    752                                 // see C11 Reference Manual 6.7.6.2.6
    753                                 // two array types with size specifiers that are integer constant expressions are
    754                                 // compatible if both size specifiers have the same constant value
    755                                 if ( ce1 && ce2 && ce1->intValue() != ce2->intValue() ) return;
    756                         }
    757 
    758                         result = unifyExact(
    759                                 array->base, array2->base, tenv, need, have, open, noWiden(),
    760                                 symtab );
    761                 }
    762 
    763                 void postvisit( const ast::ReferenceType * ref ) {
    764                         if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
    765                                 result = unifyExact(
    766                                         ref->base, ref2->base, tenv, need, have, open, noWiden(),
    767                                         symtab );
    768                         }
    769                 }
    770 
    771         private:
    772                 /// Replaces ttype variables with their bound types.
    773                 /// If this isn't done when satifying ttype assertions, then argument lists can have
    774                 /// different size and structure when they should be compatible.
    775                 struct TtypeExpander_new : public ast::WithShortCircuiting {
    776                         ast::TypeEnvironment & tenv;
    777 
    778                         TtypeExpander_new( ast::TypeEnvironment & env ) : tenv( env ) {}
    779 
    780                         const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
    781                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
    782                                         // expand ttype parameter into its actual type
    783                                         if ( clz->data.kind == ast::TypeVar::Ttype && clz->bound ) {
    784                                                 return clz->bound;
    785                                         }
    786                                 }
    787                                 return typeInst;
    788                         }
    789                 };
    790 
    791                 /// returns flattened version of `src`
    792                 static std::vector< ast::ptr< ast::DeclWithType > > flattenList(
    793                         const std::vector< ast::ptr< ast::DeclWithType > > & src, ast::TypeEnvironment & env
    794                 ) {
    795                         std::vector< ast::ptr< ast::DeclWithType > > dst;
    796                         dst.reserve( src.size() );
    797                         for ( const ast::DeclWithType * d : src ) {
    798                                 ast::Pass<TtypeExpander_new> expander{ env };
    799                                 d = d->accept( expander );
    800                                 auto types = flatten( d->get_type() );
    801                                 for ( ast::ptr< ast::Type > & t : types ) {
    802                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
    803                                         // a role in the unification of function types, since they do not determine
    804                                         // whether a function is callable.
    805                                         // NOTE: **must** consider at least mutex qualifier, since functions can be
    806                                         // overloaded on outermost mutex and a mutex function has different
    807                                         // requirements than a non-mutex function
    808                                         remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
    809                                         dst.emplace_back( new ast::ObjectDecl{ d->location, "", t } );
    810                                 }
    811                         }
    812                         return dst;
    813                 }
    814 
    815                 /// Creates a tuple type based on a list of DeclWithType
    816                 template< typename Iter >
    817                 static ast::ptr< ast::Type > tupleFromDecls( Iter crnt, Iter end ) {
    818                         std::vector< ast::ptr< ast::Type > > types;
    819                         while ( crnt != end ) {
    820                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
    821                                 // that this results in a flat tuple
    822                                 flatten( (*crnt)->get_type(), types );
    823 
    824                                 ++crnt;
    825                         }
    826 
    827                         return { new ast::TupleType{ std::move(types) } };
    828                 }
    829 
    830                 template< typename Iter >
    831                 static bool unifyDeclList(
    832                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
    833                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
    834                         const ast::SymbolTable & symtab
    835                 ) {
    836                         while ( crnt1 != end1 && crnt2 != end2 ) {
    837                                 const ast::Type * t1 = (*crnt1)->get_type();
    838                                 const ast::Type * t2 = (*crnt2)->get_type();
    839                                 bool isTuple1 = Tuples::isTtype( t1 );
    840                                 bool isTuple2 = Tuples::isTtype( t2 );
    841 
    842                                 // assumes here that ttype *must* be last parameter
    843                                 if ( isTuple1 && ! isTuple2 ) {
    844                                         // combine remainder of list2, then unify
    845                                         return unifyExact(
    846                                                 t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
    847                                                 noWiden(), symtab );
    848                                 } else if ( ! isTuple1 && isTuple2 ) {
    849                                         // combine remainder of list1, then unify
    850                                         return unifyExact(
    851                                                 tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
    852                                                 noWiden(), symtab );
    853                                 }
    854 
    855                                 if ( ! unifyExact(
    856                                         t1, t2, env, need, have, open, noWiden(), symtab )
    857                                 ) return false;
    858 
    859                                 ++crnt1; ++crnt2;
    860                         }
    861 
    862                         // May get to the end of one argument list before the other. This is only okay if the
    863                         // other is a ttype
    864                         if ( crnt1 != end1 ) {
    865                                 // try unifying empty tuple with ttype
    866                                 const ast::Type * t1 = (*crnt1)->get_type();
    867                                 if ( ! Tuples::isTtype( t1 ) ) return false;
    868                                 return unifyExact(
    869                                         t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
    870                                         noWiden(), symtab );
    871                         } else if ( crnt2 != end2 ) {
    872                                 // try unifying empty tuple with ttype
    873                                 const ast::Type * t2 = (*crnt2)->get_type();
    874                                 if ( ! Tuples::isTtype( t2 ) ) return false;
    875                                 return unifyExact(
    876                                         tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
    877                                         noWiden(), symtab );
    878                         }
    879 
    880                         return true;
    881                 }
    882 
    883                 static bool unifyDeclList(
    884                         const std::vector< ast::ptr< ast::DeclWithType > > & list1,
    885                         const std::vector< ast::ptr< ast::DeclWithType > > & list2,
    886                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
    887                         const ast::OpenVarSet & open, const ast::SymbolTable & symtab
    888                 ) {
    889                         return unifyDeclList(
    890                                 list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
    891                                 symtab );
    892                 }
    893 
    894                 static void markAssertionSet( ast::AssertionSet & assns, const ast::DeclWithType * assn ) {
    895                         auto i = assns.find( assn );
    896                         if ( i != assns.end() ) {
    897                                 i->second.isUsed = true;
    898                         }
    899                 }
    900 
    901                 /// mark all assertions in `type` used in both `assn1` and `assn2`
    902                 static void markAssertions(
    903                         ast::AssertionSet & assn1, ast::AssertionSet & assn2,
    904                         const ast::ParameterizedType * type
    905                 ) {
    906                         for ( const auto & tyvar : type->forall ) {
    907                                 for ( const ast::DeclWithType * assert : tyvar->assertions ) {
    908                                         markAssertionSet( assn1, assert );
    909                                         markAssertionSet( assn2, assert );
    910                                 }
    911                         }
    912                 }
    913 
    914         public:
    915                 void postvisit( const ast::FunctionType * func ) {
    916                         auto func2 = dynamic_cast< const ast::FunctionType * >( type2 );
    917                         if ( ! func2 ) return;
    918 
    919                         if ( func->isVarArgs != func2->isVarArgs ) return;
    920 
    921                         // Flatten the parameter lists for both functions so that tuple structure does not
    922                         // affect unification. Does not actually mutate function parameters.
    923                         auto params = flattenList( func->params, tenv );
    924                         auto params2 = flattenList( func2->params, tenv );
    925 
    926                         // sizes don't have to match if ttypes are involved; need to be more precise w.r.t.
    927                         // where the ttype is to prevent errors
    928                         if (
    929                                 ( params.size() != params2.size() || func->returns.size() != func2->returns.size() )
    930                                 && ! func->isTtype()
    931                                 && ! func2->isTtype()
    932                         ) return;
    933 
    934                         if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
    935                         if ( ! unifyDeclList(
    936                                 func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
    937 
    938                         markAssertions( have, need, func );
    939                         markAssertions( have, need, func2 );
    940 
    941                         result = true;
    942                 }
    943 
    944         private:
    945                 template< typename RefType >
    946                 const RefType * handleRefType( const RefType * inst, const ast::Type * other ) {
    947                         // check that the other type is compatible and named the same
    948                         auto otherInst = dynamic_cast< const RefType * >( other );
    949                         result = otherInst && inst->name == otherInst->name;
    950                         return otherInst;
    951                 }
    952 
    953                 /// Creates a tuple type based on a list of TypeExpr
    954                 template< typename Iter >
    955                 static const ast::Type * tupleFromExprs(
    956                         const ast::TypeExpr * param, Iter & crnt, Iter end, ast::CV::Qualifiers qs
    957                 ) {
    958                         std::vector< ast::ptr< ast::Type > > types;
    959                         do {
    960                                 types.emplace_back( param->type );
    961 
    962                                 ++crnt;
    963                                 if ( crnt == end ) break;
    964                                 param = strict_dynamic_cast< const ast::TypeExpr * >( crnt->get() );
    965                         } while(true);
    966 
    967                         return new ast::TupleType{ std::move(types), qs };
    968                 }
    969 
    970                 template< typename RefType >
    971                 void handleGenericRefType( const RefType * inst, const ast::Type * other ) {
    972                         // check that other type is compatible and named the same
    973                         const RefType * inst2 = handleRefType( inst, other );
    974                         if ( ! inst2 ) return;
    975 
    976                         // check that parameters of types unify, if any
    977                         const std::vector< ast::ptr< ast::Expr > > & params = inst->params;
    978                         const std::vector< ast::ptr< ast::Expr > > & params2 = inst2->params;
    979 
    980                         auto it = params.begin();
    981                         auto jt = params2.begin();
    982                         for ( ; it != params.end() && jt != params2.end(); ++it, ++jt ) {
    983                                 auto param = strict_dynamic_cast< const ast::TypeExpr * >( it->get() );
    984                                 auto param2 = strict_dynamic_cast< const ast::TypeExpr * >( jt->get() );
    985 
    986                                 ast::ptr< ast::Type > pty = param->type;
    987                                 ast::ptr< ast::Type > pty2 = param2->type;
    988 
    989                                 bool isTuple = Tuples::isTtype( pty );
    990                                 bool isTuple2 = Tuples::isTtype( pty2 );
    991 
    992                                 if ( isTuple && isTuple2 ) {
    993                                         ++it; ++jt;  // skip ttype parameters before break
    994                                 } else if ( isTuple ) {
    995                                         // bundle remaining params into tuple
    996                                         pty2 = tupleFromExprs( param2, jt, params2.end(), pty->qualifiers );
    997                                         ++it;  // skip ttype parameter for break
    998                                 } else if ( isTuple2 ) {
    999                                         // bundle remaining params into tuple
    1000                                         pty = tupleFromExprs( param, it, params.end(), pty2->qualifiers );
    1001                                         ++jt;  // skip ttype parameter for break
    1002                                 }
    1003 
    1004                                 if ( ! unifyExact(
    1005                                                 pty, pty2, tenv, need, have, open, noWiden(), symtab ) ) {
    1006                                         result = false;
    1007                                         return;
    1008                                 }
    1009 
    1010                                 // ttype parameter should be last
    1011                                 if ( isTuple || isTuple2 ) break;
    1012                         }
    1013                         result = it == params.end() && jt == params2.end();
    1014                 }
    1015 
    1016         public:
    1017                 void postvisit( const ast::StructInstType * aggrType ) {
    1018                         handleGenericRefType( aggrType, type2 );
    1019                 }
    1020 
    1021                 void postvisit( const ast::UnionInstType * aggrType ) {
    1022                         handleGenericRefType( aggrType, type2 );
    1023                 }
    1024 
    1025                 void postvisit( const ast::EnumInstType * aggrType ) {
    1026                         handleRefType( aggrType, type2 );
    1027                 }
    1028 
    1029                 void postvisit( const ast::TraitInstType * aggrType ) {
    1030                         handleRefType( aggrType, type2 );
    1031                 }
    1032 
    1033                 void postvisit( const ast::TypeInstType * typeInst ) {
    1034                         assert( open.find( typeInst->name ) == open.end() );
    1035                         handleRefType( typeInst, type2 );
    1036                 }
    1037 
    1038         private:
    1039                 /// Creates a tuple type based on a list of Type
    1040                 static ast::ptr< ast::Type > tupleFromTypes(
    1041                         const std::vector< ast::ptr< ast::Type > > & tys
    1042                 ) {
    1043                         std::vector< ast::ptr< ast::Type > > out;
    1044                         for ( const ast::Type * ty : tys ) {
    1045                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
    1046                                 // that this results in a flat tuple
    1047                                 flatten( ty, out );
    1048                         }
    1049 
    1050                         return { new ast::TupleType{ std::move(out) } };
    1051                 }
    1052 
    1053                 static bool unifyList(
    1054                         const std::vector< ast::ptr< ast::Type > > & list1,
    1055                         const std::vector< ast::ptr< ast::Type > > & list2, ast::TypeEnvironment & env,
    1056                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
    1057                         const ast::SymbolTable & symtab
    1058                 ) {
    1059                         auto crnt1 = list1.begin();
    1060                         auto crnt2 = list2.begin();
    1061                         while ( crnt1 != list1.end() && crnt2 != list2.end() ) {
    1062                                 const ast::Type * t1 = *crnt1;
    1063                                 const ast::Type * t2 = *crnt2;
    1064                                 bool isTuple1 = Tuples::isTtype( t1 );
    1065                                 bool isTuple2 = Tuples::isTtype( t2 );
    1066 
    1067                                 // assumes ttype must be last parameter
    1068                                 if ( isTuple1 && ! isTuple2 ) {
    1069                                         // combine entirety of list2, then unify
    1070                                         return unifyExact(
    1071                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
    1072                                                 noWiden(), symtab );
    1073                                 } else if ( ! isTuple1 && isTuple2 ) {
    1074                                         // combine entirety of list1, then unify
    1075                                         return unifyExact(
    1076                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
    1077                                                 noWiden(), symtab );
    1078                                 }
    1079 
    1080                                 if ( ! unifyExact(
    1081                                         t1, t2, env, need, have, open, noWiden(), symtab )
    1082                                 ) return false;
    1083 
    1084                                 ++crnt1; ++crnt2;
    1085                         }
    1086 
    1087                         if ( crnt1 != list1.end() ) {
    1088                                 // try unifying empty tuple type with ttype
    1089                                 const ast::Type * t1 = *crnt1;
    1090                                 if ( ! Tuples::isTtype( t1 ) ) return false;
    1091                                 // xxx - this doesn't generate an empty tuple, contrary to comment; both ported
    1092                                 // from Rob's code
    1093                                 return unifyExact(
    1094                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
    1095                                                 noWiden(), symtab );
    1096                         } else if ( crnt2 != list2.end() ) {
    1097                                 // try unifying empty tuple with ttype
    1098                                 const ast::Type * t2 = *crnt2;
    1099                                 if ( ! Tuples::isTtype( t2 ) ) return false;
    1100                                 // xxx - this doesn't generate an empty tuple, contrary to comment; both ported
    1101                                 // from Rob's code
    1102                                 return unifyExact(
    1103                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
    1104                                                 noWiden(), symtab );
    1105                         }
    1106 
    1107                         return true;
    1108                 }
    1109 
    1110         public:
    1111                 void postvisit( const ast::TupleType * tuple ) {
    1112                         auto tuple2 = dynamic_cast< const ast::TupleType * >( type2 );
    1113                         if ( ! tuple2 ) return;
    1114 
    1115                         ast::Pass<TtypeExpander_new> expander{ tenv };
    1116                         const ast::Type * flat = tuple->accept( expander );
    1117                         const ast::Type * flat2 = tuple2->accept( expander );
    1118 
    1119                         auto types = flatten( flat );
    1120                         auto types2 = flatten( flat2 );
    1121 
    1122                         result = unifyList( types, types2, tenv, need, have, open, symtab );
    1123                 }
    1124 
    1125                 void postvisit( const ast::VarArgsType * ) {
    1126                         result = dynamic_cast< const ast::VarArgsType * >( type2 );
    1127                 }
    1128 
    1129                 void postvisit( const ast::ZeroType * ) {
    1130                         result = dynamic_cast< const ast::ZeroType * >( type2 );
    1131                 }
    1132 
    1133                 void postvisit( const ast::OneType * ) {
    1134                         result = dynamic_cast< const ast::OneType * >( type2 );
    1135                 }
    1136 
    1137           private:
    1138                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
    1139                 template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
    1140         };
    1141 
    1142         bool unify(
    1143                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
    1144                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
    1145                         ast::OpenVarSet & open, const ast::SymbolTable & symtab
    1146         ) {
    1147                 ast::ptr<ast::Type> common;
    1148                 return unify( type1, type2, env, need, have, open, symtab, common );
    1149         }
    1150 
    1151         bool unify(
    1152                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
    1153                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
    1154                         ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common
    1155         ) {
    1156                 ast::OpenVarSet closed;
    1157                 findOpenVars( type1, open, closed, need, have, FirstClosed );
    1158                 findOpenVars( type2, open, closed, need, have, FirstOpen );
    1159                 return unifyInexact(
    1160                         type1, type2, env, need, have, open, WidenMode{ true, true }, symtab, common );
    1161         }
    1162 
    1163         bool unifyExact(
    1164                         const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
    1165                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
    1166                         WidenMode widen, const ast::SymbolTable & symtab
    1167         ) {
    1168                 if ( type1->qualifiers != type2->qualifiers ) return false;
    1169 
    1170                 auto var1 = dynamic_cast< const ast::TypeInstType * >( type1 );
    1171                 auto var2 = dynamic_cast< const ast::TypeInstType * >( type2 );
    1172                 ast::OpenVarSet::const_iterator
    1173                         entry1 = var1 ? open.find( var1->name ) : open.end(),
    1174                         entry2 = var2 ? open.find( var2->name ) : open.end();
    1175                 bool isopen1 = entry1 != open.end();
    1176                 bool isopen2 = entry2 != open.end();
    1177 
    1178                 if ( isopen1 && isopen2 ) {
    1179                         if ( entry1->second.kind != entry2->second.kind ) return false;
    1180                         return env.bindVarToVar(
    1181                                 var1, var2, ast::TypeDecl::Data{ entry1->second, entry2->second }, need, have,
    1182                                 open, widen, symtab );
    1183                 } else if ( isopen1 ) {
    1184                         return env.bindVar( var1, type2, entry1->second, need, have, open, widen, symtab );
    1185                 } else if ( isopen2 ) {
    1186                         return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
    1187                 } else {
    1188                         ast::Pass<Unify_new> comparator{ type2, env, need, have, open, widen, symtab };
    1189                         type1->accept( comparator );
    1190                         return comparator.pass.result;
    1191                 }
    1192         }
    1193 
    1194         bool unifyInexact(
    1195                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
    1196                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
    1197                         const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab,
    1198                         ast::ptr<ast::Type> & common
    1199         ) {
    1200                 ast::CV::Qualifiers q1 = type1->qualifiers, q2 = type2->qualifiers;
    1201 
    1202                 // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and
    1203                 // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
    1204                 ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
    1205                 reset_qualifiers( t1 );
    1206                 reset_qualifiers( t2 );
    1207 
    1208                 if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
    1209                         t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
    1210 
    1211                         // if exact unification on unqualified types, try to merge qualifiers
    1212                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
    1213                                 common = type1;
    1214                                 reset_qualifiers( common, q1 | q2 );
    1215                                 return true;
    1216                         } else {
    1217                                 return false;
    1218                         }
    1219 
    1220                 } else if (( common = commonType( t1, t2, widen, symtab, env, open ) )) {
    1221                         t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
    1222 
    1223                         // no exact unification, but common type
    1224                         reset_qualifiers( common, q1 | q2 );
    1225                         return true;
    1226                 } else {
    1227                         return false;
    1228                 }
    1229         }
    1230 
    1231         ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
    1232                 if ( func->returns.empty() ) return new ast::VoidType{};
    1233                 if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
    1234 
    1235                 std::vector<ast::ptr<ast::Type>> tys;
    1236                 for ( const ast::DeclWithType * decl : func->returns ) {
    1237                         tys.emplace_back( decl->get_type() );
    1238                 }
    1239                 return new ast::TupleType{ std::move(tys) };
    1240         }
    1241788} // namespace ResolvExpr
    1242789
Note: See TracChangeset for help on using the changeset viewer.