Changes in src/ResolvExpr/Unify.cc [f0ecf9b:ea6332d]

File:

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

src/ResolvExpr/Unify.cc

@@ -17 +17 @@
 #include <iterator>               // for back_insert_iterator, back_inserter
 #include <map>                    // for _Rb_tree_const_iterator, _Rb_tree_i...
-#include <memory>                 // for unique_ptr
+#include <memory>                 // for unique_ptr, auto_ptr
 #include <set>                    // for set
 #include <string>                 // for string, operator==, operator!=, bas...
 #include <utility>                // for pair
 
-#include "Common/PassVisitor.h"   // for PassVisitor
 #include "FindOpenVars.h"         // for findOpenVars
 #include "Parser/LinkageSpec.h"   // for C
@@ -54 +53 @@
                 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);
@@ -138 +136 @@
         bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
                 switch ( data.kind ) {
+                  case TypeDecl::Any:
                   case TypeDecl::Dtype:
                         // to bind to an object type variable, the type must not be a function type.
@@ -154 +153 @@
 
         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() );
@@ -169 +166 @@
                                 Type *common = 0;
                                 // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
-                                std::unique_ptr< Type > newType( curClass.type->clone() );
+                                std::auto_ptr< Type > newType( curClass.type->clone() );
                                 newType->get_qualifiers() = typeInst->get_qualifiers();
                                 if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
@@ -390 +387 @@
                                 } // if
                         } else {
-                                common = type1->clone();
-                                common->get_qualifiers() = tq1 | tq2;
                                 result = true;
                         } // if
@@ -444 +439 @@
         }
 
-        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
-        }
-
         void Unify::visit(ArrayType *arrayType) {
                 ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
@@ -457 +444 @@
                 // and must both have a dimension expression or not have a dimension
                 if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) {
+
+                        // not positive this is correct in all cases, but it's needed for typedefs
+                        if ( arrayType->get_isVarLen() || otherArray->get_isVarLen() ) {
+                                return;
+                        }
 
                         if ( ! arrayType->get_isVarLen() && ! otherArray->get_isVarLen() &&
@@ -532 +524 @@
         /// If this isn't done then argument lists can have wildly different
         /// size and structure, when they should be compatible.
-        struct TtypeExpander : public WithShortCircuiting {
-                TypeEnvironment & tenv;
-                TtypeExpander( TypeEnvironment & tenv ) : tenv( tenv ) {}
-                void premutate( TypeInstType * ) { visit_children = false; }
-                Type * postmutate( TypeInstType * typeInst ) {
+        struct TtypeExpander : public Mutator {
+                TypeEnvironment & env;
+                TtypeExpander( TypeEnvironment & env ) : env( env ) {}
+                Type * mutate( TypeInstType * typeInst ) {
                         EqvClass eqvClass;
-                        if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
+                        if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
                                 if ( eqvClass.data.kind == TypeDecl::Ttype ) {
                                         // expand ttype parameter into its actual type
@@ -556 +547 @@
                 dst.clear();
                 for ( DeclarationWithType * dcl : src ) {
-                        PassVisitor<TtypeExpander> expander( env );
+                        TtypeExpander expander( env );
                         dcl->acceptMutator( expander );
                         std::list< Type * > types;
@@ -746 +737 @@
                         std::list<Type *> types1, types2;
 
-                        PassVisitor<TtypeExpander> expander( env );
+                        TtypeExpander expander( env );
                         flat1->acceptMutator( expander );
                         flat2->acceptMutator( expander );