Changes in src/ResolvExpr/Unify.cc [6c3a988f:4a9ccc3]

File:

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

src/ResolvExpr/Unify.cc

@@ -123 +123 @@
         }
 
-        struct CompleteTypeChecker : public Visitor {
-                virtual void visit( VoidType *basicType ) { status = false; }
-                virtual void visit( BasicType *basicType ) {}
-                virtual void visit( PointerType *pointerType ) {}
-                virtual void visit( ArrayType *arrayType ) { status = ! arrayType->get_isVarLen(); }
-                virtual void visit( FunctionType *functionType ) {}
-                virtual void visit( StructInstType *aggregateUseType ) { status = aggregateUseType->get_baseStruct()->has_body(); }
-                virtual void visit( UnionInstType *aggregateUseType ) { status = aggregateUseType->get_baseUnion()->has_body(); }
-                // xxx - enum inst does not currently contain a pointer to base, this should be fixed.
-                virtual void visit( EnumInstType *aggregateUseType ) { /* status = aggregateUseType->get_baseEnum()->hasBody(); */ }
-                virtual void visit( TraitInstType *aggregateUseType ) { assert( false ); }
-                virtual void visit( TypeInstType *aggregateUseType ) { status = aggregateUseType->get_baseType()->isComplete(); }
-                virtual void visit( TupleType *tupleType ) {} // xxx - not sure if this is right, might need to recursively check complete-ness
-                virtual void visit( TypeofType *typeofType ) { assert( false ); }
-                virtual void visit( AttrType *attrType ) { assert( false ); } // xxx - not sure what to do here
-                virtual void visit( VarArgsType *varArgsType ){} // xxx - is this right?
-                virtual void visit( ZeroType *zeroType ) {}
-                virtual void visit( OneType *oneType ) {}
-                bool status = true;
-        };
-        bool isComplete( Type * type ) {
-                CompleteTypeChecker checker;
-                assert( type );
-                type->accept( checker );
-                return checker.status;
-        }
-
         bool tyVarCompatible( const TypeDecl::Data & data, Type *type, const SymTab::Indexer &indexer ) {
                 switch ( data.kind ) {
@@ -158 +131 @@
                         // type must also be complete
                         // xxx - should this also check that type is not a tuple type and that it's not a ttype?
-                        return ! isFtype( type, indexer ) && (! data.isComplete || isComplete( type ));
+                        return ! isFtype( type, indexer ) && (! data.isComplete || type->isComplete() );
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
                         case TypeDecl::Ttype:
                         // ttype unifies with any tuple type
-                        return dynamic_cast< TupleType * >( type );
+                        return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
                 } // switch
                 return false;
@@ -488 +461 @@
         }
 
-        template< typename Iterator >
-        std::unique_ptr<Type> combineTypes( Iterator begin, Iterator end ) {
+        template< typename Iterator, typename Func >
+        std::unique_ptr<Type> combineTypes( Iterator begin, Iterator end, Func & toType ) {
                 std::list< Type * > types;
                 for ( ; begin != end; ++begin ) {
                         // it's guaranteed that a ttype variable will be bound to a flat tuple, so ensure that this results in a flat tuple
-                        flatten( (*begin)->get_type(), back_inserter( types ) );
+                        flatten( toType( *begin ), back_inserter( types ) );
                 }
                 return std::unique_ptr<Type>( new TupleType( Type::Qualifiers(), types ) );
@@ -500 +473 @@
         template< typename Iterator1, typename Iterator2 >
         bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+                auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
                         Type * t1 = (*list1Begin)->get_type();
@@ -509 +483 @@
                         if ( isTtype1 && ! isTtype2 ) {
                                 // combine all of the things in list2, then unify
-                                return unifyExact( t1, combineTypes( list2Begin, list2End ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                         } else if ( isTtype2 && ! isTtype1 ) {
                                 // combine all of the things in list1, then unify
-                                return unifyExact( combineTypes( list1Begin, list1End ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                         } else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
                                 return false;
@@ -522 +496 @@
                         Type * t1 = (*list1Begin)->get_type();
                         if ( Tuples::isTtype( t1 ) ) {
-                                return unifyExact( t1, combineTypes( list2Begin, list2End ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                         } else return false;
                 } else if ( list2Begin != list2End ) {
@@ -528 +502 @@
                         Type * t2 = (*list2Begin)->get_type();
                         if ( Tuples::isTtype( t2 ) ) {
-                                return unifyExact( combineTypes( list1Begin, list1End ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                         } else return false;
                 } else {
@@ -665 +639 @@
         template< typename Iterator1, typename Iterator2 >
         bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+                auto get_type = [](Type * t) { return t; };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
-                        Type *commonType = 0;
-                        if ( ! unifyInexact( *list1Begin, *list2Begin, env, needAssertions, haveAssertions, openVars, widenMode, indexer, commonType ) ) {
+                        Type * t1 = *list1Begin;
+                        Type * t2 = *list2Begin;
+                        bool isTtype1 = Tuples::isTtype( t1 );
+                        bool isTtype2 = Tuples::isTtype( t2 );
+                        // xxx - assumes ttype must be last parameter
+                        // xxx - there may be a nice way to refactor this, but be careful because the argument positioning might matter in some cases.
+                        if ( isTtype1 && ! isTtype2 ) {
+                                // combine all of the things in list2, then unify
+                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else if ( isTtype2 && ! isTtype1 ) {
+                                // combine all of the things in list1, then unify
+                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
                                 return false;
-                        }
-                        delete commonType;
+                        } // if
+
                 } // for
-                if ( list1Begin != list1End || list2Begin != list2End ) {
-                        return false;
+                if ( list1Begin != list1End ) {
+                        // try unifying empty tuple type with ttype
+                        Type * t1 = *list1Begin;
+                        if ( Tuples::isTtype( t1 ) ) {
+                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else return false;
+                } else if ( list2Begin != list2End ) {
+                        // try unifying empty tuple type with ttype
+                        Type * t2 = *list2Begin;
+                        if ( Tuples::isTtype( t2 ) ) {
+                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else return false;
                 } else {
                         return true;
-                } //if
+                } // if
         }
 
         void Unify::visit(TupleType *tupleType) {
                 if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
-                        result = unifyList( tupleType->get_types().begin(), tupleType->get_types().end(), otherTuple->get_types().begin(), otherTuple->get_types().end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                        std::unique_ptr<TupleType> flat1( tupleType->clone() );
+                        std::unique_ptr<TupleType> flat2( otherTuple->clone() );
+                        std::list<Type *> types1, types2;
+
+                        TtypeExpander expander( env );
+                        flat1->acceptMutator( expander );
+                        flat2->acceptMutator( expander );
+
+                        flatten( flat1.get(), back_inserter( types1 ) );
+                        flatten( flat2.get(), back_inserter( types2 ) );
+
+                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
                 } // if
         }