Changes in src/ResolvExpr/Unify.cc [ef9988b:07de76b]

File:

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

src/ResolvExpr/Unify.cc

@@ -25 +25 @@
 #include <vector>
 
-#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Node.hpp"
 #include "AST/Pass.hpp"
-#include "AST/Print.hpp"
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
@@ -137 +135 @@
                 findOpenVars( newSecond, open, closed, need, have, FirstOpen );
 
-                return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                return unifyExact(
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -149 +148 @@
                 newFirst->get_qualifiers() = Type::Qualifiers();
                 newSecond->get_qualifiers() = Type::Qualifiers();
-
+///   std::cerr << "first is ";
+///   first->print( std::cerr );
+///   std::cerr << std::endl << "second is ";
+///   second->print( std::cerr );
+///   std::cerr << std::endl << "newFirst is ";
+///   newFirst->print( std::cerr );
+///   std::cerr << std::endl << "newSecond is ";
+///   newSecond->print( std::cerr );
+///   std::cerr << std::endl;
                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                 delete newFirst;
@@ -163 +170 @@
                 ast::AssertionSet need, have;
 
-                ast::Type * newFirst  = shallowCopy( first  );
-                ast::Type * newSecond = shallowCopy( second );
-                newFirst ->qualifiers = {};
-                newSecond->qualifiers = {};
-                ast::ptr< ast::Type > t1_(newFirst );
-                ast::ptr< ast::Type > t2_(newSecond);
-
-                ast::ptr< ast::Type > subFirst = env.apply(newFirst).node;
-                ast::ptr< ast::Type > subSecond = env.apply(newSecond).node;
+                ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
+                env.apply( newFirst );
+                env.apply( newSecond );
+                reset_qualifiers( newFirst );
+                reset_qualifiers( newSecond );
 
                 return unifyExact(
-                        subFirst,
-                        subSecond,
-                        newEnv, need, have, open, noWiden(), symtab );
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -325 +326 @@
 
         void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
+///   std::cerr << "assertion set is" << std::endl;
+///   printAssertionSet( assertions, std::cerr, 8 );
+///   std::cerr << "looking for ";
+///   assert->print( std::cerr );
+///   std::cerr << std::endl;
                 AssertionSet::iterator i = assertions.find( assert );
                 if ( i != assertions.end() ) {
+///     std::cerr << "found it!" << std::endl;
                         i->second.isUsed = true;
                 } // if
@@ -702 +709 @@
                 const ast::SymbolTable & symtab;
         public:
-                static size_t traceId;
                 bool result;
 
@@ -791 +797 @@
                         for ( const ast::DeclWithType * d : src ) {
                                 ast::Pass<TtypeExpander_new> expander{ env };
-                                // TtypeExpander pass is impure (may mutate nodes in place)
-                                // need to make nodes shared to prevent accidental mutation
-                                ast::ptr<ast::DeclWithType> dc = d;
-                                dc = dc->accept( expander );
-                                auto types = flatten( dc->get_type() );
+                                d = d->accept( expander );
+                                auto types = flatten( d->get_type() );
                                 for ( ast::ptr< ast::Type > & t : types ) {
                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
@@ -804 +807 @@
                                         // requirements than a non-mutex function
                                         remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
-                                        dst.emplace_back( new ast::ObjectDecl{ dc->location, "", t } );
+                                        dst.emplace_back( new ast::ObjectDecl{ d->location, "", t } );
                                 }
                         }
@@ -940 +943 @@
 
         private:
-                // Returns: other, cast as XInstType
-                // Assigns this->result: whether types are compatible (up to generic parameters)
-                template< typename XInstType >
-                const XInstType * handleRefType( const XInstType * inst, const ast::Type * other ) {
+                template< typename RefType >
+                const RefType * handleRefType( const RefType * inst, const ast::Type * other ) {
                         // check that the other type is compatible and named the same
-                        auto otherInst = dynamic_cast< const XInstType * >( other );
-                        this->result = otherInst && inst->name == otherInst->name;
+                        auto otherInst = dynamic_cast< const RefType * >( other );
+                        result = otherInst && inst->name == otherInst->name;
                         return otherInst;
                 }
@@ -967 +968 @@
                 }
 
-                template< typename XInstType >
-                void handleGenericRefType( const XInstType * inst, const ast::Type * other ) {
+                template< typename RefType >
+                void handleGenericRefType( const RefType * inst, const ast::Type * other ) {
                         // check that other type is compatible and named the same
-                        const XInstType * otherInst = handleRefType( inst, other );
-                        if ( ! this->result ) return;
+                        const RefType * inst2 = handleRefType( inst, other );
+                        if ( ! inst2 ) return;
 
                         // check that parameters of types unify, if any
                         const std::vector< ast::ptr< ast::Expr > > & params = inst->params;
-                        const std::vector< ast::ptr< ast::Expr > > & params2 = otherInst->params;
+                        const std::vector< ast::ptr< ast::Expr > > & params2 = inst2->params;
 
                         auto it = params.begin();
@@ -1113 +1114 @@
 
                         ast::Pass<TtypeExpander_new> expander{ tenv };
-
-                        ast::ptr<ast::TupleType> tuplec = tuple;
-                        ast::ptr<ast::TupleType> tuple2c = tuple2;
-                        const ast::Type * flat = tuplec->accept( expander );
-                        const ast::Type * flat2 = tuple2c->accept( expander );
+                        const ast::Type * flat = tuple->accept( expander );
+                        const ast::Type * flat2 = tuple2->accept( expander );
 
                         auto types = flatten( flat );
@@ -1142 +1140 @@
         };
 
-        // size_t Unify_new::traceId = Stats::Heap::new_stacktrace_id("Unify_new");
         bool unify(
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
@@ -1191 +1188 @@
                         ast::Pass<Unify_new> comparator{ type2, env, need, have, open, widen, symtab };
                         type1->accept( comparator );
-                        return comparator.core.result;
+                        return comparator.pass.result;
                 }
         }
@@ -1205 +1202 @@
                 // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and
                 // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
-                ast::Type * t1 = shallowCopy(type1.get());
-                ast::Type * t2 = shallowCopy(type2.get());
-                t1->qualifiers = {};
-                t2->qualifiers = {};
-                ast::ptr< ast::Type > t1_(t1);
-                ast::ptr< ast::Type > t2_(t2);
+                ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
+                reset_qualifiers( t1 );
+                reset_qualifiers( t2 );
 
                 if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
+                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
+
                         // if exact unification on unqualified types, try to merge qualifiers
                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
-                                t1->qualifiers = q1 | q2;
-                                common = t1;
+                                common = type1;
+                                reset_qualifiers( common, q1 | q2 );
                                 return true;
                         } else {
@@ -1223 +1219 @@
 
                 } else if (( common = commonType( t1, t2, widen, symtab, env, open ) )) {
+                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
+
                         // no exact unification, but common type
-                        auto c = shallowCopy(common.get());
-                        c->qualifiers = q1 | q2;
-                        common = c;
+                        reset_qualifiers( common, q1 | q2 );
                         return true;
                 } else {