source: src/ResolvExpr/ResolveAssertions.cc@ aba20d2

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since aba20d2 was 462a7c7, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

Removed non-moving assignment on ParamEntry to help debugging
  • Property mode set to 100644
File size: 16.5 KB
RevLine 
[6d6e829]1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// ResolveAssertions.cc --
8//
9// Author : Aaron B. Moss
10// Created On : Fri Oct 05 13:46:00 2018
11// Last Modified By : Aaron B. Moss
12// Last Modified On : Fri Oct 05 13:46:00 2018
13// Update Count : 1
14//
15
16#include "ResolveAssertions.h"
17
[b3bd772]18#include <algorithm> // for sort
[83ab931]19#include <cassert> // for assertf
20#include <list> // for list
[b3bd772]21#include <memory> // for unique_ptr
[4d2d45f9]22#include <sstream> // for ostringstream
23#include <string> // for string
[83ab931]24#include <unordered_map> // for unordered_map, unordered_multimap
25#include <utility> // for move
26#include <vector> // for vector
27
28#include "Alternative.h" // for Alternative, AssertionItem, AssertionList
29#include "Common/FilterCombos.h" // for filterCombos
[4d2d45f9]30#include "Common/Indenter.h" // for Indenter
[83ab931]31#include "Common/utility.h" // for sort_mins
[d76c588]32#include "GenPoly/GenPoly.h" // for getFunctionType
[83ab931]33#include "ResolvExpr/RenameVars.h" // for renameTyVars
34#include "SymTab/Indexer.h" // for Indexer
[b3bd772]35#include "SymTab/Mangler.h" // for Mangler
[83ab931]36#include "SynTree/Expression.h" // for InferredParams
37#include "TypeEnvironment.h" // for TypeEnvironment, etc.
[052cd71]38#include "typeops.h" // for adjustExprType, specCost
[83ab931]39#include "Unify.h" // for unify
[6d6e829]40
41namespace ResolvExpr {
42 /// Unified assertion candidate
43 struct AssnCandidate {
44 SymTab::Indexer::IdData cdata; ///< Satisfying declaration
45 Type* adjType; ///< Satisfying type
46 TypeEnvironment env; ///< Post-unification environment
47 AssertionSet have; ///< Post-unification have-set
48 AssertionSet need; ///< Post-unification need-set
49 OpenVarSet openVars; ///< Post-unification open-var set
[0b00df0]50 UniqueId resnSlot; ///< Slot for any recursive assertion IDs
[6d6e829]51
[aaeacf4]52 AssnCandidate( const SymTab::Indexer::IdData& cdata, Type* adjType, TypeEnvironment&& env,
53 AssertionSet&& have, AssertionSet&& need, OpenVarSet&& openVars, UniqueId resnSlot )
54 : cdata(cdata), adjType(adjType), env(std::move(env)), have(std::move(have)),
[0b00df0]55 need(std::move(need)), openVars(std::move(openVars)), resnSlot(resnSlot) {}
[6d6e829]56 };
57
58 /// List of candidate assertion resolutions
59 using CandidateList = std::vector<AssnCandidate>;
60
61 /// Reference to single deferred item
62 struct DeferRef {
[052cd71]63 const DeclarationWithType* decl;
64 const AssertionSetValue& info;
[6d6e829]65 const AssnCandidate& match;
66 };
67
68 /// Wrapper for the deferred items from a single assertion resolution.
69 /// Acts like indexed list of DeferRef
70 struct DeferItem {
[052cd71]71 const DeclarationWithType* decl;
72 const AssertionSetValue& info;
73 CandidateList matches;
[6d6e829]74
[052cd71]75 DeferItem( DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
76 : decl(decl), info(info), matches(std::move(matches)) {}
[6d6e829]77
[052cd71]78 bool empty() const { return matches.empty(); }
[6d6e829]79
[052cd71]80 CandidateList::size_type size() const { return matches.size(); }
[4d2d45f9]81
[052cd71]82 DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
[6d6e829]83 };
84
85 /// List of deferred resolution items
86 using DeferList = std::vector<DeferItem>;
87
[aaeacf4]88 /// Combo iterator that combines candidates into an output list, merging their environments.
[6d6e829]89 /// Rejects an appended candidate if the environments cannot be merged.
90 class CandidateEnvMerger {
91 /// Current list of merged candidates
92 std::vector<DeferRef> crnt;
93 /// Stack of environments to support backtracking
94 std::vector<TypeEnvironment> envs;
95 /// Stack of open variables to support backtracking
96 std::vector<OpenVarSet> varSets;
97 /// Indexer to use for merges
98 const SymTab::Indexer& indexer;
[aaeacf4]99
[6d6e829]100 public:
101 /// The merged environment/open variables and the list of candidates
102 struct OutType {
103 TypeEnvironment env;
104 OpenVarSet openVars;
105 std::vector<DeferRef> assns;
[c519942]106 Cost cost;
[6d6e829]107
[aaeacf4]108 OutType( const TypeEnvironment& env, const OpenVarSet& openVars,
[6d6e829]109 const std::vector<DeferRef>& assns )
[c519942]110 : env(env), openVars(openVars), assns(assns), cost(Cost::infinity) {}
[6d6e829]111 };
112
[aaeacf4]113 CandidateEnvMerger( const TypeEnvironment& env, const OpenVarSet& openVars,
[6d6e829]114 const SymTab::Indexer& indexer )
115 : crnt(), envs{ env }, varSets{ openVars }, indexer(indexer) {}
116
117 bool append( DeferRef i ) {
118 TypeEnvironment env = envs.back();
119 OpenVarSet openVars = varSets.back();
120 mergeOpenVars( openVars, i.match.openVars );
121
122 if ( ! env.combine( i.match.env, openVars, indexer ) ) return false;
123
124 crnt.emplace_back( i );
125 envs.emplace_back( env );
126 varSets.emplace_back( openVars );
127 return true;
128 }
129
130 void backtrack() {
131 crnt.pop_back();
132 envs.pop_back();
133 varSets.pop_back();
134 }
135
136 OutType finalize() { return { envs.back(), varSets.back(), crnt }; }
137 };
138
[aaeacf4]139 /// Comparator for CandidateEnvMerger outputs that sums their costs and caches the stored
[fbecee5]140 /// sums
141 struct CandidateCost {
142 using Element = CandidateEnvMerger::OutType;
143 private:
144 const SymTab::Indexer& indexer; ///< Indexer for costing
145
146 public:
147 CandidateCost( const SymTab::Indexer& indexer ) : indexer(indexer) {}
148
149 /// reports the cost of an element
[c519942]150 Cost get( Element& x ) const {
151 // check cached cost
152 if ( x.cost != Cost::infinity ) return x.cost;
153
154 // generate cost
155 Cost k = Cost::zero;
156 for ( const auto& assn : x.assns ) {
[d76c588]157 // compute conversion cost from satisfying decl to assertion
[aaeacf4]158 k += computeConversionCost(
[c519942]159 assn.match.adjType, assn.decl->get_type(), indexer, x.env );
[aaeacf4]160
[c519942]161 // mark vars+specialization cost on function-type assertions
[d76c588]162 FunctionType* func = GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
[c519942]163 if ( ! func ) continue;
[aaeacf4]164
[c519942]165 for ( DeclarationWithType* formal : func->parameters ) {
166 k.decSpec( specCost( formal->get_type() ) );
167 }
168 k.incVar( func->forall.size() );
169 for ( TypeDecl* td : func->forall ) {
170 k.decSpec( td->assertions.size() );
[fbecee5]171 }
172 }
[c519942]173
174 // cache and return
175 x.cost = k;
176 return k;
[fbecee5]177 }
[aaeacf4]178
[fbecee5]179 /// compares elements by cost
[c519942]180 bool operator() ( Element& a, Element& b ) const {
[fbecee5]181 return get( a ) < get( b );
182 }
183 };
184
[0b00df0]185 /// Set of assertion resolutions, grouped by resolution ID
186 using InferCache = std::unordered_map< UniqueId, InferredParams >;
187
[6d6e829]188 /// Flag for state iteration
189 enum IterateFlag { IterateState };
190
191 /// State needed to resolve a set of assertions
192 struct ResnState {
[0b00df0]193 Alternative alt; ///< Alternative assertion is rooted on
194 AssertionList need; ///< Assertions to find
195 AssertionSet newNeed; ///< New assertions for current resolutions
196 DeferList deferred; ///< Deferred matches
197 InferCache inferred; ///< Cache of already-inferred parameters
198 SymTab::Indexer& indexer; ///< Name lookup (depends on previous assertions)
[6d6e829]199
200 /// Initial resolution state for an alternative
201 ResnState( Alternative& a, SymTab::Indexer& indexer )
[0b00df0]202 : alt(a), need(), newNeed(), deferred(), inferred(), indexer(indexer) {
[6d6e829]203 need.swap( a.need );
204 }
205
206 /// Updated resolution state with new need-list
207 ResnState( ResnState&& o, IterateFlag )
[aaeacf4]208 : alt(std::move(o.alt)), need(o.newNeed.begin(), o.newNeed.end()), newNeed(), deferred(),
[0b00df0]209 inferred(std::move(o.inferred)), indexer(o.indexer) {}
[6d6e829]210 };
211
212 /// Binds a single assertion, updating resolution state
[aaeacf4]213 void bindAssertion( const DeclarationWithType* decl, AssertionSetValue info, Alternative& alt,
[0b00df0]214 AssnCandidate& match, InferCache& inferred ) {
[aaeacf4]215
[6d6e829]216 DeclarationWithType* candidate = match.cdata.id;
217 assertf( candidate->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
218
219 Expression* varExpr = match.cdata.combine( alt.cvtCost );
[2c187378]220 delete varExpr->result;
221 varExpr->result = match.adjType->clone();
[0b00df0]222 if ( match.resnSlot ) { varExpr->resnSlots.push_back( match.resnSlot ); }
[6d6e829]223
[0b00df0]224 // place newly-inferred assertion in proper place in cache
225 inferred[ info.resnSlot ][ decl->get_uniqueId() ] = ParamEntry{
[aaeacf4]226 candidate->get_uniqueId(), candidate->clone(), match.adjType->clone(), decl->get_type()->clone(),
[9aaacc27]227 varExpr };
[6d6e829]228 }
229
230 /// Adds a captured assertion to the symbol table
231 void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
[e1f7eef]232 for ( auto& i : assertSet ) {
233 if ( i.second.isUsed ) {
234 indexer.addId( i.first );
[6d6e829]235 }
236 }
237 }
238
[0b00df0]239 // in AlternativeFinder.cc; unique ID for assertion resolutions
240 extern UniqueId globalResnSlot;
241
[6d6e829]242 /// Resolve a single assertion, in context
[052cd71]243 bool resolveAssertion( AssertionItem& assn, ResnState& resn ) {
[6d6e829]244 // skip unused assertions
245 if ( ! assn.info.isUsed ) return true;
246
[052cd71]247 // lookup candidates for this assertion
248 std::list< SymTab::Indexer::IdData > candidates;
249 resn.indexer.lookupId( assn.decl->name, candidates );
250
251 // find the candidates that unify with the desired type
252 CandidateList matches;
253 for ( const auto& cdata : candidates ) {
254 DeclarationWithType* candidate = cdata.id;
255
256 // build independent unification context for candidate
257 AssertionSet have, newNeed;
258 TypeEnvironment newEnv{ resn.alt.env };
259 OpenVarSet newOpenVars{ resn.alt.openVars };
260 Type* adjType = candidate->get_type()->clone();
261 adjustExprType( adjType, newEnv, resn.indexer );
262 renameTyVars( adjType );
263
264 // keep unifying candidates
[aaeacf4]265 if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars,
[052cd71]266 resn.indexer ) ) {
267 // set up binding slot for recursive assertions
268 UniqueId crntResnSlot = 0;
269 if ( ! newNeed.empty() ) {
270 crntResnSlot = ++globalResnSlot;
271 for ( auto& a : newNeed ) {
272 a.second.resnSlot = crntResnSlot;
[0b00df0]273 }
[2fd9f24]274 }
[e1f7eef]275
[aaeacf4]276 matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have),
[052cd71]277 std::move(newNeed), std::move(newOpenVars), crntResnSlot );
278 } else {
279 delete adjType;
280 }
[6d6e829]281 }
282
283 // break if no suitable assertion
284 if ( matches.empty() ) return false;
285
286 // defer if too many suitable assertions
287 if ( matches.size() > 1 ) {
[052cd71]288 resn.deferred.emplace_back( assn.decl, assn.info, std::move(matches) );
[6d6e829]289 return true;
290 }
291
292 // otherwise bind current match in ongoing scope
293 AssnCandidate& match = matches.front();
294 addToIndexer( match.have, resn.indexer );
295 resn.newNeed.insert( match.need.begin(), match.need.end() );
[052cd71]296 resn.alt.env = std::move(match.env);
297 resn.alt.openVars = std::move(match.openVars);
[6d6e829]298
[0b00df0]299 bindAssertion( assn.decl, assn.info, resn.alt, match, resn.inferred );
[6d6e829]300 return true;
301 }
302
[0b00df0]303 /// Associates inferred parameters with an expression
304 struct InferMatcher {
305 InferCache& inferred;
306
307 InferMatcher( InferCache& inferred ) : inferred( inferred ) {}
308
309 Expression* postmutate( Expression* expr ) {
[40290497]310 // defer missing inferred parameters until they are hopefully found later
311 std::vector<UniqueId> missingSlots;
[0b00df0]312 // place inferred parameters into resolution slots
313 for ( UniqueId slot : expr->resnSlots ) {
314 // fail if no matching parameters found
[40290497]315 auto it = inferred.find( slot );
316 if ( it == inferred.end() ) {
317 missingSlots.push_back( slot );
318 continue;
319 }
320 InferredParams& inferParams = it->second;
[aaeacf4]321
[0b00df0]322 // place inferred parameters into proper place in expression
323 for ( auto& entry : inferParams ) {
324 // recurse on inferParams of resolved expressions
325 entry.second.expr = postmutate( entry.second.expr );
326 // xxx - look at entry.second.inferParams?
[462a7c7]327 auto res = expr->inferParams.emplace( entry.first, entry.second );
328 assert(res.second);
[0b00df0]329 }
330 }
331
332 // clear resolution slots and return
[40290497]333 expr->resnSlots.swap( missingSlots );
[0b00df0]334 return expr;
335 }
336 };
337
338 void finalizeAssertions( Alternative& alt, InferCache& inferred, AltList& out ) {
339 PassVisitor<InferMatcher> matcher{ inferred };
340 alt.expr = alt.expr->acceptMutator( matcher );
341 out.emplace_back( alt );
342 }
343
344 /// Limit to depth of recursion of assertion satisfaction
[d3b2c32a]345 static const int recursionLimit = 4;
346 /// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
347 static const int deferLimit = 10;
[6d6e829]348
[4d2d45f9]349 void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors ) {
[6d6e829]350 // finish early if no assertions to resolve
351 if ( alt.need.empty() ) {
352 out.emplace_back( alt );
353 return;
354 }
355
356 // build list of possible resolutions
357 using ResnList = std::vector<ResnState>;
358 SymTab::Indexer root_indexer{ indexer };
359 ResnList resns{ ResnState{ alt, root_indexer } };
360 ResnList new_resns{};
361
362 // resolve assertions in breadth-first-order up to a limited number of levels deep
363 for ( unsigned level = 0; level < recursionLimit; ++level ) {
364 // scan over all mutually-compatible resolutions
365 for ( auto& resn : resns ) {
366 // make initial pass at matching assertions
367 for ( auto& assn : resn.need ) {
368 // fail early if any assertion is not resolvable
[052cd71]369 if ( ! resolveAssertion( assn, resn ) ) {
[99d4584]370 Indenter tabs{ 3 };
[4d2d45f9]371 std::ostringstream ss;
372 ss << tabs << "Unsatisfiable alternative:\n";
373 resn.alt.print( ss, ++tabs );
[d3b2c32a]374 ss << (tabs-1) << "Could not satisfy assertion:\n";
375 assn.decl->print( ss, tabs );
[aaeacf4]376
[4d2d45f9]377 errors.emplace_back( ss.str() );
378 goto nextResn;
379 }
[6d6e829]380 }
381
382 if ( resn.deferred.empty() ) {
383 // either add successful match or push back next state
384 if ( resn.newNeed.empty() ) {
[0b00df0]385 finalizeAssertions( resn.alt, resn.inferred, out );
[6d6e829]386 } else {
387 new_resns.emplace_back( std::move(resn), IterateState );
388 }
[d3b2c32a]389 } else if ( resn.deferred.size() > deferLimit ) {
390 // too many deferred assertions to attempt mutual compatibility
391 Indenter tabs{ 3 };
392 std::ostringstream ss;
393 ss << tabs << "Unsatisfiable alternative:\n";
394 resn.alt.print( ss, ++tabs );
395 ss << (tabs-1) << "Too many non-unique satisfying assignments for "
396 "assertions:\n";
397 for ( const auto& d : resn.deferred ) {
398 d.decl->print( ss, tabs );
399 }
400
401 errors.emplace_back( ss.str() );
402 goto nextResn;
[6d6e829]403 } else {
[b3bd772]404 // resolve deferred assertions by mutual compatibility
[6d6e829]405 std::vector<CandidateEnvMerger::OutType> compatible = filterCombos(
[aaeacf4]406 resn.deferred,
[6d6e829]407 CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
[4d2d45f9]408 // fail early if no mutually-compatible assertion satisfaction
409 if ( compatible.empty() ) {
[99d4584]410 Indenter tabs{ 3 };
[4d2d45f9]411 std::ostringstream ss;
412 ss << tabs << "Unsatisfiable alternative:\n";
413 resn.alt.print( ss, ++tabs );
[d3b2c32a]414 ss << (tabs-1) << "No mutually-compatible satisfaction for assertions:\n";
[4d2d45f9]415 for ( const auto& d : resn.deferred ) {
[052cd71]416 d.decl->print( ss, tabs );
[4d2d45f9]417 }
418
419 errors.emplace_back( ss.str() );
420 goto nextResn;
421 }
[b3bd772]422 // sort by cost
423 CandidateCost coster{ resn.indexer };
424 std::sort( compatible.begin(), compatible.end(), coster );
425
426 // keep map of detected options
427 std::unordered_map<std::string, Cost> found;
428 for ( auto& compat : compatible ) {
429 // filter by environment-adjusted result type, keep only cheapest option
430 Type* resType = alt.expr->result->clone();
431 compat.env.apply( resType );
432 // skip if cheaper alternative already processed with same result type
433 Cost resCost = coster.get( compat );
434 auto it = found.emplace( SymTab::Mangler::mangleType( resType ), resCost );
[aeb8f70]435 delete resType;
[b3bd772]436 if ( it.second == false && it.first->second < resCost ) continue;
437
438 // proceed with resolution step
[6d6e829]439 ResnState new_resn = resn;
440
441 // add compatible assertions to new resolution state
442 for ( DeferRef r : compat.assns ) {
443 AssnCandidate match = r.match;
444 addToIndexer( match.have, new_resn.indexer );
445 new_resn.newNeed.insert( match.need.begin(), match.need.end() );
446
[052cd71]447 bindAssertion( r.decl, r.info, new_resn.alt, match, new_resn.inferred );
[6d6e829]448 }
449
450 // set mutual environment into resolution state
451 new_resn.alt.env = std::move(compat.env);
452 new_resn.alt.openVars = std::move(compat.openVars);
453
454 // either add sucessful match or push back next state
455 if ( new_resn.newNeed.empty() ) {
[0b00df0]456 finalizeAssertions( new_resn.alt, new_resn.inferred, out );
[6d6e829]457 } else {
458 new_resns.emplace_back( std::move(new_resn), IterateState );
459 }
460 }
461 }
462 nextResn:; }
463
464 // finish or reset for next round
465 if ( new_resns.empty() ) return;
466 resns.swap( new_resns );
467 new_resns.clear();
468 }
[aaeacf4]469
[6d6e829]470 // exceeded recursion limit if reaches here
471 if ( out.empty() ) {
472 SemanticError( alt.expr->location, "Too many recursive assertions" );
473 }
474 }
475} // namespace ResolvExpr
476
477// Local Variables: //
478// tab-width: 4 //
479// mode: c++ //
480// compile-command: "make install" //
481// End: //
Note: See TracBrowser for help on using the repository browser.