Changeset 90152a4 for src/ResolvExpr/TypeEnvironment.h

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

File:

• src/ResolvExpr/TypeEnvironment.h (modified) (6 diffs)

src/ResolvExpr/TypeEnvironment.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:24:58 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:35:45 2017
-// Update Count     : 3
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Mon Jun 18 11:58:00 2018
+// Update Count     : 4
 //
 
@@ -21 +21 @@
 #include <set>                         // for set
 #include <string>                      // for string
+#include <utility>                     // for move, swap
+
+#include "WidenMode.h"                 // for WidenMode
 
 #include "SynTree/Declaration.h"       // for TypeDecl::Data, DeclarationWit...
@@ -37 +40 @@
         //
         // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this comparator.
+        //
+        // Note: since this compares pointers for position, minor changes in the source file that affect
+        // memory layout can alter compilation time in unpredictable ways. For example, the placement
+        // of a line directive can reorder type pointers with respect to each other so that assertions
+        // are seen in different orders, causing a potentially different number of unification calls when
+        // resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering line directives
+        // alone, so it would be nice to fix this comparison so that assertions compare more consistently.
+        // I've tried to modify this to compare on mangle name instead of type as the second comparator, but
+        // this causes some assertions to never be recorded. More investigation is needed.
         struct AssertCompare {
                 bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
@@ -64 +76 @@
 
                 void initialize( const EqvClass &src, EqvClass &dest );
+                void initialize( const EqvClass &src, EqvClass &dest, const Type *ty );
                 EqvClass();
                 EqvClass( const EqvClass &other );
+                EqvClass( const EqvClass &other, const Type *ty );
+                EqvClass( EqvClass &&other );
                 EqvClass &operator=( const EqvClass &other );
+                EqvClass &operator=( EqvClass &&other );
                 ~EqvClass();
                 void print( std::ostream &os, Indenter indent = {} ) const;
+
+                /// Takes ownership of `ty`, freeing old `type`
+                void set_type(Type* ty);
         };
 
         class TypeEnvironment {
           public:
-                bool lookup( const std::string &var, EqvClass &eqvClass ) const;
-                void add( const EqvClass &eqvClass );
+                const EqvClass* lookup( const std::string &var ) const;
+          private:
+                void add( EqvClass &&eqvClass  );
+          public:
                 void add( const Type::ForallList &tyDecls );
+                void add( const TypeSubstitution & sub );
                 template< typename SynTreeClass > int apply( SynTreeClass *&type ) const;
                 template< typename SynTreeClass > int applyFree( SynTreeClass *&type ) const;
@@ -81 +103 @@
                 bool isEmpty() const { return env.empty(); }
                 void print( std::ostream &os, Indenter indent = {} ) const;
-                void combine( const TypeEnvironment &second, Type *(*combineFunc)( Type*, Type* ) );
+                // void combine( const TypeEnvironment &second, Type *(*combineFunc)( Type*, Type* ) );
                 void simpleCombine( const TypeEnvironment &second );
                 void extractOpenVars( OpenVarSet &openVars ) const;
@@ -90 +112 @@
                 void addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars );
 
-                typedef std::list< EqvClass >::iterator iterator;
-                iterator begin() { return env.begin(); }
-                iterator end() { return env.end(); }
-                typedef std::list< EqvClass >::const_iterator const_iterator;
-                const_iterator begin() const { return env.begin(); }
-                const_iterator end() const { return env.end(); }
+                /// Binds the type class represented by `typeInst` to the type `bindTo`; will add 
+                /// the class if needed. Returns false on failure.
+                bool bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+                
+                /// Binds the type classes represented by `var1` and `var2` together; will add 
+                /// one or both classes if needed. Returns false on failure.
+                bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+
+                /// Disallows widening for all bindings in the environment
+                void forbidWidening();
+
+                using iterator = std::list< EqvClass >::const_iterator;
+                iterator begin() const { return env.begin(); }
+                iterator end() const { return env.end(); }
+
           private:
                 std::list< EqvClass > env;
+                
                 std::list< EqvClass >::iterator internal_lookup( const std::string &var );
         };