Changeset 9a19608

Timestamp:

Jun 4, 2019, 4:49:30 PM (5 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

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

Children:

9519aba

Parents:

1867c96 (diff), de8dfac2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Expr.cpp (modified) (5 diffs)
• AST/Node.hpp (modified) (1 diff)
• AST/Type.hpp (modified) (1 diff)
• AST/TypeEnvironment.cpp (modified) (5 diffs)
• AST/TypeEnvironment.hpp (modified) (1 diff)
• ResolvExpr/CommonType.cc (modified) (13 diffs)
• ResolvExpr/Unify.cc (modified) (25 diffs)
• ResolvExpr/Unify.h (modified) (1 diff)
• ResolvExpr/WidenMode.h (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (3 diffs)

src/AST/Expr.cpp

@@ -65 +65 @@
                         // base type
                         ret->result = base;
-                        add_lvalue( ret->result );
+                        add_qualifiers( ret->result, CV::Lvalue );
                 }
         }
@@ -165 +165 @@
         genericSubsitution( aggregate->result ).apply( result );
         // ensure lvalue and appropriate restrictions from aggregate type
-        result.get_and_mutate()->qualifiers |= aggregate->result->qualifiers | CV::Lvalue;
+        add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );
 }
 
@@ -175 +175 @@
         assert( var->get_type() );
         result = var->get_type();
-        add_lvalue( result );
+        add_qualifiers( result, CV::Lvalue );
 }
 
@@ -309 +309 @@
         assert( t && i );
         result = t;
-        add_lvalue( result );
+        add_qualifiers( result, CV::Lvalue );
 }
 
@@ -326 +326 @@
         // like MemberExpr, TupleIndexExpr is always an lvalue
         result = type->types[ index ];
-        add_lvalue( result );
+        add_qualifiers( result, CV::Lvalue );
 }
 

src/AST/Node.hpp

@@ -166 +166 @@
         const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
 
+        /// wrapper for convenient access to strict_dynamic_cast
+        template<typename o_node_t>
+        const o_node_t * strict_as() const { return strict_dynamic_cast<const o_node_t *>(node); }
+
         /// Returns a mutable version of the pointer in this node.
         node_t * get_and_mutate();

src/AST/Type.hpp

@@ -77 +77 @@
 };
 
-/// Set the `is_lvalue` qualifier on this type, cloning only if necessary
+/// Clear/reset the qualifiers on this type, cloning only if necessary
 template< enum Node::ref_type ref_t >
-void add_lvalue( ptr_base< Type, ref_t > & p ) {
-        if ( ! p->qualifiers.is_lvalue ) p.get_and_mutate()->qualifiers.is_lvalue = true;
+void reset_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q = {} ) {
+        if ( p->qualifiers.val != q.val ) p.get_and_mutate()->qualifiers = q;
 }
 
-/// Clear the qualifiers on this type, cloning only if necessary
+/// Add the specified qualifiers to this type, cloning only if necessary
 template< enum Node::ref_type ref_t >
-void clear_qualifiers( ptr_base< Type, ref_t > & p ) {
-        if ( p->qualifiers != CV::Qualifiers{} ) p.get_and_mutate()->qualifiers = CV::Qualifiers{};
+void add_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
+        if ( ( p->qualifiers.val & q.val ) != q.val ) p.get_and_mutate()->qualifiers |= q;
+}
+
+/// Remove the specified qualifiers from this type, cloning only if necessary
+template< enum Node::ref_type ref_t >
+void remove_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
+        if ( ( p->qualifiers.val & q.val ) != 0 ) p.get_and_mutate()->qualifiers -= q;
 }
 

src/AST/TypeEnvironment.cpp

@@ -235 +235 @@
 }
 
+/// true if a type is a function type
+bool isFtype( const Type * type ) {
+        if ( dynamic_cast< const FunctionType * >( type ) ) {
+                return true;
+        } else if ( auto typeInst = dynamic_cast< const TypeInstType * >( type ) ) {
+                return typeInst->kind == TypeVar::Ftype;
+        } else return false;
+}
+
 namespace {
-        /// true if a type is a function type
-        bool isFtype( const Type * type ) {
-                if ( dynamic_cast< const FunctionType * >( type ) ) {
-                        return true;
-                } else if ( auto typeInst = dynamic_cast< const TypeInstType * >( type ) ) {
-                        return typeInst->kind == TypeVar::Ftype;
-                } else return false;
-        }
-
         /// true if the given type can be bound to the given type variable
         bool tyVarCompatible( const TypeDecl::Data & data, const Type * type ) {
@@ -285 +285 @@
                         ptr<Type> common;
                         ptr<Type> newType = it->bound;
-                        newType.get_and_mutate()->qualifiers = typeInst->qualifiers;
+                        reset_qualifiers( newType, typeInst->qualifiers );
                         if ( unifyInexact( 
                                         newType, target, *this, need, have, open, 
@@ -291 +291 @@
                                 if ( common ) {
                                         it->bound = std::move(common);
-                                        clear_qualifiers( it->bound );
+                                        reset_qualifiers( it->bound );
                                 }
                         } else return false;
                 } else {
                         it->bound = std::move(target);
-                        clear_qualifiers( it->bound );
+                        reset_qualifiers( it->bound );
                         it->allowWidening = widen.first && widen.second;
                 }
@@ -351 +351 @@
                         if ( common ) {
                                 c1->bound = std::move(common);
-                                clear_qualifiers( c1->bound );
+                                reset_qualifiers( c1->bound );
                         }
                         c1->data.isComplete |= data.isComplete;
@@ -411 +411 @@
                                 if ( common ) {
                                         to.bound = std::move(common);
-                                        clear_qualifiers( to.bound );
+                                        reset_qualifiers( to.bound );
                                 }
                         } else return false; // cannot unify

src/AST/TypeEnvironment.hpp

@@ -112 +112 @@
         EqvClass( const std::string & v, const Type * b, bool w, const TypeDecl::Data & d )
         : vars{ v }, bound( b ), allowWidening( w ), data( d ) {
-                clear_qualifiers( bound );
+                reset_qualifiers( bound );
         }
 

src/ResolvExpr/CommonType.cc

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

src/ResolvExpr/Unify.cc

@@ -136 +136 @@
 
                 return unifyExact( 
-                        newFirst, newSecond, newEnv, need, have, open, WidenMode{ false, false }, symtab );
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -173 +173 @@
                 env.apply( newFirst );
                 env.apply( newSecond );
-                clear_qualifiers( newFirst );
-                clear_qualifiers( newSecond );
+                reset_qualifiers( newFirst );
+                reset_qualifiers( newSecond );
 
                 return unifyExact( 
-                        newFirst, newSecond, newEnv, need, have, open, WidenMode{ false, false }, symtab );
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -700 +700 @@
         }
 
-        class Unify_new : public ast::WithShortCircuiting {
+        class Unify_new final : public ast::WithShortCircuiting {
                 const ast::Type * type2;
                 ast::TypeEnvironment & tenv;
@@ -720 +720 @@
                 void previsit( const ast::Node * ) { visit_children = false; }
                 
-                void previsit( const ast::VoidType * ) {
-                        visit_children = false;
+                void postvisit( const ast::VoidType * ) {
                         result = dynamic_cast< const ast::VoidType * >( type2 );
                 }
 
-                void previsit( const ast::BasicType * basic ) {
-                        visit_children = false;
+                void postvisit( const ast::BasicType * basic ) {
                         if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
                                 result = basic->kind == basic2->kind;
@@ -732 +730 @@
                 }
 
-                void previsit( const ast::PointerType * pointer ) {
-                        visit_children = false;
+                void postvisit( const ast::PointerType * pointer ) {
                         if ( auto pointer2 = dynamic_cast< const ast::PointerType * >( type2 ) ) {
                                 result = unifyExact( 
                                         pointer->base, pointer2->base, tenv, need, have, open, 
-                                        WidenMode{ false, false }, symtab );
-                        }
-                }
-
-                void previsit( const ast::ArrayType * array ) {
-                        visit_children = false;
+                                        noWiden(), symtab );
+                        }
+                }
+
+                void postvisit( const ast::ArrayType * array ) {
                         auto array2 = dynamic_cast< const ast::ArrayType * >( type2 );
                         if ( ! array2 ) return;
@@ -761 +757 @@
 
                         result = unifyExact( 
-                                array->base, array2->base, tenv, need, have, open, WidenMode{ false, false }, 
+                                array->base, array2->base, tenv, need, have, open, noWiden(), 
                                 symtab );
                 }
 
-                void previsit( const ast::ReferenceType * ref ) {
-                        visit_children = false;
+                void postvisit( const ast::ReferenceType * ref ) {
                         if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
                                 result = unifyExact( 
-                                        ref->base, ref2->base, tenv, need, have, open, WidenMode{ false, false }, 
+                                        ref->base, ref2->base, tenv, need, have, open, noWiden(), 
                                         symtab );
                         }
@@ -783 +778 @@
                         TtypeExpander_new( ast::TypeEnvironment & env ) : tenv( env ) {}
 
-                        const ast::Type * postmutate( const ast::TypeInstType * typeInst ) {
+                        const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
                                         // expand ttype parameter into its actual type
@@ -811 +806 @@
                                         // overloaded on outermost mutex and a mutex function has different 
                                         // requirements than a non-mutex function
-                                        t.get_and_mutate()->qualifiers 
-                                                -= ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic;
+                                        remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
                                         dst.emplace_back( new ast::ObjectDecl{ d->location, "", t } );
                                 }
@@ -851 +845 @@
                                         return unifyExact( 
                                                 t1, tupleFromDecls( crnt2, end2 ), env, need, have, open, 
-                                                WidenMode{ false, false }, symtab );
+                                                noWiden(), symtab );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine remainder of list1, then unify
                                         return unifyExact( 
                                                 tupleFromDecls( crnt1, end1 ), t2, env, need, have, open, 
-                                                WidenMode{ false, false }, symtab );
+                                                noWiden(), symtab );
                                 }
 
                                 if ( ! unifyExact( 
-                                        t1, t2, env, need, have, open, WidenMode{ false, false }, symtab ) 
+                                        t1, t2, env, need, have, open, noWiden(), symtab ) 
                                 ) return false;
 
@@ -874 +868 @@
                                 return unifyExact( 
                                         t1, tupleFromDecls( crnt2, end2 ), env, need, have, open, 
-                                        WidenMode{ false, false }, symtab );
+                                        noWiden(), symtab );
                         } else if ( crnt2 != end2 ) {
                                 // try unifying empty tuple with ttype
@@ -881 +875 @@
                                 return unifyExact( 
                                         tupleFromDecls( crnt1, end1 ), t2, env, need, have, open, 
-                                        WidenMode{ false, false }, symtab );
+                                        noWiden(), symtab );
                         }
 
@@ -919 +913 @@
 
         public:
-                void previsit( const ast::FunctionType * func ) {
-                        visit_children = false;
+                void postvisit( const ast::FunctionType * func ) {
                         auto func2 = dynamic_cast< const ast::FunctionType * >( type2 );
                         if ( ! func2 ) return;
@@ -952 +945 @@
                 template< typename RefType >
                 const RefType * handleRefType( const RefType * inst, const ast::Type * other ) {
-                        visit_children = false;
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const RefType * >( other );
@@ -1011 +1003 @@
 
                                 if ( ! unifyExact( 
-                                                pty, pty2, tenv, need, have, open, WidenMode{ false, false }, symtab ) ) {
+                                                pty, pty2, tenv, need, have, open, noWiden(), symtab ) ) {
                                         result = false;
                                         return;
@@ -1023 +1015 @@
 
         public:
-                void previsit( const ast::StructInstType * aggrType ) {
+                void postvisit( const ast::StructInstType * aggrType ) {
                         handleGenericRefType( aggrType, type2 );
                 }
 
-                void previsit( const ast::UnionInstType * aggrType ) {
+                void postvisit( const ast::UnionInstType * aggrType ) {
                         handleGenericRefType( aggrType, type2 );
                 }
 
-                void previsit( const ast::EnumInstType * aggrType ) {
+                void postvisit( const ast::EnumInstType * aggrType ) {
                         handleRefType( aggrType, type2 );
                 }
 
-                void previsit( const ast::TraitInstType * aggrType ) {
+                void postvisit( const ast::TraitInstType * aggrType ) {
                         handleRefType( aggrType, type2 );
                 }
 
-                void previsit( const ast::TypeInstType * typeInst ) {
+                void postvisit( const ast::TypeInstType * typeInst ) {
                         assert( open.find( typeInst->name ) == open.end() );
                         handleRefType( typeInst, type2 );
@@ -1078 +1070 @@
                                         return unifyExact( 
                                                 t1, tupleFromTypes( list2 ), env, need, have, open, 
-                                                WidenMode{ false, false }, symtab );
+                                                noWiden(), symtab );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine entirety of list1, then unify
                                         return unifyExact(
                                                 tupleFromTypes( list1 ), t2, env, need, have, open, 
-                                                WidenMode{ false, false }, symtab );
+                                                noWiden(), symtab );
                                 }
 
                                 if ( ! unifyExact( 
-                                        t1, t2, env, need, have, open, WidenMode{ false, false }, symtab ) 
+                                        t1, t2, env, need, have, open, noWiden(), symtab ) 
                                 ) return false;
 
@@ -1101 +1093 @@
                                 return unifyExact( 
                                                 t1, tupleFromTypes( list2 ), env, need, have, open, 
-                                                WidenMode{ false, false }, symtab );
+                                                noWiden(), symtab );
                         } else if ( crnt2 != list2.end() ) {
                                 // try unifying empty tuple with ttype
@@ -1110 +1102 @@
                                 return unifyExact(
                                                 tupleFromTypes( list1 ), t2, env, need, have, open, 
-                                                WidenMode{ false, false }, symtab );
+                                                noWiden(), symtab );
                         }
 
@@ -1117 +1109 @@
 
         public:
-                void previsit( const ast::TupleType * tuple ) {
-                        visit_children = false;
+                void postvisit( const ast::TupleType * tuple ) {
                         auto tuple2 = dynamic_cast< const ast::TupleType * >( type2 );
                         if ( ! tuple2 ) return;
@@ -1132 +1123 @@
                 }
 
-                void previsit( const ast::VarArgsType * ) {
-                        visit_children = false;
+                void postvisit( const ast::VarArgsType * ) {
                         result = dynamic_cast< const ast::VarArgsType * >( type2 );
                 }
 
-                void previsit( const ast::ZeroType * ) {
-                        visit_children = false;
+                void postvisit( const ast::ZeroType * ) {
                         result = dynamic_cast< const ast::ZeroType * >( type2 );
                 }
 
-                void previsit( const ast::OneType * ) {
-                        visit_children = false;
+                void postvisit( const ast::OneType * ) {
                         result = dynamic_cast< const ast::OneType * >( type2 );
                 }       
@@ -1151 +1139 @@
                 template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
         };
+
+        bool unify( 
+                        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                        ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common 
+        ) {
+                ast::OpenVarSet closed;
+                findOpenVars( type1, open, closed, need, have, FirstClosed );
+                findOpenVars( type2, open, closed, need, have, FirstOpen );
+                return unifyInexact( 
+                        type1, type2, env, need, have, open, WidenMode{ true, true }, symtab, common );
+        }
 
         bool unifyExact( 
@@ -1184 +1184 @@
 
         bool unifyInexact( 
-                        ast::ptr<ast::Type> & type1, ast::ptr<ast::Type> & type2, ast::TypeEnvironment & env, 
-                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
-                        WidenMode widen, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common 
+                        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab, 
+                        ast::ptr<ast::Type> & common 
         ) {
                 ast::CV::Qualifiers q1 = type1->qualifiers, q2 = type2->qualifiers;
@@ -1193 +1194 @@
                 // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
                 ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
-                clear_qualifiers( t1 );
-                clear_qualifiers( t2 );
+                reset_qualifiers( t1 );
+                reset_qualifiers( t2 );
                 
                 if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
@@ -1201 +1202 @@
                         // if exact unification on unqualified types, try to merge qualifiers
                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
-                                common.set_and_mutate( type1 )->qualifiers = q1 | q2;
+                                common = type1;
+                                reset_qualifiers( common, q1 | q2 );
                                 return true;
                         } else {
@@ -1211 +1213 @@
 
                         // no exact unification, but common type
-                        common.get_and_mutate()->qualifiers = q1 | q2;
+                        reset_qualifiers( common, q1 | q2 );
                         return true;
                 } else {

src/ResolvExpr/Unify.h

@@ -69 +69 @@
         }
 
+        bool unify( 
+                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common );
+
         bool unifyExact( 
                 const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
-                ast::AssertionSet & need, ast::AssertionSet & have, ast::OpenVarSet & open, 
-                const ast::SymbolTable & symtab );
+                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
+                WidenMode widen, const ast::SymbolTable & symtab );
 
         bool unifyInexact( 
-                ast::ptr<ast::Type> & type1, ast::ptr<ast::Type> & type2, ast::TypeEnvironment & env, 
-                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
-                WidenMode widen, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common );
+                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
+                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
+                const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab, 
+                ast::ptr<ast::Type> & common );
 
 } // namespace ResolvExpr

src/ResolvExpr/WidenMode.h

@@ -40 +40 @@
                 bool first : 1, second : 1;
         };
+
+        static inline WidenMode noWiden() { return { false, false }; }
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -89 +89 @@
 
         // in Unify.cc
-        bool isFtype( Type *type );
         bool typesCompatible( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
         bool typesCompatibleIgnoreQualifiers( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
@@ -118 +117 @@
         // in CommonType.cc
         Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
-        const ast::Type * commonType(
-                const ast::Type * type1, const ast::Type * type2, WidenMode widen, 
+        ast::ptr< ast::Type > commonType(
+                const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, WidenMode widen, 
                 const ast::SymbolTable & symtab, ast::TypeEnvironment & env, const ast::OpenVarSet & open );
 
@@ -177 +176 @@
                 return out;
         }
+
+        // in TypeEnvironment.cc
+        bool isFtype( Type *type );
 } // namespace ResolvExpr
+
+namespace ast {
+        // in TypeEnvironment.cpp
+        bool isFtype( const ast::Type * type );
+} // namespace ast
 
 // Local Variables: //