Changeset 28f3a19 for src/ResolvExpr/Unify.cc

Timestamp:

Jun 27, 2018, 3:28:41 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

b21c77a

Parents:

0182bfa (diff), 63238a4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into with_gc

File:

• src/ResolvExpr/Unify.cc (modified) (3 diffs)

src/ResolvExpr/Unify.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:27:10 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 16:22:54 2017
-// Update Count     : 42
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Mon Jun 18 11:58:00 2018
+// Update Count     : 43
 //
 
@@ -122 +122 @@
         }
 
-        bool isFtype( Type *type ) {
-                if ( dynamic_cast< FunctionType* >( type ) ) {
-                        return true;
-                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
-                        return typeInst->get_isFtype();
-                } // if
-                return false;
-        }
-
-        bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
-                switch ( data.kind ) {
-                  case TypeDecl::Dtype:
-                        // to bind to an object type variable, the type must not be a function type.
-                        // if the type variable is specified to be a complete type then the incoming
-                        // type must also be complete
-                        // xxx - should this also check that type is not a tuple type and that it's not a ttype?
-                        return ! isFtype( type ) && (! data.isComplete || type->isComplete() );
-                  case TypeDecl::Ftype:
-                        return isFtype( type );
-                  case TypeDecl::Ttype:
-                        // ttype unifies with any tuple type
-                        return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
-                } // switch
-                return false;
-        }
-
-        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 ) {
-                // remove references from other, so that type variables can only bind to value types
-                other = other->stripReferences();
-                OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
-                assert( tyvar != openVars.end() );
-                if ( ! tyVarCompatible( tyvar->second, other ) ) {
-                        return false;
-                } // if
-                if ( occurs( other, typeInst->get_name(), env ) ) {
-                        return false;
-                } // if
-                if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
-                        if ( curClass->type ) {
-                                Type *common = 0;
-                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
-                                Type* newType = curClass->type->clone();
-                                newType->get_qualifiers() = typeInst->get_qualifiers();
-                                if ( unifyInexact( newType, other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
-                                        if ( common ) {
-                                                common->get_qualifiers() = Type::Qualifiers();
-                                                EqvClass newClass = *curClass;
-                                                newClass.type = common;
-                                                env.add( std::move(newClass) );
-                                        } // if
-                                        return true;
-                                } else {
-                                        return false;
-                                } // if
-                        } else {
-                                EqvClass newClass = *curClass;
-                                newClass.type = other->clone();
-                                newClass.type->get_qualifiers() = Type::Qualifiers();
-                                newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
-                                env.add( std::move(newClass) );
-                        } // if
-                } else {
-                        EqvClass newClass;
-                        newClass.vars.insert( typeInst->get_name() );
-                        newClass.type = other->clone();
-                        newClass.type->get_qualifiers() = Type::Qualifiers();
-                        newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
-                        newClass.data = data;
-                        env.add( newClass );
-                } // if
-                return true;
-        }
-
-        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 ) {
-                bool result = true;
-                const EqvClass *class1 = env.lookup( var1->get_name() );
-                const EqvClass *class2 = env.lookup( var2->get_name() );
-                bool widen1 = false, widen2 = false;
-                Type *type1 = nullptr, *type2 = nullptr;
-
-                if ( class1 ) {
-                        if ( class1->type ) {
-                                if ( occurs( class1->type, var2->get_name(), env ) ) {
-                                        return false;
-                                } // if
-                                type1 = class1->type->clone();
-                        } // if
-                        widen1 = widenMode.widenFirst && class1->allowWidening;
-                } // if
-                if ( class2 ) {
-                        if ( class2->type ) {
-                                if ( occurs( class2->type, var1->get_name(), env ) ) {
-                                        return false;
-                                } // if
-                                type2 = class2->type->clone();
-                        } // if
-                        widen2 = widenMode.widenSecond && class2->allowWidening;
-                } // if
-
-                if ( type1 && type2 ) {
-//    std::cerr << "has type1 && type2" << std::endl;
-                        WidenMode newWidenMode ( widen1, widen2 );
-                        Type *common = 0;
-                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
-                                EqvClass newClass1 = *class1;
-                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
-                                newClass1.allowWidening = widen1 && widen2;
-                                if ( common ) {
-                                        common->get_qualifiers() = Type::Qualifiers();
-                                        newClass1.type = common;
-                                } // if
-                                env.add( std::move(newClass1) );
-                        } else {
-                                result = false;
-                        } // if
-                } else if ( class1 && class2 ) {
-                        if ( type1 ) {
-                                EqvClass newClass1 = *class1;
-                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
-                                newClass1.allowWidening = widen1;
-                                env.add( std::move(newClass1) );
-                        } else {
-                                EqvClass newClass2 = *class2;
-                                newClass2.vars.insert( class1->vars.begin(), class1->vars.end() );
-                                newClass2.allowWidening = widen2;
-                                env.add( std::move(newClass2) );
-                        } // if
-                } else if ( class1 ) {
-                        EqvClass newClass1 = *class1;
-                        newClass1.vars.insert( var2->get_name() );
-                        newClass1.allowWidening = widen1;
-                        env.add( std::move(newClass1) );
-                } else if ( class2 ) {
-                        EqvClass newClass2 = *class2;
-                        newClass2.vars.insert( var1->get_name() );
-                        newClass2.allowWidening = widen2;
-                        env.add( std::move(newClass2) );
-                } else {
-                        EqvClass newClass;
-                        newClass.vars.insert( var1->get_name() );
-                        newClass.vars.insert( var2->get_name() );
-                        newClass.allowWidening = widen1 && widen2;
-                        newClass.data = data;
-                        env.add( newClass );
-                } // if
-                return result;
-        }
-
         bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 OpenVarSet closedVars;
@@ -307 +159 @@
 
                 if ( isopen1 && isopen2 && entry1->second == entry2->second ) {
-                        result = bindVarToVar( var1, var2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                        result = env.bindVarToVar( var1, var2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
                 } else if ( isopen1 ) {
-                        result = bindVar( var1, type2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                        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 = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                        result = env.bindVar( var2, type1, entry2->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
                 } else {
                         PassVisitor<Unify> comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );