Context Navigation

source: src/ResolvExpr/ResolveAssertions.cc @ edf3ff1

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since edf3ff1 was 2fb35df, checked in by Fangren Yu <f37yu@…>, 4 years ago
exclude deleted declarations for assertion matching
Property mode set to `100644`
File size: 18.3 KB

Line
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 : Andrew Beach
12	// Last Modified On : Thu Aug 8 16:47:00 2019
13	// Update Count : 3
14	//
15
16	#include "ResolveAssertions.h"
17
18	#include <algorithm> // for sort
19	#include <cassert> // for assertf
20	#include <list> // for list
21	#include <memory> // for unique_ptr
22	#include <sstream> // for ostringstream
23	#include <string> // for string
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
30	#include "Common/Indenter.h" // for Indenter
31	#include "Common/utility.h" // for sort_mins
32	#include "GenPoly/GenPoly.h" // for getFunctionType
33	#include "ResolvExpr/RenameVars.h" // for renameTyVars
34	#include "SymTab/Indexer.h" // for Indexer
35	#include "SymTab/Mangler.h" // for Mangler
36	#include "SynTree/Expression.h" // for InferredParams
37	#include "TypeEnvironment.h" // for TypeEnvironment, etc.
38	#include "typeops.h" // for adjustExprType, specCost
39	#include "Unify.h" // for unify
40
41	namespace 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
50	UniqueId resnSlot; ///< Slot for any recursive assertion IDs
51
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)),
55	need(std::move(need)), openVars(std::move(openVars)), resnSlot(resnSlot) {}
56	};
57
58	/// List of candidate assertion resolutions
59	using CandidateList = std::vector<AssnCandidate>;
60
61	/// Reference to single deferred item
62	struct DeferRef {
63	const DeclarationWithType* decl;
64	const AssertionSetValue& info;
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 {
71	const DeclarationWithType* decl;
72	const AssertionSetValue& info;
73	CandidateList matches;
74
75	DeferItem( const DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
76	: decl(decl), info(info), matches(std::move(matches)) {}
77
78	bool empty() const { return matches.empty(); }
79
80	CandidateList::size_type size() const { return matches.size(); }
81
82	DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
83	};
84
85	/// List of deferred resolution items
86	using DeferList = std::vector<DeferItem>;
87
88	/// Combo iterator that combines candidates into an output list, merging their environments.
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;
99
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;
106	Cost cost;
107
108	OutType( const TypeEnvironment& env, const OpenVarSet& openVars,
109	const std::vector<DeferRef>& assns )
110	: env(env), openVars(openVars), assns(assns), cost(Cost::infinity) {}
111	};
112
113	CandidateEnvMerger( const TypeEnvironment& env, const OpenVarSet& openVars,
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
139	/// Comparator for CandidateEnvMerger outputs that sums their costs and caches the stored
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
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 ) {
157	// compute conversion cost from satisfying decl to assertion
158	k += computeConversionCost(
159	assn.match.adjType, assn.decl->get_type(), false, indexer, x.env );
160
161	// mark vars+specialization cost on function-type assertions
162	FunctionType* func = GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
163	if ( ! func ) continue;
164
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() );
171	}
172	}
173
174	// cache and return
175	x.cost = k;
176	return k;
177	}
178
179	/// compares elements by cost
180	bool operator() ( Element& a, Element& b ) const {
181	return get( a ) < get( b );
182	}
183	};
184
185	/// Set of assertion resolutions, grouped by resolution ID
186	using InferCache = std::unordered_map< UniqueId, InferredParams >;
187
188	/// Lexicographically-ordered vector of costs
189	using CostVec = std::vector< Cost >;
190
191	int compare( const CostVec & a, const CostVec & b ) {
192	unsigned i = 0;
193	do {
194	// lex-compare where shorter one is less
195	if ( i == a.size() ) {
196	return i == b.size() ? 0 : -1;
197	}
198	if ( i == b.size() /* && i < a.size() */ ) return 1;
199
200	int c = a[i].compare( b[i] );
201	if ( c != 0 ) return c;
202	} while ( ++i );
203	assert(!"unreachable");
204	}
205
206	bool operator< ( const CostVec & a, const CostVec & b ) { return compare( a, b ) < 0; }
207
208	/// Flag for state iteration
209	enum IterateFlag { IterateState };
210
211	/// State needed to resolve a set of assertions
212	struct ResnState {
213	Alternative alt; ///< Alternative assertion is rooted on
214	AssertionList need; ///< Assertions to find
215	AssertionSet newNeed; ///< New assertions for current resolutions
216	DeferList deferred; ///< Deferred matches
217	InferCache inferred; ///< Cache of already-inferred parameters
218	CostVec costs; ///< Costs of recursive assertion satisfaction for disambiguation
219	SymTab::Indexer& indexer; ///< Name lookup (depends on previous assertions)
220
221	/// Initial resolution state for an alternative
222	ResnState( Alternative & a, SymTab::Indexer & indexer )
223	: alt(a), need(), newNeed(), deferred(), inferred(), costs{ Cost::zero }, indexer(indexer) {
224	need.swap( a.need );
225	}
226
227	/// Updated resolution state with new need-list
228	ResnState( ResnState && o, IterateFlag )
229	: alt(std::move(o.alt)), need(o.newNeed.begin(), o.newNeed.end()), newNeed(), deferred(),
230	inferred(std::move(o.inferred)), costs(o.costs), indexer(o.indexer) {
231	costs.emplace_back( Cost::zero );
232	}
233	};
234
235	/// Binds a single assertion, updating resolution state
236	void bindAssertion( const DeclarationWithType * decl, AssertionSetValue info, Alternative & alt,
237	AssnCandidate & match, InferCache & inferred ) {
238
239	const DeclarationWithType * candidate = match.cdata.id;
240	assertf( candidate->uniqueId, "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
241
242	Expression * varExpr = match.cdata.combine( alt.cvtCost );
243	delete varExpr->result;
244	varExpr->result = match.adjType->clone();
245	if ( match.resnSlot ) { varExpr->resnSlots.push_back( match.resnSlot ); }
246
247	// place newly-inferred assertion in proper place in cache
248	inferred[ info.resnSlot ][ decl->get_uniqueId() ] = ParamEntry{
249	candidate->uniqueId, candidate->clone(), match.adjType->clone(), decl->get_type()->clone(),
250	varExpr };
251	}
252
253	/// Adds a captured assertion to the symbol table
254	void addToIndexer( AssertionSet & assertSet, SymTab::Indexer & indexer ) {
255	for ( auto& i : assertSet ) {
256	if ( i.second.isUsed ) {
257	indexer.addId( i.first );
258	}
259	}
260	}
261
262	// in AlternativeFinder.cc; unique ID for assertion resolutions
263	extern UniqueId globalResnSlot;
264
265	/// Resolve a single assertion, in context
266	bool resolveAssertion( AssertionItem & assn, ResnState & resn ) {
267	// skip unused assertions
268	if ( ! assn.info.isUsed ) return true;
269
270	// lookup candidates for this assertion
271	std::list< SymTab::Indexer::IdData > candidates;
272	resn.indexer.lookupId( assn.decl->name, candidates );
273
274	// find the candidates that unify with the desired type
275	CandidateList matches;
276	for ( const auto & cdata : candidates ) {
277	const DeclarationWithType * candidate = cdata.id;
278
279	// ignore deleted candidates.
280	// NOTE: this behavior is different from main resolver.
281	// further investigations might be needed to determine
282	// if we should implement the same rule here
283	// (i.e. error if unique best match is deleted)
284	if (candidate->isDeleted) continue;
285
286	// build independent unification context. for candidate
287	AssertionSet have, newNeed;
288	TypeEnvironment newEnv{ resn.alt.env };
289	OpenVarSet newOpenVars{ resn.alt.openVars };
290	Type * adjType = candidate->get_type()->clone();
291	adjustExprType( adjType, newEnv, resn.indexer );
292	renameTyVars( adjType );
293
294	// keep unifying candidates
295	if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars,
296	resn.indexer ) ) {
297	// set up binding slot for recursive assertions
298	UniqueId crntResnSlot = 0;
299	if ( ! newNeed.empty() ) {
300	crntResnSlot = ++globalResnSlot;
301	for ( auto& a : newNeed ) {
302	a.second.resnSlot = crntResnSlot;
303	}
304	}
305
306	matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have),
307	std::move(newNeed), std::move(newOpenVars), crntResnSlot );
308	} else {
309	delete adjType;
310	}
311	}
312
313	// break if no suitable assertion
314	if ( matches.empty() ) return false;
315
316	// defer if too many suitable assertions
317	if ( matches.size() > 1 ) {
318	resn.deferred.emplace_back( assn.decl, assn.info, std::move(matches) );
319	return true;
320	}
321
322	// otherwise bind current match in ongoing scope
323	AssnCandidate& match = matches.front();
324	addToIndexer( match.have, resn.indexer );
325	resn.newNeed.insert( match.need.begin(), match.need.end() );
326	resn.alt.env = std::move(match.env);
327	resn.alt.openVars = std::move(match.openVars);
328
329	bindAssertion( assn.decl, assn.info, resn.alt, match, resn.inferred );
330	return true;
331	}
332
333	/// Associates inferred parameters with an expression
334	struct InferMatcher {
335	InferCache& inferred;
336
337	InferMatcher( InferCache& inferred ) : inferred( inferred ) {}
338
339	Expression* postmutate( Expression* expr ) {
340	// defer missing inferred parameters until they are hopefully found later
341	std::vector<UniqueId> missingSlots;
342	// place inferred parameters into resolution slots
343	for ( UniqueId slot : expr->resnSlots ) {
344	// fail if no matching parameters found
345	auto it = inferred.find( slot );
346	if ( it == inferred.end() ) {
347	missingSlots.push_back( slot );
348	continue;
349	}
350	InferredParams& inferParams = it->second;
351
352	// place inferred parameters into proper place in expression
353	for ( auto& entry : inferParams ) {
354	// recurse on inferParams of resolved expressions
355	entry.second.expr = postmutate( entry.second.expr );
356	// xxx - look at entry.second.inferParams?
357	auto res = expr->inferParams.emplace( entry.first, entry.second );
358	assert(res.second);
359	}
360	}
361
362	// clear resolution slots and return
363	expr->resnSlots.swap( missingSlots );
364	return expr;
365	}
366	};
367
368	/// Map of alternative return types to recursive assertion satisfaction costs
369	using PruneMap = std::unordered_map<std::string, CostVec>;
370
371	/// Gets the pruning key for an alternative
372	std::string pruneKey( const Alternative & alt ) {
373	Type* resType = alt.expr->result->clone();
374	alt.env.apply( resType );
375	std::string resKey = SymTab::Mangler::mangleType( resType );
376	delete resType;
377	return resKey;
378	}
379
380	/// Replace resnSlots with inferParams and add alternative to output list, if meets pruning
381	/// threshold.
382	void finalizeAssertions( ResnState& resn, PruneMap & pruneThresholds, AltList& out ) {
383	// prune if cheaper alternative for same key has already been generated
384	std::string resKey = pruneKey( resn.alt );
385	auto it = pruneThresholds.find( resKey );
386	if ( it != pruneThresholds.end() ) {
387	if ( it->second < resn.costs ) return;
388	} else {
389	pruneThresholds.emplace_hint( it, resKey, resn.costs );
390	}
391
392	// replace resolution slots with inferred params, add to output
393	PassVisitor<InferMatcher> matcher{ resn.inferred };
394	resn.alt.expr = resn.alt.expr->acceptMutator( matcher );
395	out.emplace_back( resn.alt );
396	}
397
398	/// Limit to depth of recursion of assertion satisfaction
399	static const int recursionLimit = 4;
400	/// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
401	static const int deferLimit = 10;
402
403	void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors ) {
404	// finish early if no assertions to resolve
405	if ( alt.need.empty() ) {
406	out.emplace_back( alt );
407	return;
408	}
409
410	// build list of possible resolutions
411	using ResnList = std::vector<ResnState>;
412	SymTab::Indexer root_indexer{ indexer };
413	ResnList resns{ ResnState{ alt, root_indexer } };
414	ResnList new_resns{};
415
416	// Pruning thresholds by result type of the output alternatives.
417	// Alternatives should be generated in sorted order, so no need to retroactively prune
418	PruneMap thresholds;
419
420	// resolve assertions in breadth-first-order up to a limited number of levels deep
421	for ( unsigned level = 0; level < recursionLimit; ++level ) {
422	// scan over all mutually-compatible resolutions
423	for ( auto& resn : resns ) {
424	// stop this branch if already found a better option
425	auto it = thresholds.find( pruneKey( resn.alt ) );
426	if ( it != thresholds.end() && it->second < resn.costs ) goto nextResn;
427
428	// make initial pass at matching assertions
429	for ( auto& assn : resn.need ) {
430	// fail early if any assertion is not resolvable
431	if ( ! resolveAssertion( assn, resn ) ) {
432	Indenter tabs{ 3 };
433	std::ostringstream ss;
434	ss << tabs << "Unsatisfiable alternative:\n";
435	resn.alt.print( ss, ++tabs );
436	ss << (tabs-1) << "Could not satisfy assertion:\n";
437	assn.decl->print( ss, tabs );
438
439	errors.emplace_back( ss.str() );
440	goto nextResn;
441	}
442	}
443
444	if ( resn.deferred.empty() ) {
445	// either add successful match or push back next state
446	if ( resn.newNeed.empty() ) {
447	finalizeAssertions( resn, thresholds, out );
448	} else {
449	new_resns.emplace_back( std::move(resn), IterateState );
450	}
451	} else if ( resn.deferred.size() > deferLimit ) {
452	// too many deferred assertions to attempt mutual compatibility
453	Indenter tabs{ 3 };
454	std::ostringstream ss;
455	ss << tabs << "Unsatisfiable alternative:\n";
456	resn.alt.print( ss, ++tabs );
457	ss << (tabs-1) << "Too many non-unique satisfying assignments for "
458	"assertions:\n";
459	for ( const auto& d : resn.deferred ) {
460	d.decl->print( ss, tabs );
461	}
462
463	errors.emplace_back( ss.str() );
464	goto nextResn;
465	} else {
466	// resolve deferred assertions by mutual compatibility
467	std::vector<CandidateEnvMerger::OutType> compatible = filterCombos(
468	resn.deferred,
469	CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
470	// fail early if no mutually-compatible assertion satisfaction
471	if ( compatible.empty() ) {
472	Indenter tabs{ 3 };
473	std::ostringstream ss;
474	ss << tabs << "Unsatisfiable alternative:\n";
475	resn.alt.print( ss, ++tabs );
476	ss << (tabs-1) << "No mutually-compatible satisfaction for assertions:\n";
477	for ( const auto& d : resn.deferred ) {
478	d.decl->print( ss, tabs );
479	}
480
481	errors.emplace_back( ss.str() );
482	goto nextResn;
483	}
484	// sort by cost for overall pruning
485	CandidateCost coster{ resn.indexer };
486	std::sort( compatible.begin(), compatible.end(), coster );
487
488	for ( auto& compat : compatible ) {
489	ResnState new_resn = resn;
490
491	// add compatible assertions to new resolution state
492	for ( DeferRef r : compat.assns ) {
493	AssnCandidate match = r.match;
494	addToIndexer( match.have, new_resn.indexer );
495	new_resn.newNeed.insert( match.need.begin(), match.need.end() );
496
497	bindAssertion( r.decl, r.info, new_resn.alt, match, new_resn.inferred );
498	}
499
500	// set mutual environment into resolution state
501	new_resn.alt.env = std::move(compat.env);
502	new_resn.alt.openVars = std::move(compat.openVars);
503
504	// mark cost of this path
505	new_resn.costs.back() += compat.cost;
506
507	// either add sucessful match or push back next state
508	if ( new_resn.newNeed.empty() ) {
509	finalizeAssertions( new_resn, thresholds, out );
510	} else {
511	new_resns.emplace_back( std::move(new_resn), IterateState );
512	}
513	}
514	}
515	nextResn:; }
516
517	// finish or reset for next round
518	if ( new_resns.empty() ) return;
519	resns.swap( new_resns );
520	new_resns.clear();
521	}
522
523	// exceeded recursion limit if reaches here
524	if ( out.empty() ) {
525	SemanticError( alt.expr->location, "Too many recursive assertions" );
526	}
527	}
528	} // namespace ResolvExpr
529
530	// Local Variables: //
531	// tab-width: 4 //
532	// mode: c++ //
533	// compile-command: "make install" //
534	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats: