Changeset ebc0a85

Timestamp:

May 29, 2019, 10:22:31 AM (5 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:

f57dd25

Parents:

1259c35 (diff), eba615c (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

Location:

src

Files:

• AST/Convert.cpp (modified) (4 diffs)
• ResolvExpr/ResolveAssertions.cc (modified) (3 diffs)

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu May 23 16:59:00 2019
-// Update Count     : 6
+// Last Modified On : Tue May 28 12:00:00 2019
+// Update Count     : 7
 //
 
@@ -1337 +1337 @@
                 if ( ! old ) return nullptr;
                 old->accept(*this);
-                return strict_dynamic_cast< NewT * >( node );
+                ast::Node * ret = node;
+                node = nullptr;
+                return strict_dynamic_cast< NewT * >( ret );
         }
 
@@ -1350 +1352 @@
                         a->accept( *this );
                         ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
+                        node = nullptr;
                 }
                 return ret;
@@ -1873 +1876 @@
                         GET_LABELS_V(old->labels)
                 );
+                cache.emplace( old, stmt );
+                stmt->callStmt = GET_ACCEPT_1(callStmt, Stmt);
                 this->node = stmt;
-                cache.emplace( old, this->node );
-                stmt->callStmt = GET_ACCEPT_1(callStmt, Stmt);
         }
 

src/ResolvExpr/ResolveAssertions.cc

@@ -103 +103 @@
                         OpenVarSet openVars;
                         std::vector<DeferRef> assns;
+                        Cost cost;
 
                         OutType( const TypeEnvironment& env, const OpenVarSet& openVars, 
                                 const std::vector<DeferRef>& assns )
-                        : env(env), openVars(openVars), assns(assns) {}
+                        : env(env), openVars(openVars), assns(assns), cost(Cost::infinity) {}
                 };
 
@@ -140 +141 @@
                 using Element = CandidateEnvMerger::OutType;
         private:
-                using Memo = std::unordered_map<const Element*, Cost>;
-                mutable Memo cache;              ///< cache of element costs
                 const SymTab::Indexer& indexer;  ///< Indexer for costing
 
@@ -148 +147 @@
 
                 /// reports the cost of an element
-                Cost get( const Element& x ) const {
-                        Memo::const_iterator it = cache.find( &x );
-                        if ( it == cache.end() ) {
-                                Cost k = Cost::zero;
-                                for ( const auto& assn : x.assns ) {
-                                        k += computeConversionCost( 
-                                                assn.match.adjType, assn.decl->get_type(), indexer, x.env );
-                                        
-                                        // mark vars+specialization cost on function-type assertions
-                                        PointerType* ptr = dynamic_cast< PointerType* >( assn.decl->get_type() );
-                                        if ( ! ptr ) continue;
-                                        FunctionType* func = dynamic_cast< FunctionType* >( ptr->base );
-                                        if ( ! func ) continue;
-                                        
-                                        for ( DeclarationWithType* formal : func->parameters ) {
-                                                k.decSpec( specCost( formal->get_type() ) );
-                                        }
-                                        k.incVar( func->forall.size() );
-                                        for ( TypeDecl* td : func->forall ) {
-                                                k.decSpec( td->assertions.size() );
-                                        }
-                                }
-                                it = cache.emplace_hint( it, &x, k );
+                Cost get( Element& x ) const {
+                        // check cached cost
+                        if ( x.cost != Cost::infinity ) return x.cost;
+
+                        // generate cost
+                        Cost k = Cost::zero;
+                        for ( const auto& assn : x.assns ) {
+                                k += computeConversionCost( 
+                                        assn.match.adjType, assn.decl->get_type(), indexer, x.env );
+                                
+                                // mark vars+specialization cost on function-type assertions
+                                Type* assnType = assn.match.cdata.id->get_type();
+                                FunctionType* func;
+                                if ( PointerType* ptr = dynamic_cast< PointerType* >( assnType ) ) {
+                                        func = dynamic_cast< FunctionType* >( ptr->base );
+                                } else {
+                                        func = dynamic_cast< FunctionType* >( assnType );
+                                }
+                                if ( ! func ) continue;
+                                
+                                for ( DeclarationWithType* formal : func->parameters ) {
+                                        k.decSpec( specCost( formal->get_type() ) );
+                                }
+                                k.incVar( func->forall.size() );
+                                for ( TypeDecl* td : func->forall ) {
+                                        k.decSpec( td->assertions.size() );
+                                }
                         }
-                        return it->second;
+
+                        // cache and return
+                        x.cost = k;
+                        return k;
                 }
                 
                 /// compares elements by cost
-                bool operator() ( const Element& a, const Element& b ) const {
+                bool operator() ( Element& a, Element& b ) const {
                         return get( a ) < get( b );
                 }