Context Navigation

source: src/ResolvExpr/ResolveAssertions.cc @ 600478d

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

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

Download in other formats: