Context Navigation

source: src/Tuples/TupleAssignment.cc @ 70a141d4

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 70a141d4 was b8524ca, checked in by Aaron Moss <a3moss@…>, 5 years ago

new AST porting

mostly InitTweak? autogeneration
added some convenience methods
- nullptr assignment for ast::ptr
- convenience wrapper ctors for AddressExpr?, CastExpr? that draw location from first arg

Property mode set to 100644

File size: 27.4 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	// TupleAssignment.cc --
8	//
9	// Author : Rodolfo G. Esteves
10	// Created On : Mon May 18 07:44:20 2015
11	// Last Modified By : Peter A. Buhr
12	// Last Modified On : Fri Mar 17 09:43:03 2017
13	// Update Count : 8
14	//
15
16	#include <algorithm> // for transform
17	#include <cassert> // for assert
18	#include <iterator> // for back_insert_iterator, back...
19	#include <list> // for _List_const_iterator, _Lis...
20	#include <memory> // for unique_ptr, allocator_trai...
21	#include <string> // for string
22	#include <vector>
23
24	#include "AST/Decl.hpp"
25	#include "AST/Init.hpp"
26	#include "AST/Pass.hpp"
27	#include "AST/Stmt.hpp"
28	#include "AST/TypeEnvironment.hpp"
29	#include "CodeGen/OperatorTable.h"
30	#include "Common/PassVisitor.h"
31	#include "Common/UniqueName.h" // for UniqueName
32	#include "Common/utility.h" // for splice, zipWith
33	#include "Explode.h" // for explode
34	#include "InitTweak/GenInit.h" // for genCtorInit
35	#include "InitTweak/InitTweak.h" // for getPointerBase, isAssignment
36	#include "Parser/LinkageSpec.h" // for Cforall
37	#include "ResolvExpr/Alternative.h" // for AltList, Alternative
38	#include "ResolvExpr/AlternativeFinder.h" // for AlternativeFinder, simpleC...
39	#include "ResolvExpr/Cost.h" // for Cost
40	#include "ResolvExpr/Resolver.h" // for resolveCtorInit
41	#include "ResolvExpr/TypeEnvironment.h" // for TypeEnvironment
42	#include "ResolvExpr/typeops.h" // for combos
43	#include "SynTree/Declaration.h" // for ObjectDecl
44	#include "SynTree/Expression.h" // for Expression, CastExpr, Name...
45	#include "SynTree/Initializer.h" // for ConstructorInit, SingleInit
46	#include "SynTree/Statement.h" // for ExprStmt
47	#include "SynTree/Type.h" // for Type, Type::Qualifiers
48	#include "SynTree/TypeSubstitution.h" // for TypeSubstitution
49	#include "SynTree/Visitor.h" // for Visitor
50
51	#if 0
52	#define PRINT(x) x
53	#else
54	#define PRINT(x)
55	#endif
56
57	namespace Tuples {
58	class TupleAssignSpotter_old {
59	public:
60	// dispatcher for Tuple (multiple and mass) assignment operations
61	TupleAssignSpotter_old( ResolvExpr::AlternativeFinder & );
62	void spot( UntypedExpr * expr, std::vector<ResolvExpr::AlternativeFinder> &args );
63
64	private:
65	void match();
66
67	struct Matcher {
68	public:
69	Matcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
70	const ResolvExpr::AltList& rhs );
71	virtual ~Matcher() {}
72
73	virtual void match( std::list< Expression * > &out ) = 0;
74	ObjectDecl * newObject( UniqueName & namer, Expression * expr );
75
76	void combineState( const ResolvExpr::Alternative& alt ) {
77	compositeEnv.simpleCombine( alt.env );
78	ResolvExpr::mergeOpenVars( openVars, alt.openVars );
79	cloneAll( alt.need, need );
80	}
81
82	void combineState( const ResolvExpr::AltList& alts ) {
83	for ( const ResolvExpr::Alternative& alt : alts ) { combineState( alt ); }
84	}
85
86	ResolvExpr::AltList lhs, rhs;
87	TupleAssignSpotter_old &spotter;
88	ResolvExpr::Cost baseCost;
89	std::list< ObjectDecl * > tmpDecls;
90	ResolvExpr::TypeEnvironment compositeEnv;
91	ResolvExpr::OpenVarSet openVars;
92	ResolvExpr::AssertionSet need;
93	};
94
95	struct MassAssignMatcher : public Matcher {
96	public:
97	MassAssignMatcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
98	const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
99	virtual void match( std::list< Expression * > &out );
100	};
101
102	struct MultipleAssignMatcher : public Matcher {
103	public:
104	MultipleAssignMatcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
105	const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
106	virtual void match( std::list< Expression * > &out );
107	};
108
109	ResolvExpr::AlternativeFinder &currentFinder;
110	std::string fname;
111	std::unique_ptr< Matcher > matcher;
112	};
113
114	/// true if expr is an expression of tuple type
115	bool isTuple( Expression *expr ) {
116	if ( ! expr ) return false;
117	assert( expr->result );
118	return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
119	}
120
121	template< typename AltIter >
122	bool isMultAssign( AltIter begin, AltIter end ) {
123	// multiple assignment if more than one alternative in the range or if
124	// the alternative is a tuple
125	if ( begin == end ) return false;
126	if ( isTuple( begin->expr ) ) return true;
127	return ++begin != end;
128	}
129
130	bool refToTuple( Expression *expr ) {
131	assert( expr->get_result() );
132	// also check for function returning tuple of reference types
133	if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
134	return refToTuple( castExpr->get_arg() );
135	} else {
136	return isTuple( expr );
137	}
138	return false;
139	}
140
141	void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr,
142	std::vector<ResolvExpr::AlternativeFinder> &args ) {
143	TupleAssignSpotter_old spotter( currentFinder );
144	spotter.spot( expr, args );
145	}
146
147	TupleAssignSpotter_old::TupleAssignSpotter_old( ResolvExpr::AlternativeFinder &f )
148	: currentFinder(f) {}
149
150	void TupleAssignSpotter_old::spot( UntypedExpr * expr,
151	std::vector<ResolvExpr::AlternativeFinder> &args ) {
152	if ( NameExpr op = dynamic_cast< NameExpr >(expr->get_function()) ) {
153	if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
154	fname = op->get_name();
155
156	// AlternativeFinder will naturally handle this case case, if it's legal
157	if ( args.size() == 0 ) return;
158
159	// if an assignment only takes 1 argument, that's odd, but maybe someone wrote
160	// the function, in which case AlternativeFinder will handle it normally
161	if ( args.size() == 1 && CodeGen::isAssignment( fname ) ) return;
162
163	// look over all possible left-hand-sides
164	for ( ResolvExpr::Alternative& lhsAlt : args[0] ) {
165	// skip non-tuple LHS
166	if ( ! refToTuple(lhsAlt.expr) ) continue;
167
168	// explode is aware of casts - ensure every LHS expression is sent into explode
169	// with a reference cast
170	// xxx - this seems to change the alternatives before the normal
171	// AlternativeFinder flow; maybe this is desired?
172	if ( ! dynamic_cast<CastExpr*>( lhsAlt.expr ) ) {
173	lhsAlt.expr = new CastExpr( lhsAlt.expr,
174	new ReferenceType( Type::Qualifiers(),
175	lhsAlt.expr->result->clone() ) );
176	}
177
178	// explode the LHS so that each field of a tuple-valued-expr is assigned
179	ResolvExpr::AltList lhs;
180	explode( lhsAlt, currentFinder.get_indexer(), back_inserter(lhs), true );
181	for ( ResolvExpr::Alternative& alt : lhs ) {
182	// each LHS value must be a reference - some come in with a cast expression,
183	// if not just cast to reference here
184	if ( ! dynamic_cast<ReferenceType*>( alt.expr->get_result() ) ) {
185	alt.expr = new CastExpr( alt.expr,
186	new ReferenceType( Type::Qualifiers(),
187	alt.expr->get_result()->clone() ) );
188	}
189	}
190
191	if ( args.size() == 1 ) {
192	// mass default-initialization/destruction
193	ResolvExpr::AltList rhs{};
194	matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
195	match();
196	} else if ( args.size() > 2 ) {
197	// expand all possible RHS possibilities
198	// TODO build iterative version of this instead of using combos
199	std::vector< ResolvExpr::AltList > rhsAlts;
200	combos( std::next(args.begin(), 1), args.end(),
201	std::back_inserter( rhsAlts ) );
202	for ( const ResolvExpr::AltList& rhsAlt : rhsAlts ) {
203	// multiple assignment
204	ResolvExpr::AltList rhs;
205	explode( rhsAlt, currentFinder.get_indexer(),
206	std::back_inserter(rhs), true );
207	matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
208	match();
209	}
210	} else {
211	for ( const ResolvExpr::Alternative& rhsAlt : args[1] ) {
212	ResolvExpr::AltList rhs;
213	if ( isTuple(rhsAlt.expr) ) {
214	// multiple assignment
215	explode( rhsAlt, currentFinder.get_indexer(),
216	std::back_inserter(rhs), true );
217	matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
218	} else {
219	// mass assignment
220	rhs.push_back( rhsAlt );
221	matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
222	}
223	match();
224	}
225	}
226	}
227	}
228	}
229	}
230
231	void TupleAssignSpotter_old::match() {
232	assert ( matcher != 0 );
233
234	std::list< Expression * > new_assigns;
235	matcher->match( new_assigns );
236
237	if ( ! matcher->lhs.empty() \|\| ! matcher->rhs.empty() ) {
238	// if both lhs and rhs are empty then this is the empty tuple case, wherein it's okay for new_assigns to be empty.
239	// if not the empty tuple case, return early so that no new alternatives are generated.
240	if ( new_assigns.empty() ) return;
241	}
242	ResolvExpr::AltList current;
243	// now resolve new assignments
244	for ( std::list< Expression * >::iterator i = new_assigns.begin();
245	i != new_assigns.end(); ++i ) {
246	PRINT(
247	std::cerr << "== resolving tuple assign ==" << std::endl;
248	std::cerr << *i << std::endl;
249	)
250
251	ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
252	matcher->compositeEnv };
253
254	try {
255	finder.findWithAdjustment(*i);
256	} catch (...) {
257	return; // no match should not mean failure, it just means this particular tuple assignment isn't valid
258	}
259	// prune expressions that don't coincide with
260	ResolvExpr::AltList alts = finder.get_alternatives();
261	assert( alts.size() == 1 );
262	assert( alts.front().expr != 0 );
263	current.push_back( alts.front() );
264	}
265
266	// extract expressions from the assignment alternatives to produce a list of assignments
267	// that together form a single alternative
268	std::list< Expression *> solved_assigns;
269	for ( ResolvExpr::Alternative & alt : current ) {
270	solved_assigns.push_back( alt.expr->clone() );
271	matcher->combineState( alt );
272	}
273
274	// xxx -- was push_front
275	currentFinder.get_alternatives().push_back( ResolvExpr::Alternative{
276	new TupleAssignExpr{ solved_assigns, matcher->tmpDecls }, matcher->compositeEnv,
277	matcher->openVars,
278	ResolvExpr::AssertionList( matcher->need.begin(), matcher->need.end() ),
279	ResolvExpr::sumCost( current ) + matcher->baseCost } );
280	}
281
282	TupleAssignSpotter_old::Matcher::Matcher( TupleAssignSpotter_old &spotter,
283	const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs )
284	: lhs(lhs), rhs(rhs), spotter(spotter),
285	baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
286	combineState( lhs );
287	combineState( rhs );
288	}
289
290	UntypedExpr * createFunc( const std::string &fname, ObjectDecl left, ObjectDecl right ) {
291	assert( left );
292	std::list< Expression * > args;
293	args.push_back( new VariableExpr( left ) );
294	// args.push_back( new AddressExpr( new VariableExpr( left ) ) );
295	if ( right ) args.push_back( new VariableExpr( right ) );
296	if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
297	args.front() = new AddressExpr( args.front() );
298	if ( right ) args.back() = new AddressExpr( args.back() );
299	return new UntypedExpr( new NameExpr( "?=?" ), args );
300	} else {
301	return new UntypedExpr( new NameExpr( fname ), args );
302	}
303	}
304
305	// removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator, and adds the bindings to the compositeEnv
306	// xxx - maybe this should happen in alternative finder for every StmtExpr?
307	struct EnvRemover {
308	void previsit( ExprStmt * stmt ) {
309	assert( compositeEnv );
310	if ( stmt->expr->env ) {
311	compositeEnv->add( *stmt->expr->env );
312	delete stmt->expr->env;
313	stmt->expr->env = nullptr;
314	}
315	}
316
317	ResolvExpr::TypeEnvironment * compositeEnv = nullptr;
318	};
319
320	ObjectDecl * TupleAssignSpotter_old::Matcher::newObject( UniqueName & namer, Expression * expr ) {
321	assert( expr->result && ! expr->get_result()->isVoid() );
322	ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->result->clone(), new SingleInit( expr->clone() ) );
323	// if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
324	if ( ! dynamic_cast< ReferenceType * >( expr->result ) ) {
325	ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
326	ret->init = ctorInit;
327	ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
328	PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
329	rm.pass.compositeEnv = &compositeEnv;
330	ctorInit->accept( rm );
331	}
332	PRINT( std::cerr << "new object: " << ret << std::endl; )
333	return ret;
334	}
335
336	void TupleAssignSpotter_old::MassAssignMatcher::match( std::list< Expression * > &out ) {
337	static UniqueName lhsNamer( "__massassign_L" );
338	static UniqueName rhsNamer( "__massassign_R" );
339	// empty tuple case falls into this matcher, hence the second part of the assert
340	assert( (! lhs.empty() && rhs.size() <= 1) \|\| (lhs.empty() && rhs.empty()) );
341
342	// xxx - may need to split this up into multiple declarations, because potential conversion to references
343	// probably should not reference local variable - see MultipleAssignMatcher::match
344	ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
345	for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
346	// create a temporary object for each value in the lhs and create a call involving the rhs
347	ObjectDecl * ltmp = newObject( lhsNamer, lhsAlt.expr );
348	out.push_back( createFunc( spotter.fname, ltmp, rtmp ) );
349	tmpDecls.push_back( ltmp );
350	}
351	if ( rtmp ) tmpDecls.push_back( rtmp );
352	}
353
354	void TupleAssignSpotter_old::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
355	static UniqueName lhsNamer( "__multassign_L" );
356	static UniqueName rhsNamer( "__multassign_R" );
357
358	if ( lhs.size() == rhs.size() ) {
359	// produce a new temporary object for each value in the lhs and rhs and pairwise create the calls
360	std::list< ObjectDecl * > ltmp;
361	std::list< ObjectDecl * > rtmp;
362	for ( auto p : group_iterate( lhs, rhs ) ) {
363	ResolvExpr::Alternative & lhsAlt = std::get<0>(p);
364	ResolvExpr::Alternative & rhsAlt = std::get<1>(p);
365	// convert RHS to LHS type minus one reference -- important for the case where LHS is && and RHS is lvalue, etc.
366	ReferenceType * lhsType = strict_dynamic_cast<ReferenceType *>( lhsAlt.expr->result );
367	rhsAlt.expr = new CastExpr( rhsAlt.expr, lhsType->base->clone() );
368	ObjectDecl * lobj = newObject( lhsNamer, lhsAlt.expr );
369	ObjectDecl * robj = newObject( rhsNamer, rhsAlt.expr );
370	out.push_back( createFunc(spotter.fname, lobj, robj) );
371	ltmp.push_back( lobj );
372	rtmp.push_back( robj );
373
374	// resolve the cast expression so that rhsAlt return type is bound by the cast type as needed, and transfer the resulting environment
375	ResolvExpr::AlternativeFinder finder{ spotter.currentFinder.get_indexer(), compositeEnv };
376	finder.findWithAdjustment( rhsAlt.expr );
377	assert( finder.get_alternatives().size() == 1 );
378	compositeEnv = std::move( finder.get_alternatives().front().env );
379	}
380	tmpDecls.splice( tmpDecls.end(), ltmp );
381	tmpDecls.splice( tmpDecls.end(), rtmp );
382	}
383	}
384
385	namespace {
386	/// true if `expr` is of tuple type
387	bool isTuple( const ast::Expr * expr ) {
388	if ( ! expr ) return false;
389	assert( expr->result );
390	return dynamic_cast< const ast::TupleType * >( expr->result->stripReferences() );
391	}
392
393	/// true if `expr` is of tuple type or a reference to one
394	bool refToTuple( const ast::Expr * expr ) {
395	assert( expr->result );
396	// check for function returning tuple of reference types
397	if ( auto castExpr = dynamic_cast< const ast::CastExpr * >( expr ) ) {
398	return refToTuple( castExpr->arg );
399	} else {
400	return isTuple( expr );
401	}
402	}
403
404	/// Dispatcher for tuple (multiple and mass) assignment operations
405	class TupleAssignSpotter_new final {
406	/// Actually finds tuple assignment operations, by subclass
407	struct Matcher {
408	ResolvExpr::CandidateList lhs, rhs;
409	TupleAssignSpotter_new & spotter;
410	CodeLocation location;
411	ResolvExpr::Cost baseCost;
412	std::vector< ast::ptr< ast::ObjectDecl > > tmpDecls;
413	ast::TypeEnvironment env;
414	ast::OpenVarSet open;
415	ast::AssertionSet need;
416
417	void combineState( const ResolvExpr::Candidate & cand ) {
418	env.simpleCombine( cand.env );
419	ast::mergeOpenVars( open, cand.open );
420	need.insert( cand.need.begin(), cand.need.end() );
421	}
422
423	Matcher(
424	TupleAssignSpotter_new & s, const CodeLocation & loc,
425	const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
426	: lhs( l ), rhs( r ), spotter( s ), location( loc ),
427	baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ), tmpDecls(),
428	env(), open(), need() {
429	for ( auto & cand : lhs ) combineState( *cand );
430	for ( auto & cand : rhs ) combineState( *cand );
431	}
432
433	virtual std::vector< ast::ptr< ast::Expr > > match() = 0;
434
435	/// removes environments from subexpressions within statement expressions, which could
436	/// throw off later passes like those in Box which rely on PolyMutator, and adds the
437	/// bindings to the env
438	struct EnvRemover {
439	/// environment to hoist ExprStmt environments to
440	ast::TypeEnvironment & tenv;
441
442	EnvRemover( ast::TypeEnvironment & e ) : tenv( e ) {}
443
444	const ast::ExprStmt * previsit( const ast::ExprStmt * stmt ) {
445	if ( stmt->expr->env ) {
446	tenv.add( *stmt->expr->env );
447	ast::ExprStmt * mut = mutate( stmt );
448	mut->expr.get_and_mutate()->env = nullptr;
449	return mut;
450	}
451	return stmt;
452	}
453	};
454
455	ast::ObjectDecl * newObject( UniqueName & namer, const ast::Expr * expr ) {
456	assert( expr->result && ! expr->result->isVoid() );
457
458	ast::ObjectDecl * ret = new ast::ObjectDecl{
459	location, namer.newName(), expr->result, new ast::SingleInit{ location, expr },
460	ast::Storage::Classes{}, ast::Linkage::Cforall };
461
462	// if expression type is a reference, just need an initializer, otherwise construct
463	if ( ! expr->result.as< ast::ReferenceType >() ) {
464	// resolve ctor/dtor for the new object
465	ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit(
466	InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
467	// remove environments from subexpressions of stmtExpr
468	ast::Pass< EnvRemover > rm{ env };
469	ret->init = ctorInit->accept( rm );
470	}
471
472	PRINT( std::cerr << "new object: " << ret << std::endl; )
473	return ret;
474	}
475
476	ast::UntypedExpr * createFunc(
477	const std::string & fname, const ast::ObjectDecl * left,
478	const ast::ObjectDecl * right
479	) {
480	assert( left );
481	std::vector< ast::ptr< ast::Expr > > args;
482	args.emplace_back( new ast::VariableExpr{ location, left } );
483	if ( right ) { args.emplace_back( new ast::VariableExpr{ location, right } ); }
484
485	if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
486	args.front() = new ast::AddressExpr{ location, args.front() };
487	if ( right ) { args.back() = new ast::AddressExpr{ location, args.back() }; }
488	return new ast::UntypedExpr{
489	location, new ast::NameExpr{ location, "?=?" }, std::move(args) };
490	} else {
491	return new ast::UntypedExpr{
492	location, new ast::NameExpr{ location, fname }, std::move(args) };
493	}
494	}
495	};
496
497	/// Finds mass-assignment operations
498	struct MassAssignMatcher final : public Matcher {
499	MassAssignMatcher(
500	TupleAssignSpotter_new & s, const CodeLocation & loc,
501	const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
502	: Matcher( s, loc, l, r ) {}
503
504	std::vector< ast::ptr< ast::Expr > > match() override {
505	static UniqueName lhsNamer( "__massassign_L" );
506	static UniqueName rhsNamer( "__massassign_R" );
507	// empty tuple case falls into this matcher
508	assert( lhs.empty() ? rhs.empty() : rhs.size() <= 1 );
509
510	ast::ptr< ast::ObjectDecl > rtmp =
511	rhs.size() == 1 ? newObject( rhsNamer, rhs.front()->expr ) : nullptr;
512
513	std::vector< ast::ptr< ast::Expr > > out;
514	for ( ResolvExpr::CandidateRef & lhsCand : lhs ) {
515	// create a temporary object for each value in the LHS and create a call
516	// involving the RHS
517	ast::ptr< ast::ObjectDecl > ltmp = newObject( lhsNamer, lhsCand->expr );
518	out.emplace_back( createFunc( spotter.fname, ltmp, rtmp ) );
519	tmpDecls.emplace_back( std::move( ltmp ) );
520	}
521	if ( rtmp ) tmpDecls.emplace_back( std::move( rtmp ) );
522
523	return out;
524	}
525	};
526
527	/// Finds multiple-assignment operations
528	struct MultipleAssignMatcher final : public Matcher {
529	MultipleAssignMatcher(
530	TupleAssignSpotter_new & s, const CodeLocation & loc,
531	const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
532	: Matcher( s, loc, l, r ) {}
533
534	std::vector< ast::ptr< ast::Expr > > match() override {
535	static UniqueName lhsNamer( "__multassign_L" );
536	static UniqueName rhsNamer( "__multassign_R" );
537
538	if ( lhs.size() != rhs.size() ) return {};
539
540	// produce a new temporary object for each value in the LHS and RHS and pairwise
541	// create the calls
542	std::vector< ast::ptr< ast::ObjectDecl > > ltmp, rtmp;
543
544	std::vector< ast::ptr< ast::Expr > > out;
545	for ( unsigned i = 0; i < lhs.size(); ++i ) {
546	ResolvExpr::CandidateRef & lhsCand = lhs[i];
547	ResolvExpr::CandidateRef & rhsCand = rhs[i];
548
549	// convert RHS to LHS type minus one reference -- important for case where LHS
550	// is && and RHS is lvalue
551	auto lhsType = lhsCand->expr->result.strict_as< ast::ReferenceType >();
552	rhsCand->expr = new ast::CastExpr{ rhsCand->expr, lhsType->base };
553	ast::ptr< ast::ObjectDecl > lobj = newObject( lhsNamer, lhsCand->expr );
554	ast::ptr< ast::ObjectDecl > robj = newObject( rhsNamer, rhsCand->expr );
555	out.emplace_back( createFunc( spotter.fname, lobj, robj ) );
556	ltmp.emplace_back( std::move( lobj ) );
557	rtmp.emplace_back( std::move( robj ) );
558
559	// resolve the cast expression so that rhsCand return type is bound by the cast
560	// type as needed, and transfer the resulting environment
561	ResolvExpr::CandidateFinder finder{ spotter.crntFinder.symtab, env };
562	finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() );
563	assert( finder.candidates.size() == 1 );
564	env = std::move( finder.candidates.front()->env );
565	}
566
567	splice( tmpDecls, ltmp );
568	splice( tmpDecls, rtmp );
569
570	return out;
571	}
572	};
573
574	ResolvExpr::CandidateFinder & crntFinder;
575	std::string fname;
576	std::unique_ptr< Matcher > matcher;
577
578	public:
579	TupleAssignSpotter_new( ResolvExpr::CandidateFinder & f )
580	: crntFinder( f ), fname(), matcher() {}
581
582	// find left- and right-hand-sides for mass or multiple assignment
583	void spot(
584	const ast::UntypedExpr * expr, std::vector< ResolvExpr::CandidateFinder > & args
585	) {
586	if ( auto op = expr->func.as< ast::NameExpr >() ) {
587	// skip non-assignment functions
588	if ( ! CodeGen::isCtorDtorAssign( op->name ) ) return;
589	fname = op->name;
590
591	// handled by CandidateFinder if applicable (both odd cases)
592	if ( args.empty() \|\| ( args.size() == 1 && CodeGen::isAssignment( fname ) ) ) {
593	return;
594	}
595
596	// look over all possible left-hand-side
597	for ( ResolvExpr::CandidateRef & lhsCand : args[0] ) {
598	// skip non-tuple LHS
599	if ( ! refToTuple( lhsCand->expr ) ) continue;
600
601	// explode is aware of casts - ensure every LHS is sent into explode with a
602	// reference cast
603	if ( ! lhsCand->expr.as< ast::CastExpr >() ) {
604	lhsCand->expr = new ast::CastExpr{
605	lhsCand->expr, new ast::ReferenceType{ lhsCand->expr->result } };
606	}
607
608	// explode the LHS so that each field of a tuple-valued expr is assigned
609	ResolvExpr::CandidateList lhs;
610	explode( *lhsCand, crntFinder.symtab, back_inserter(lhs), true );
611	for ( ResolvExpr::CandidateRef & cand : lhs ) {
612	// each LHS value must be a reference - some come in with a cast, if not
613	// just cast to reference here
614	if ( ! cand->expr->result.as< ast::ReferenceType >() ) {
615	cand->expr = new ast::CastExpr{
616	cand->expr, new ast::ReferenceType{ cand->expr->result } };
617	}
618	}
619
620	if ( args.size() == 1 ) {
621	// mass default-initialization/destruction
622	ResolvExpr::CandidateList rhs{};
623	matcher.reset( new MassAssignMatcher{ *this, expr->location, lhs, rhs } );
624	match();
625	} else if ( args.size() == 2 ) {
626	for ( const ResolvExpr::CandidateRef & rhsCand : args[1] ) {
627	ResolvExpr::CandidateList rhs;
628	if ( isTuple( rhsCand->expr ) ) {
629	// multiple assignment
630	explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true );
631	matcher.reset(
632	new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
633	} else {
634	// mass assignment
635	rhs.emplace_back( rhsCand );
636	matcher.reset(
637	new MassAssignMatcher{ *this, expr->location, lhs, rhs } );
638	}
639	match();
640	}
641	} else {
642	// expand all possible RHS possibilities
643	std::vector< ResolvExpr::CandidateList > rhsCands;
644	combos(
645	std::next( args.begin(), 1 ), args.end(), back_inserter( rhsCands ) );
646	for ( const ResolvExpr::CandidateList & rhsCand : rhsCands ) {
647	// multiple assignment
648	ResolvExpr::CandidateList rhs;
649	explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true );
650	matcher.reset(
651	new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
652	match();
653	}
654	}
655	}
656	}
657	}
658
659	void match() {
660	assert( matcher );
661
662	std::vector< ast::ptr< ast::Expr > > newAssigns = matcher->match();
663
664	if ( ! ( matcher->lhs.empty() && matcher->rhs.empty() ) ) {
665	// if both LHS and RHS are empty than this is the empty tuple case, wherein it's
666	// okay for newAssigns to be empty. Otherwise, return early so that no new
667	// candidates are generated
668	if ( newAssigns.empty() ) return;
669	}
670
671	ResolvExpr::CandidateList crnt;
672	// now resolve new assignments
673	for ( const ast::Expr * expr : newAssigns ) {
674	PRINT(
675	std::cerr << "== resolving tuple assign ==" << std::endl;
676	std::cerr << expr << std::endl;
677	)
678
679	ResolvExpr::CandidateFinder finder{ crntFinder.symtab, matcher->env };
680
681	try {
682	finder.find( expr, ResolvExpr::ResolvMode::withAdjustment() );
683	} catch (...) {
684	// no match is not failure, just that this tuple assignment is invalid
685	return;
686	}
687
688	ResolvExpr::CandidateList & cands = finder.candidates;
689	assert( cands.size() == 1 );
690	assert( cands.front()->expr );
691	crnt.emplace_back( std::move( cands.front() ) );
692	}
693
694	// extract expressions from the assignment candidates to produce a list of assignments
695	// that together form a sigle candidate
696	std::vector< ast::ptr< ast::Expr > > solved;
697	for ( ResolvExpr::CandidateRef & cand : crnt ) {
698	solved.emplace_back( cand->expr );
699	matcher->combineState( *cand );
700	}
701
702	crntFinder.candidates.emplace_back( std::make_shared< ResolvExpr::Candidate >(
703	new ast::TupleAssignExpr{
704	matcher->location, std::move( solved ), std::move( matcher->tmpDecls ) },
705	std::move( matcher->env ), std::move( matcher->open ), std::move( matcher->need ),
706	ResolvExpr::sumCost( crnt ) + matcher->baseCost ) );
707	}
708	};
709	} // anonymous namespace
710
711	void handleTupleAssignment(
712	ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign,
713	std::vector< ResolvExpr::CandidateFinder > & args
714	) {
715	TupleAssignSpotter_new spotter{ finder };
716	spotter.spot( assign, args );
717	}
718
719	} // namespace Tuples
720
721	// Local Variables: //
722	// tab-width: 4 //
723	// mode: c++ //
724	// compile-command: "make install" //
725	// End: //

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

Download in other formats: