Changeset cde3891 for src/ResolvExpr/Alternative.h

Timestamp:

Jan 23, 2019, 4:52:16 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

a200795

Parents:

9b086ca (diff), 1d832f4 (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/Alternative.h (modified) (3 diffs)

src/ResolvExpr/Alternative.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:45:43 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:36:36 2017
-// Update Count     : 3
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Oct 11 10:55:00 2018
+// Update Count     : 4
 //
 
@@ -20 +20 @@
 
 #include "Cost.h"             // for Cost
-#include "TypeEnvironment.h"  // for TypeEnvironment
+#include "TypeEnvironment.h"  // for TypeEnvironment, AssertionSetValue
+
+#include "Common/utility.h"   // for maybeClone
 
 class Expression;
 
 namespace ResolvExpr {
+        /// One assertion to resolve
+        struct AssertionItem {
+                DeclarationWithType* decl;
+                AssertionSetValue info;
+                
+                AssertionItem() = default;
+                AssertionItem( DeclarationWithType* decl, const AssertionSetValue& info ) 
+                : decl(decl), info(info) {}
+                AssertionItem( const AssertionSet::value_type& e ) : decl(e.first), info(e.second) {}
+                operator AssertionSet::value_type () const { return { decl, info }; }
+
+                // to support cloneAll
+                AssertionItem clone() const { return { maybeClone(decl), info }; }
+        };
+        /// A list of unresolved assertions
+        using AssertionList = std::vector<AssertionItem>;
+
+        /// Clones an assertion list into an assertion set
+        static inline void cloneAll( const AssertionList& src, AssertionSet& dst ) {
+                for ( const AssertionItem& item : src ) {
+                        dst.emplace( maybeClone(item.decl), item.info );
+                }
+        }
+
+        /// Clones an assertion set into an assertion list
+        static inline void cloneAll( const AssertionSet& src, AssertionList& dst ) {
+                dst.reserve( dst.size() + src.size() );
+                for ( const auto& entry : src ) {
+                        dst.emplace_back( maybeClone(entry.first), entry.second );
+                }
+        }
+
+        /// Clones an assertion list into an assertion list
+        static inline void cloneAll( const AssertionList& src, AssertionList& dst ) {
+                dst.reserve( dst.size() + src.size() );
+                for ( const AssertionItem& item : src ) {
+                        dst.emplace_back( maybeClone(item.decl), item.info );
+                }
+        }
+
+        /// One option for resolution of an expression
         struct Alternative {
                 Alternative();
-                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost );
-                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost, const Cost &cvtCost );
+                Alternative( Expression *expr, const TypeEnvironment &env );
+                Alternative( const Alternative &o, Expression *expr, const Cost &cost );
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet& openVars, 
+                        const AssertionList& need, const Cost &cost );
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet& openVars, 
+                        const AssertionList& need, const Cost &cost, const Cost &cvtCost );
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet &openVars, 
+                        const AssertionSet &need, const Cost &cost);
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet &openVars, 
+                        const AssertionSet &need, const Cost &cost, const Cost& cvtCost );
+                Alternative( Expression *expr, TypeEnvironment &&env, OpenVarSet &&openVars, 
+                        AssertionSet &&need, const Cost &cost );
+                Alternative( Expression *expr, TypeEnvironment &&env, OpenVarSet &&openVars, 
+                        AssertionSet &&need, const Cost &cost, const Cost &cvtCost );
                 Alternative( const Alternative &other );
                 Alternative &operator=( const Alternative &other );
@@ -44 +99 @@
                 }
 
-                Cost cost;
-                Cost cvtCost;
-                Expression *expr;
-                TypeEnvironment env;
+                /// Sorts by cost
+                bool operator< ( const Alternative& o ) const { return cost < o.cost; }
+
+                Cost cost;            ///< Cost of the whole expression
+                Cost cvtCost;         ///< Cost of conversions to the satisfying expression
+                Expression *expr;     ///< Satisfying expression
+                TypeEnvironment env;  ///< Containing type environment
+                OpenVarSet openVars;  ///< Open variables for environment
+                AssertionList need;   ///< Assertions which need to be resolved
         };