source: src/Tuples/TupleAssignment.cc@ 18fe0fe

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 18fe0fe was 3251b66, checked in by Fangren Yu <f37yu@…>, 5 years ago

use different autogen prefix for new ast
  • Property mode set to 100644
File size: 27.5 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 Dec 13 23:45:33 2019
13// Update Count : 9
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 "ResolvExpr/Alternative.h" // for AltList, Alternative
37#include "ResolvExpr/AlternativeFinder.h" // for AlternativeFinder, simpleC...
38#include "ResolvExpr/Cost.h" // for Cost
39#include "ResolvExpr/Resolver.h" // for resolveCtorInit
40#include "ResolvExpr/TypeEnvironment.h" // for TypeEnvironment
41#include "ResolvExpr/typeops.h" // for combos
42#include "SynTree/LinkageSpec.h" // for Cforall
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
57namespace 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
385namespace {
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 virtual ~Matcher() = default;
433
434 virtual std::vector< ast::ptr< ast::Expr > > match() = 0;
435
436 /// removes environments from subexpressions within statement expressions, which could
437 /// throw off later passes like those in Box which rely on PolyMutator, and adds the
438 /// bindings to the env
439 struct EnvRemover {
440 /// environment to hoist ExprStmt environments to
441 ast::TypeEnvironment & tenv;
442
443 EnvRemover( ast::TypeEnvironment & e ) : tenv( e ) {}
444
445 const ast::ExprStmt * previsit( const ast::ExprStmt * stmt ) {
446 if ( stmt->expr->env ) {
447 tenv.add( *stmt->expr->env );
448 ast::ExprStmt * mut = mutate( stmt );
449 mut->expr.get_and_mutate()->env = nullptr;
450 return mut;
451 }
452 return stmt;
453 }
454 };
455
456 ast::ObjectDecl * newObject( UniqueName & namer, const ast::Expr * expr ) {
457 assert( expr->result && ! expr->result->isVoid() );
458
459 ast::ObjectDecl * ret = new ast::ObjectDecl{
460 location, namer.newName(), expr->result, new ast::SingleInit{ location, expr },
461 ast::Storage::Classes{}, ast::Linkage::Cforall };
462
463 // if expression type is a reference, just need an initializer, otherwise construct
464 if ( ! expr->result.as< ast::ReferenceType >() ) {
465 // resolve ctor/dtor for the new object
466 ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit(
467 InitTweak::genCtorInit( location, ret ), spotter.crntFinder.localSyms );
468 // remove environments from subexpressions of stmtExpr
469 ast::Pass< EnvRemover > rm{ env };
470 ret->init = ctorInit->accept( rm );
471 }
472
473 PRINT( std::cerr << "new object: " << ret << std::endl; )
474 return ret;
475 }
476
477 ast::UntypedExpr * createFunc(
478 const std::string & fname, const ast::ObjectDecl * left,
479 const ast::ObjectDecl * right
480 ) {
481 assert( left );
482 std::vector< ast::ptr< ast::Expr > > args;
483 args.emplace_back( new ast::VariableExpr{ location, left } );
484 if ( right ) { args.emplace_back( new ast::VariableExpr{ location, right } ); }
485
486 if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
487 args.front() = new ast::AddressExpr{ location, args.front() };
488 if ( right ) { args.back() = new ast::AddressExpr{ location, args.back() }; }
489 return new ast::UntypedExpr{
490 location, new ast::NameExpr{ location, "?=?" }, std::move(args) };
491 } else {
492 return new ast::UntypedExpr{
493 location, new ast::NameExpr{ location, fname }, std::move(args) };
494 }
495 }
496 };
497
498 /// Finds mass-assignment operations
499 struct MassAssignMatcher final : public Matcher {
500 MassAssignMatcher(
501 TupleAssignSpotter_new & s, const CodeLocation & loc,
502 const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
503 : Matcher( s, loc, l, r ) {}
504
505 std::vector< ast::ptr< ast::Expr > > match() override {
506 // temporary workaround for new and old ast to coexist and avoid name collision
507 static UniqueName lhsNamer( "__massassign_Ln" );
508 static UniqueName rhsNamer( "__massassign_Rn" );
509 // empty tuple case falls into this matcher
510 assert( lhs.empty() ? rhs.empty() : rhs.size() <= 1 );
511
512 ast::ptr< ast::ObjectDecl > rtmp =
513 rhs.size() == 1 ? newObject( rhsNamer, rhs.front()->expr ) : nullptr;
514
515 std::vector< ast::ptr< ast::Expr > > out;
516 for ( ResolvExpr::CandidateRef & lhsCand : lhs ) {
517 // create a temporary object for each value in the LHS and create a call
518 // involving the RHS
519 ast::ptr< ast::ObjectDecl > ltmp = newObject( lhsNamer, lhsCand->expr );
520 out.emplace_back( createFunc( spotter.fname, ltmp, rtmp ) );
521 tmpDecls.emplace_back( std::move( ltmp ) );
522 }
523 if ( rtmp ) tmpDecls.emplace_back( std::move( rtmp ) );
524
525 return out;
526 }
527 };
528
529 /// Finds multiple-assignment operations
530 struct MultipleAssignMatcher final : public Matcher {
531 MultipleAssignMatcher(
532 TupleAssignSpotter_new & s, const CodeLocation & loc,
533 const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
534 : Matcher( s, loc, l, r ) {}
535
536 std::vector< ast::ptr< ast::Expr > > match() override {
537 // temporary workaround for new and old ast to coexist and avoid name collision
538 static UniqueName lhsNamer( "__multassign_Ln" );
539 static UniqueName rhsNamer( "__multassign_Rn" );
540
541 if ( lhs.size() != rhs.size() ) return {};
542
543 // produce a new temporary object for each value in the LHS and RHS and pairwise
544 // create the calls
545 std::vector< ast::ptr< ast::ObjectDecl > > ltmp, rtmp;
546
547 std::vector< ast::ptr< ast::Expr > > out;
548 for ( unsigned i = 0; i < lhs.size(); ++i ) {
549 ResolvExpr::CandidateRef & lhsCand = lhs[i];
550 ResolvExpr::CandidateRef & rhsCand = rhs[i];
551
552 // convert RHS to LHS type minus one reference -- important for case where LHS
553 // is && and RHS is lvalue
554 auto lhsType = lhsCand->expr->result.strict_as< ast::ReferenceType >();
555 rhsCand->expr = new ast::CastExpr{ rhsCand->expr, lhsType->base };
556 ast::ptr< ast::ObjectDecl > lobj = newObject( lhsNamer, lhsCand->expr );
557 ast::ptr< ast::ObjectDecl > robj = newObject( rhsNamer, rhsCand->expr );
558 out.emplace_back( createFunc( spotter.fname, lobj, robj ) );
559 ltmp.emplace_back( std::move( lobj ) );
560 rtmp.emplace_back( std::move( robj ) );
561
562 // resolve the cast expression so that rhsCand return type is bound by the cast
563 // type as needed, and transfer the resulting environment
564 ResolvExpr::CandidateFinder finder{ spotter.crntFinder.localSyms, env };
565 finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() );
566 assert( finder.candidates.size() == 1 );
567 env = std::move( finder.candidates.front()->env );
568 }
569
570 splice( tmpDecls, ltmp );
571 splice( tmpDecls, rtmp );
572
573 return out;
574 }
575 };
576
577 ResolvExpr::CandidateFinder & crntFinder;
578 std::string fname;
579 std::unique_ptr< Matcher > matcher;
580
581 public:
582 TupleAssignSpotter_new( ResolvExpr::CandidateFinder & f )
583 : crntFinder( f ), fname(), matcher() {}
584
585 // find left- and right-hand-sides for mass or multiple assignment
586 void spot(
587 const ast::UntypedExpr * expr, std::vector< ResolvExpr::CandidateFinder > & args
588 ) {
589 if ( auto op = expr->func.as< ast::NameExpr >() ) {
590 // skip non-assignment functions
591 if ( ! CodeGen::isCtorDtorAssign( op->name ) ) return;
592 fname = op->name;
593
594 // handled by CandidateFinder if applicable (both odd cases)
595 if ( args.empty() || ( args.size() == 1 && CodeGen::isAssignment( fname ) ) ) {
596 return;
597 }
598
599 // look over all possible left-hand-side
600 for ( ResolvExpr::CandidateRef & lhsCand : args[0] ) {
601 // skip non-tuple LHS
602 if ( ! refToTuple( lhsCand->expr ) ) continue;
603
604 // explode is aware of casts - ensure every LHS is sent into explode with a
605 // reference cast
606 if ( ! lhsCand->expr.as< ast::CastExpr >() ) {
607 lhsCand->expr = new ast::CastExpr{
608 lhsCand->expr, new ast::ReferenceType{ lhsCand->expr->result } };
609 }
610
611 // explode the LHS so that each field of a tuple-valued expr is assigned
612 ResolvExpr::CandidateList lhs;
613 explode( *lhsCand, crntFinder.localSyms, back_inserter(lhs), true );
614 for ( ResolvExpr::CandidateRef & cand : lhs ) {
615 // each LHS value must be a reference - some come in with a cast, if not
616 // just cast to reference here
617 if ( ! cand->expr->result.as< ast::ReferenceType >() ) {
618 cand->expr = new ast::CastExpr{
619 cand->expr, new ast::ReferenceType{ cand->expr->result } };
620 }
621 }
622
623 if ( args.size() == 1 ) {
624 // mass default-initialization/destruction
625 ResolvExpr::CandidateList rhs{};
626 matcher.reset( new MassAssignMatcher{ *this, expr->location, lhs, rhs } );
627 match();
628 } else if ( args.size() == 2 ) {
629 for ( const ResolvExpr::CandidateRef & rhsCand : args[1] ) {
630 ResolvExpr::CandidateList rhs;
631 if ( isTuple( rhsCand->expr ) ) {
632 // multiple assignment
633 explode( *rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
634 matcher.reset(
635 new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
636 } else {
637 // mass assignment
638 rhs.emplace_back( rhsCand );
639 matcher.reset(
640 new MassAssignMatcher{ *this, expr->location, lhs, rhs } );
641 }
642 match();
643 }
644 } else {
645 // expand all possible RHS possibilities
646 std::vector< ResolvExpr::CandidateList > rhsCands;
647 combos(
648 std::next( args.begin(), 1 ), args.end(), back_inserter( rhsCands ) );
649 for ( const ResolvExpr::CandidateList & rhsCand : rhsCands ) {
650 // multiple assignment
651 ResolvExpr::CandidateList rhs;
652 explode( rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
653 matcher.reset(
654 new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
655 match();
656 }
657 }
658 }
659 }
660 }
661
662 void match() {
663 assert( matcher );
664
665 std::vector< ast::ptr< ast::Expr > > newAssigns = matcher->match();
666
667 if ( ! ( matcher->lhs.empty() && matcher->rhs.empty() ) ) {
668 // if both LHS and RHS are empty than this is the empty tuple case, wherein it's
669 // okay for newAssigns to be empty. Otherwise, return early so that no new
670 // candidates are generated
671 if ( newAssigns.empty() ) return;
672 }
673
674 ResolvExpr::CandidateList crnt;
675 // now resolve new assignments
676 for ( const ast::Expr * expr : newAssigns ) {
677 PRINT(
678 std::cerr << "== resolving tuple assign ==" << std::endl;
679 std::cerr << expr << std::endl;
680 )
681
682 ResolvExpr::CandidateFinder finder{ crntFinder.localSyms, matcher->env };
683
684 try {
685 finder.find( expr, ResolvExpr::ResolvMode::withAdjustment() );
686 } catch (...) {
687 // no match is not failure, just that this tuple assignment is invalid
688 return;
689 }
690
691 ResolvExpr::CandidateList & cands = finder.candidates;
692 assert( cands.size() == 1 );
693 assert( cands.front()->expr );
694 crnt.emplace_back( std::move( cands.front() ) );
695 }
696
697 // extract expressions from the assignment candidates to produce a list of assignments
698 // that together form a sigle candidate
699 std::vector< ast::ptr< ast::Expr > > solved;
700 for ( ResolvExpr::CandidateRef & cand : crnt ) {
701 solved.emplace_back( cand->expr );
702 matcher->combineState( *cand );
703 }
704
705 crntFinder.candidates.emplace_back( std::make_shared< ResolvExpr::Candidate >(
706 new ast::TupleAssignExpr{
707 matcher->location, std::move( solved ), std::move( matcher->tmpDecls ) },
708 std::move( matcher->env ), std::move( matcher->open ), std::move( matcher->need ),
709 ResolvExpr::sumCost( crnt ) + matcher->baseCost ) );
710 }
711 };
712} // anonymous namespace
713
714void handleTupleAssignment(
715 ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign,
716 std::vector< ResolvExpr::CandidateFinder > & args
717) {
718 TupleAssignSpotter_new spotter{ finder };
719 spotter.spot( assign, args );
720}
721
722} // namespace Tuples
723
724// Local Variables: //
725// tab-width: 4 //
726// mode: c++ //
727// compile-command: "make install" //
728// End: //
Note: See TracBrowser for help on using the repository browser.