Changes in src/ResolvExpr/Unify.cc [62423350:ce8c12f]

File:

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

src/ResolvExpr/Unify.cc

@@ -42 +42 @@
                 virtual void visit(PointerType *pointerType);
                 virtual void visit(ArrayType *arrayType);
+                virtual void visit(ReferenceType *refType);
                 virtual void visit(FunctionType *functionType);
                 virtual void visit(StructInstType *aggregateUseType);
@@ -114 +115 @@
         }
 
-        bool isFtype( Type *type ) {
+        bool isFtype( Type *type, const SymTab::Indexer &indexer ) {
                 if ( dynamic_cast< FunctionType* >( type ) ) {
                         return true;
@@ -123 +124 @@
         }
 
-        bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
+        bool tyVarCompatible( const TypeDecl::Data & data, Type *type, const SymTab::Indexer &indexer ) {
                 switch ( data.kind ) {
                   case TypeDecl::Any:
@@ -131 +132 @@
                         // 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() );
+                        return ! isFtype( type, indexer ) && (! data.isComplete || type->isComplete() );
                   case TypeDecl::Ftype:
-                        return isFtype( type );
+                        return isFtype( type, indexer );
                   case TypeDecl::Ttype:
                         // ttype unifies with any tuple type
@@ -144 +145 @@
                 OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
                 assert( tyvar != openVars.end() );
-                if ( ! tyVarCompatible( tyvar->second, other ) ) {
+                if ( ! tyVarCompatible( tyvar->second, other, indexer ) ) {
                         return false;
                 } // if
@@ -344 +345 @@
                 std::cerr << "unifyInexact type 1 is ";
                 type1->print( std::cerr );
-                std::cerr << " type 2 is ";
+                std::cerr << "type 2 is ";
                 type2->print( std::cerr );
                 std::cerr << std::endl;
@@ -388 +389 @@
         }
 
-        void Unify::visit( __attribute__((unused)) VoidType *voidType) {
+        void Unify::visit(VoidType *voidType) {
                 result = dynamic_cast< VoidType* >( type2 );
         }
@@ -425 +426 @@
                         markAssertions( haveAssertions, needAssertions, pointerType );
                         markAssertions( haveAssertions, needAssertions, otherPointer );
+                } // if
+        }
+
+        void Unify::visit(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 );
+                        markAssertions( haveAssertions, needAssertions, refType );
+                        markAssertions( haveAssertions, needAssertions, otherRef );
                 } // if
         }
@@ -606 +615 @@
                         } else if ( tupleParam ) {
                                 // bundle other parameters into tuple to match
-                                std::list< Type * > binderTypes;
+                                TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
 
                                 do {
-                                        binderTypes.push_back( otherParam->get_type()->clone() );
+                                        binder->get_types().push_back( otherParam->get_type()->clone() );
                                         ++jt;
 
@@ -618 +627 @@
                                 } while (true);
 
-                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
+                                otherParamTy = binder;
                                 ++it;  // skip ttype parameter for break
                         } else if ( otherTupleParam ) {
                                 // bundle parameters into tuple to match other
-                                std::list< Type * > binderTypes;
+                                TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
 
                                 do {
-                                        binderTypes.push_back( param->get_type()->clone() );
+                                        binder->get_types().push_back( param->get_type()->clone() );
                                         ++it;
 
@@ -634 +643 @@
                                 } while (true);
 
-                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
+                                paramTy = binder;
                                 ++jt;  // skip ttype parameter for break
                         }
@@ -683 +692 @@
 
         template< typename Iterator1, typename Iterator2 >
-        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+        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 ) {
@@ -733 +742 @@
                         flatten( flat2.get(), back_inserter( types2 ) );
 
-                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, indexer );
-                } // if
-        }
-
-        void Unify::visit( __attribute__((unused)) VarArgsType *varArgsType ) {
+                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                } // if
+        }
+
+        void Unify::visit(VarArgsType *varArgsType) {
                 result = dynamic_cast< VarArgsType* >( type2 );
         }
 
-        void Unify::visit( __attribute__((unused)) ZeroType *zeroType ) {
+        void Unify::visit(ZeroType *zeroType) {
                 result = dynamic_cast< ZeroType* >( type2 );
         }
 
-        void Unify::visit( __attribute__((unused)) OneType *oneType ) {
+        void Unify::visit(OneType *oneType) {
                 result = dynamic_cast< OneType* >( type2 );
         }
@@ -756 +765 @@
                         return function->get_returnVals().front()->get_type()->clone();
                 } else {
-                        std::list< Type * > types;
+                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
                         for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                types.push_back( decl->get_type()->clone() );
+                                tupleType->get_types().push_back( decl->get_type()->clone() );
                         } // for
-                        return new TupleType( Type::Qualifiers(), types );
+                        return tupleType;
                 }
         }