Changeset e67a82d for src/ResolvExpr/SatisfyAssertions.cpp

Timestamp:

Aug 20, 2020, 11:48:15 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

d685cb0

Parents:

67ca73e (diff), 013b028 (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:

fix conflicts

File:

• src/ResolvExpr/SatisfyAssertions.cpp (modified) (9 diffs)

src/ResolvExpr/SatisfyAssertions.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Mon Jun 10 17:45:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Mon Jun 10 17:45:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct  1 13:56:00 2019
+// Update Count     : 2
 //
 
@@ -188 +188 @@
 
                                 matches.emplace_back( 
-                                        cdata, adjType, std::move( newEnv ), std::move( newNeed ), std::move( have ), 
+                                        cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
                                         std::move( newOpen ), crntResnSlot );
                         }
@@ -229 +229 @@
                 InferMatcher( InferCache & inferred ) : inferred( inferred ) {}
 
-                const ast::Expr * postmutate( const ast::Expr * expr ) {
+                const ast::Expr * postvisit( const ast::Expr * expr ) {
                         // Skip if no slots to find
-                        if ( expr->inferred.mode != ast::Expr::InferUnion::Slots ) return expr;
-
+                        if ( !expr->inferred.hasSlots() ) return expr;
+                        // if ( expr->inferred.mode != ast::Expr::InferUnion::Slots ) return expr;
+                        std::vector<UniqueId> missingSlots;
                         // find inferred parameters for resolution slots
-                        ast::InferredParams newInferred;
+                        ast::InferredParams * newInferred = new ast::InferredParams();
                         for ( UniqueId slot : expr->inferred.resnSlots() ) {
                                 // fail if no matching assertions found
                                 auto it = inferred.find( slot );
                                 if ( it == inferred.end() ) {
-                                        assert(!"missing assertion");
+                                        std::cerr << "missing assertion " << slot << std::endl;
+                                        missingSlots.push_back(slot);
+                                        continue;
                                 }
 
@@ -245 +248 @@
                                 for ( auto & entry : it->second ) {
                                         // recurse on inferParams of resolved expressions
-                                        entry.second.expr = postmutate( entry.second.expr );
-                                        auto res = newInferred.emplace( entry );
+                                        entry.second.expr = postvisit( entry.second.expr );
+                                        auto res = newInferred->emplace( entry );
                                         assert( res.second && "all assertions newly placed" );
                                 }
@@ -252 +255 @@
 
                         ast::Expr * ret = mutate( expr );
-                        ret->inferred.set_inferParams( std::move( newInferred ) );
+                        ret->inferred.set_inferParams( newInferred );
+                        if (!missingSlots.empty()) ret->inferred.resnSlots() = missingSlots;
                         return ret;
                 }
@@ -299 +303 @@
                         Cost cost;
 
-                        OutType( 
-                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o, 
+                        OutType(
+                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o,
                                 const std::vector< DeferRef > & as, const ast::SymbolTable & symtab )
                         : env( e ), open( o ), assns( as ), cost( Cost::zero ) {
@@ -306 +310 @@
                                 for ( const DeferRef & assn : assns ) {
                                         // compute conversion cost from satisfying decl to assertion
-                                        cost += computeConversionCost( 
-                                                assn.match.adjType, assn.decl->get_type(), symtab, env );
-                                        
+                                        cost += computeConversionCost(
+                                                assn.match.adjType, assn.decl->get_type(), false, symtab, env );
+
                                         // mark vars+specialization on function-type assertions
-                                        const ast::FunctionType * func = 
+                                        const ast::FunctionType * func =
                                                 GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
                                         if ( ! func ) continue;
@@ -317 +321 @@
                                                 cost.decSpec( specCost( param->get_type() ) );
                                         }
-                                        
+
                                         cost.incVar( func->forall.size() );
-                                        
+
                                         for ( const ast::TypeDecl * td : func->forall ) {
                                                 cost.decSpec( td->assertions.size() );
@@ -329 +333 @@
                 };
 
-                CandidateEnvMerger( 
-                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open, 
+                CandidateEnvMerger(
+                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open,
                         const ast::SymbolTable & syms )
                 : crnt(), envs{ env }, opens{ open }, symtab( syms ) {}