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

File:

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

src/ResolvExpr/Unify.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:27:10 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Sep  4 10:00:00 2019
-// Update Count     : 44
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Dec 13 23:43:05 2019
+// Update Count     : 46
 //
 
@@ -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"
 #include "Common/PassVisitor.h"     // for PassVisitor
 #include "FindOpenVars.h"           // for findOpenVars
-#include "Parser/LinkageSpec.h"     // for C
+#include "SynTree/LinkageSpec.h"    // for C
 #include "SynTree/Constant.h"       // for Constant
 #include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
@@ -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> newFirst{ first }, newSecond{ second };
+                env.apply( newFirst );
+                env.apply( newSecond );
+                reset_qualifiers( newFirst );
+                reset_qualifiers( newSecond );
 
                 return unifyExact(
-                        env.apply( newFirst  ).node,
-                        env.apply( newSecond ).node,
-                        newEnv, need, have, open, noWiden(), symtab );
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -322 +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
@@ -771 +781 @@
                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
                                         // expand ttype parameter into its actual type
-                                        if ( clz->data.kind == ast::TypeVar::Ttype && clz->bound ) {
+                                        if ( clz->data.kind == ast::TypeDecl::Ttype && clz->bound ) {
                                                 return clz->bound;
                                         }
@@ -933 +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;
                 }
@@ -960 +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();
@@ -1194 +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 {
@@ -1212 +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 {