Changeset 00ac42e for src/ResolvExpr/TypeEnvironment.cc

Timestamp:

Jun 1, 2018, 2:54:55 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

262bd63

Parents:

41e16b1

git-author:

Aaron Moss <a3moss@…> (05/31/18 16:24:49)

git-committer:

Aaron Moss <a3moss@…> (06/01/18 14:54:55)

Message:

stop eagerly copying EqvClass? on lookup

File:

• src/ResolvExpr/TypeEnvironment.cc (modified) (4 diffs)

src/ResolvExpr/TypeEnvironment.cc

@@ -17 +17 @@
 #include <algorithm>                   // for copy, set_intersection
 #include <iterator>                    // for ostream_iterator, insert_iterator
-#include <utility>                     // for pair
+#include <utility>                     // for pair, move
 
 #include "Common/utility.h"            // for maybeClone
@@ -44 +44 @@
 
         void EqvClass::initialize( const EqvClass &src, EqvClass &dest ) {
+                initialize( src, dest, src.type );
+        }
+
+        void EqvClass::initialize( const EqvClass &src, EqvClass &dest, const Type *ty ) {
                 dest.vars = src.vars;
-                dest.type = maybeClone( src.type );
+                dest.type = maybeClone( ty );
                 dest.allowWidening = src.allowWidening;
                 dest.data = src.data;
@@ -55 +59 @@
         EqvClass::EqvClass( const EqvClass &other ) {
                 initialize( other, *this );
+        }
+
+        EqvClass::EqvClass( const EqvClass &other, const Type *ty ) {
+                initialize( other, *this, ty );
         }
 
@@ -82 +90 @@
         }
 
-        bool TypeEnvironment::lookup( const std::string &var, EqvClass &eqvClass ) const {
+        const EqvClass* TypeEnvironment::lookup( const std::string &var ) const {
                 for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
                         if ( i->vars.find( var ) != i->vars.end() ) {
 ///       std::cout << var << " is in class ";
 ///       i->print( std::cout );
-                                eqvClass = *i;
-                                return true;
+                                return &*i;
                         }
 ///     std::cout << var << " is not in class ";
 ///     i->print( std::cout );
                 } // for
-                return false;
+                return nullptr;
+        }
+
+        /// Removes any class from env that intersects eqvClass
+        void filterOverlappingClasses( std::list<EqvClass> &env, const EqvClass &eqvClass ) {
+                for ( auto i = env.begin(); i != env.end(); ) {
+                        auto next = i;
+                        ++next;
+                        std::set<std::string> intersection;
+                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), 
+                                std::inserter( intersection, intersection.begin() ) );
+                        if ( ! intersection.empty() ) { env.erase( i ); }
+                        i = next;
+                }
         }
 
         void TypeEnvironment::add( const EqvClass &eqvClass ) {
-                std::list< EqvClass >::iterator i = env.begin();
-                while ( i != env.end() ) {
-                        std::list< EqvClass >::iterator next = i;
-                        next++;
-                        std::set< std::string > intersection;
-                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), std::inserter( intersection, intersection.begin() ) );
-                        if ( ! intersection.empty() ) {
-                                env.erase( i );
-                        } // if
-                        i = next;
-                } // while
-                env.insert( env.end(), eqvClass );
+                filterOverlappingClasses( env, eqvClass );
+                env.push_back( eqvClass );
+        }
+
+        void TypeEnvironment::add( EqvClass &&eqvClass ) {
+                filterOverlappingClasses( env, eqvClass );
+                env.push_back( std::move(eqvClass) );
         }