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
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
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.