source: src/AST/Expr.hpp@ 8b34df0

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 8b34df0 was aaeacf4, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

Removed global look-up table from UniqueId to Decl
  • Property mode set to 100644
File size: 24.9 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// Expr.hpp --
8//
9// Author : Aaron B. Moss
10// Created On : Fri May 10 10:30:00 2019
11// Last Modified By : Aaron B. Moss
12// Created On : Fri May 10 10:30:00 2019
13// Update Count : 1
14//
15
16#pragma once
17
18#include <cassert>
19#include <deque>
20#include <map>
21#include <string>
22#include <utility> // for move
23#include <vector>
24
25#include "Fwd.hpp" // for UniqueId
26#include "Label.hpp"
27#include "ParseNode.hpp"
28#include "Visitor.hpp"
29
30// Must be included in *all* AST classes; should be #undef'd at the end of the file
31#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
32
33class ConverterOldToNew;
34
35namespace ast {
36
37/// Contains the ID of a declaration and a type that is derived from that declaration,
38/// but subject to decay-to-pointer and type parameter renaming
39struct ParamEntry {
40 UniqueId decl;
41 ptr<Decl> declptr;
42 ptr<Type> actualType;
43 ptr<Type> formalType;
44 ptr<Expr> expr;
45
46 ParamEntry() : decl( 0 ), declptr( nullptr ), actualType( nullptr ), formalType( nullptr ), expr( nullptr ) {}
47 ParamEntry( UniqueId id, Decl * declptr, Type* actual, Type* formal, Expr* e )
48 : decl( id ), declptr( declptr ), actualType( actual ), formalType( formal ), expr( e ) {}
49};
50
51/// Pre-resolution list of parameters to infer
52using ResnSlots = std::vector<UniqueId>;
53/// Post-resolution map of inferred parameters
54using InferredParams = std::map< UniqueId, ParamEntry >;
55
56/// Base node for expressions
57class Expr : public ParseNode {
58public:
59 /// Saves space (~16 bytes) by combining ResnSlots and InferredParams
60 struct InferUnion {
61 enum { Empty, Slots, Params } mode;
62 union data_t {
63 char def;
64 ResnSlots resnSlots;
65 InferredParams inferParams;
66
67 data_t() : def('\0') {}
68 ~data_t() {}
69 } data;
70
71 /// initializes from other InferUnion
72 void init_from( const InferUnion& o ) {
73 switch ( o.mode ) {
74 case Empty: return;
75 case Slots: new(&data.resnSlots) ResnSlots{ o.data.resnSlots }; return;
76 case Params: new(&data.inferParams) InferredParams{ o.data.inferParams }; return;
77 }
78 }
79
80 /// initializes from other InferUnion (move semantics)
81 void init_from( InferUnion&& o ) {
82 switch ( o.mode ) {
83 case Empty: return;
84 case Slots: new(&data.resnSlots) ResnSlots{ std::move(o.data.resnSlots) }; return;
85 case Params:
86 new(&data.inferParams) InferredParams{ std::move(o.data.inferParams) }; return;
87 }
88 }
89
90 /// clears variant fields
91 void reset() {
92 switch( mode ) {
93 case Empty: return;
94 case Slots: data.resnSlots.~ResnSlots(); return;
95 case Params: data.inferParams.~InferredParams(); return;
96 }
97 }
98
99 InferUnion() : mode(Empty), data() {}
100 InferUnion( const InferUnion& o ) : mode( o.mode ), data() { init_from( o ); }
101 InferUnion( InferUnion&& o ) : mode( o.mode ), data() { init_from( std::move(o) ); }
102 InferUnion& operator= ( const InferUnion& ) = delete;
103 InferUnion& operator= ( InferUnion&& ) = delete;
104 ~InferUnion() { reset(); }
105
106 ResnSlots& resnSlots() {
107 switch (mode) {
108 case Empty: new(&data.resnSlots) ResnSlots{}; mode = Slots; // fallthrough
109 case Slots: return data.resnSlots;
110 case Params: assert(!"Cannot return to resnSlots from Params");
111 }
112 return *((ResnSlots*)nullptr);
113 }
114
115 const ResnSlots& resnSlots() const {
116 if (mode == Slots) {
117 return data.resnSlots;
118 }
119 assert(!"Mode was not already resnSlots");
120 return *((ResnSlots*)nullptr);
121 }
122
123 InferredParams& inferParams() {
124 switch (mode) {
125 case Slots: data.resnSlots.~ResnSlots(); // fallthrough
126 case Empty: new(&data.inferParams) InferredParams{}; mode = Params; // fallthrough
127 case Params: return data.inferParams;
128 }
129 return *((InferredParams*)nullptr);
130 }
131
132 const InferredParams& inferParams() const {
133 if (mode == Params) {
134 return data.inferParams;
135 }
136 assert(!"Mode was not already Params");
137 return *((InferredParams*)nullptr);
138 }
139
140 /// splices other InferUnion into this one. Will fail if one union is in `Slots` mode
141 /// and the other is in `Params`.
142 void splice( InferUnion && o ) {
143 if ( o.mode == Empty ) return;
144 if ( mode == Empty ) { init_from( o ); return; }
145 assert( mode == o.mode && "attempt to splice incompatible InferUnion" );
146
147 if ( mode == Slots ){
148 data.resnSlots.insert(
149 data.resnSlots.end(), o.data.resnSlots.begin(), o.data.resnSlots.end() );
150 } else if ( mode == Params ) {
151 for ( const auto & p : o.data.inferParams ) {
152 data.inferParams[p.first] = std::move(p.second);
153 }
154 } else assert(!"invalid mode");
155 }
156 };
157
158 ptr<Type> result;
159 ptr<TypeSubstitution> env;
160 InferUnion inferred;
161 bool extension = false;
162
163 Expr( const CodeLocation & loc, const Type * res = nullptr )
164 : ParseNode( loc ), result( res ), env(), inferred() {}
165
166 Expr * set_extension( bool ex ) { extension = ex; return this; }
167
168 virtual const Expr * accept( Visitor & v ) const override = 0;
169private:
170 Expr * clone() const override = 0;
171 MUTATE_FRIEND
172};
173
174/// The application of a function to a set of parameters.
175/// Post-resolver form of `UntypedExpr`
176class ApplicationExpr final : public Expr {
177public:
178 ptr<Expr> func;
179 std::vector<ptr<Expr>> args;
180
181 ApplicationExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} );
182
183 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
184private:
185 ApplicationExpr * clone() const override { return new ApplicationExpr{ *this }; }
186 MUTATE_FRIEND
187};
188
189/// The application of a function to a set of parameters, pre-overload resolution.
190class UntypedExpr final : public Expr {
191public:
192 ptr<Expr> func;
193 std::vector<ptr<Expr>> args;
194
195 UntypedExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} )
196 : Expr( loc ), func( f ), args( std::move(as) ) {}
197
198 /// Creates a new dereference expression
199 static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
200 /// Creates a new assignment expression
201 static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
202
203 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
204private:
205 UntypedExpr * clone() const override { return new UntypedExpr{ *this }; }
206 MUTATE_FRIEND
207};
208
209/// A name whose name is as-yet undetermined.
210/// May also be used to avoid name mangling in codegen phase.
211class NameExpr final : public Expr {
212public:
213 std::string name;
214
215 NameExpr( const CodeLocation & loc, const std::string & n ) : Expr( loc ), name( n ) {}
216
217 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
218private:
219 NameExpr * clone() const override { return new NameExpr{ *this }; }
220 MUTATE_FRIEND
221};
222
223/// Address-of expression `&e`
224class AddressExpr final : public Expr {
225public:
226 ptr<Expr> arg;
227
228 AddressExpr( const CodeLocation & loc, const Expr * a );
229
230 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
231private:
232 AddressExpr * clone() const override { return new AddressExpr{ *this }; }
233 MUTATE_FRIEND
234};
235
236/// GCC &&label
237/// https://gcc.gnu.org/onlinedocs/gcc-3.4.2/gcc/Labels-as-Values.html
238class LabelAddressExpr final : public Expr {
239public:
240 Label arg;
241
242 LabelAddressExpr( const CodeLocation & loc, Label && a );
243
244 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
245private:
246 LabelAddressExpr * clone() const override { return new LabelAddressExpr{ *this }; }
247 MUTATE_FRIEND
248};
249
250/// Whether a cast existed in the program source or not
251enum GeneratedFlag { ExplicitCast, GeneratedCast };
252
253/// A type cast, e.g. `(int)e`
254class CastExpr final : public Expr {
255public:
256 ptr<Expr> arg;
257 GeneratedFlag isGenerated;
258
259 CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
260 GeneratedFlag g = GeneratedCast ) : Expr( loc, to ), arg( a ), isGenerated( g ) {}
261 /// Cast-to-void
262 CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast );
263
264 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
265private:
266 CastExpr * clone() const override { return new CastExpr{ *this }; }
267 MUTATE_FRIEND
268};
269
270/// A cast to "keyword types", e.g. `(thread &)t`
271class KeywordCastExpr final : public Expr {
272public:
273 ptr<Expr> arg;
274 enum Target { Coroutine, Thread, Monitor, NUMBER_OF_TARGETS } target;
275
276 KeywordCastExpr( const CodeLocation & loc, const Expr * a, Target t )
277 : Expr( loc ), arg( a ), target( t ) {}
278
279 /// Get a name for the target type
280 const std::string& targetString() const;
281
282 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
283private:
284 KeywordCastExpr * clone() const override { return new KeywordCastExpr{ *this }; }
285 MUTATE_FRIEND
286};
287
288/// A virtual dynamic cast, e.g. `(virtual exception)e`
289class VirtualCastExpr final : public Expr {
290public:
291 ptr<Expr> arg;
292
293 VirtualCastExpr( const CodeLocation & loc, const Expr * a, const Type * to )
294 : Expr( loc, to ), arg( a ) {}
295
296 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
297private:
298 VirtualCastExpr * clone() const override { return new VirtualCastExpr{ *this }; }
299 MUTATE_FRIEND
300};
301
302/// A member selection operation before expression resolution, e.g. `q.p`
303class UntypedMemberExpr final : public Expr {
304public:
305 ptr<Expr> member;
306 ptr<Expr> aggregate;
307
308 UntypedMemberExpr( const CodeLocation & loc, const Expr * mem, const Expr * agg )
309 : Expr( loc ), member( mem ), aggregate( agg ) { assert( aggregate ); }
310
311 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
312private:
313 UntypedMemberExpr * clone() const override { return new UntypedMemberExpr{ *this }; }
314 MUTATE_FRIEND
315};
316
317/// A member selection operation after expression resolution, e.g. `q.p`
318class MemberExpr final : public Expr {
319public:
320 readonly<DeclWithType> member;
321 ptr<Expr> aggregate;
322
323 MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg );
324
325 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
326private:
327 MemberExpr * clone() const override { return new MemberExpr{ *this }; }
328 MUTATE_FRIEND
329};
330
331/// A reference to a named variable.
332class VariableExpr final : public Expr {
333public:
334 readonly<DeclWithType> var;
335
336 VariableExpr( const CodeLocation & loc );
337 VariableExpr( const CodeLocation & loc, const DeclWithType * v );
338
339 /// generates a function pointer for a given function
340 static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
341
342 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
343private:
344 VariableExpr * clone() const override { return new VariableExpr{ *this }; }
345 MUTATE_FRIEND
346};
347
348/// A compile-time constant
349class ConstantExpr final : public Expr {
350 union Val {
351 unsigned long long ival;
352 double dval;
353
354 Val( unsigned long long i ) : ival( i ) {}
355 Val( double d ) : dval( d ) {}
356 } val;
357public:
358 std::string rep;
359 enum Kind { Integer, FloatingPoint, String } kind;
360
361 ConstantExpr(
362 const CodeLocation & loc, const Type * ty, const std::string & r, unsigned long long v,
363 Kind k = Integer )
364 : Expr( loc, ty ), val( v ), rep( r ), kind( k ) {}
365 ConstantExpr( const CodeLocation & loc, const Type * ty, const std::string & r, double v )
366 : Expr( loc, ty ), val( v ), rep( r ), kind( FloatingPoint ) {}
367
368 /// Gets the value of this constant as an integer
369 long long int intValue() const;
370 /// Gets the value of this constant as floating point
371 double floatValue() const;
372
373 /// generates a boolean constant of the given bool
374 static ConstantExpr * from_bool( const CodeLocation & loc, bool b );
375 /// generates a char constant of the given char
376 static ConstantExpr * from_char( const CodeLocation & loc, char c );
377 /// generates an integer constant of the given int
378 static ConstantExpr * from_int( const CodeLocation & loc, int i );
379 /// generates an integer constant of the given unsigned long int
380 static ConstantExpr * from_ulong( const CodeLocation & loc, unsigned long i );
381 /// generates a floating point constant of the given double
382 static ConstantExpr * from_double( const CodeLocation & loc, double d );
383 /// generates an array of chars constant of the given string
384 static ConstantExpr * from_string( const CodeLocation & loc, const std::string & s );
385 /// generates a null pointer value for the given type. void * if omitted.
386 static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
387
388 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
389private:
390 ConstantExpr * clone() const override { return new ConstantExpr{ *this }; }
391 MUTATE_FRIEND
392};
393
394/// sizeof expression, e.g. `sizeof(int)`, `sizeof 3+4`
395class SizeofExpr final : public Expr {
396public:
397 ptr<Expr> expr;
398 ptr<Type> type;
399
400 SizeofExpr( const CodeLocation & loc, const Expr * e );
401 SizeofExpr( const CodeLocation & loc, const Type * t );
402 // deliberately no disambiguating overload for nullptr_t
403
404 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
405private:
406 SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
407 MUTATE_FRIEND
408};
409
410/// alignof expression, e.g. `alignof(int)`, `alignof 3+4`
411class AlignofExpr final : public Expr {
412public:
413 ptr<Expr> expr;
414 ptr<Type> type;
415
416 AlignofExpr( const CodeLocation & loc, const Expr * e );
417 AlignofExpr( const CodeLocation & loc, const Type * t );
418 // deliberately no disambiguating overload for nullptr_t
419
420 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
421private:
422 AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
423 MUTATE_FRIEND
424};
425
426/// offsetof expression before resolver determines field, e.g. `offsetof(MyStruct, myfield)`
427class UntypedOffsetofExpr final : public Expr {
428public:
429 ptr<Type> type;
430 std::string member;
431
432 UntypedOffsetofExpr( const CodeLocation & loc, const Type * ty, const std::string & mem )
433 : Expr( loc ), type( ty ), member( mem ) {}
434
435 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
436private:
437 UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr{ *this }; }
438 MUTATE_FRIEND
439};
440
441/// offsetof expression after resolver determines field, e.g. `offsetof(MyStruct, myfield)`
442class OffsetofExpr final : public Expr {
443public:
444 ptr<Type> type;
445 readonly<DeclWithType> member;
446
447 OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem );
448
449 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
450private:
451 OffsetofExpr * clone() const override { return new OffsetofExpr{ *this }; }
452 MUTATE_FRIEND
453};
454
455/// a pack of field-offsets for a generic type
456class OffsetPackExpr final : public Expr {
457public:
458 ptr<StructInstType> type;
459
460 OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty );
461
462 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
463private:
464 OffsetPackExpr * clone() const override { return new OffsetPackExpr{ *this }; }
465 MUTATE_FRIEND
466};
467
468/// Variants of short-circuiting logical expression
469enum LogicalFlag { OrExpr, AndExpr };
470
471/// Short-circuiting boolean expression (`&&` or `||`)
472class LogicalExpr final : public Expr {
473public:
474 ptr<Expr> arg1;
475 ptr<Expr> arg2;
476 LogicalFlag isAnd;
477
478 LogicalExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia );
479
480 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
481private:
482 LogicalExpr * clone() const override { return new LogicalExpr{ *this }; }
483 MUTATE_FRIEND
484};
485
486/// Three-argument conditional e.g. `p ? a : b`
487class ConditionalExpr final : public Expr {
488public:
489 ptr<Expr> arg1;
490 ptr<Expr> arg2;
491 ptr<Expr> arg3;
492
493 ConditionalExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2, const Expr * a3 )
494 : Expr( loc ), arg1( a1 ), arg2( a2 ), arg3( a3 ) {}
495
496 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
497private:
498 ConditionalExpr * clone() const override { return new ConditionalExpr{ *this }; }
499 MUTATE_FRIEND
500};
501
502/// Comma expression e.g. `( a , b )`
503class CommaExpr final : public Expr {
504public:
505 ptr<Expr> arg1;
506 ptr<Expr> arg2;
507
508 CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
509 : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
510
511 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
512private:
513 CommaExpr * clone() const override { return new CommaExpr{ *this }; }
514 MUTATE_FRIEND
515};
516
517/// A type used as an expression (e.g. a type generator parameter)
518class TypeExpr final : public Expr {
519public:
520 ptr<Type> type;
521
522 TypeExpr( const CodeLocation & loc, const Type * t ) : Expr(loc), type(t) {}
523
524 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
525private:
526 TypeExpr * clone() const override { return new TypeExpr{ *this }; }
527 MUTATE_FRIEND
528};
529
530/// A GCC "asm constraint operand" used in an asm statement, e.g. `[output] "=f" (result)`.
531/// https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
532class AsmExpr final : public Expr {
533public:
534 ptr<Expr> inout;
535 ptr<Expr> constraint;
536 ptr<Expr> operand;
537
538 AsmExpr( const CodeLocation & loc, const Expr * io, const Expr * con, const Expr * op )
539 : Expr( loc ), inout( io ), constraint( con ), operand( op ) {}
540
541 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
542private:
543 AsmExpr * clone() const override { return new AsmExpr{ *this }; }
544 MUTATE_FRIEND
545};
546
547/// The application of a function to a set of parameters, along with a set of copy constructor
548/// calls, one for each argument
549class ImplicitCopyCtorExpr final : public Expr {
550public:
551 ptr<ApplicationExpr> callExpr;
552
553 ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
554 : Expr( loc, call->result ) { assert( call ); }
555
556 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
557private:
558 ImplicitCopyCtorExpr * clone() const override { return new ImplicitCopyCtorExpr{ *this }; }
559 MUTATE_FRIEND
560};
561
562/// Constructor in expression context, e.g. `int * x = alloc() { 42 };`
563class ConstructorExpr final : public Expr {
564public:
565 ptr<Expr> callExpr;
566
567 ConstructorExpr( const CodeLocation & loc, const Expr * call );
568
569 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
570private:
571 ConstructorExpr * clone() const override { return new ConstructorExpr{ *this }; }
572 MUTATE_FRIEND
573};
574
575/// A C99 compound literal, e.g. `(MyType){ a, b, c }`
576class CompoundLiteralExpr final : public Expr {
577public:
578 ptr<Init> init;
579
580 CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i );
581
582 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
583private:
584 CompoundLiteralExpr * clone() const override { return new CompoundLiteralExpr{ *this }; }
585 MUTATE_FRIEND
586};
587
588/// A range, e.g. `3 ... 5` or `1~10`
589class RangeExpr final : public Expr {
590public:
591 ptr<Expr> low;
592 ptr<Expr> high;
593
594 RangeExpr( const CodeLocation & loc, const Expr * l, const Expr * h )
595 : Expr( loc ), low( l ), high( h ) {}
596
597 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
598private:
599 RangeExpr * clone() const override { return new RangeExpr{ *this }; }
600 MUTATE_FRIEND
601};
602
603/// A tuple expression before resolution, e.g. `[a, b, c]`
604class UntypedTupleExpr final : public Expr {
605public:
606 std::vector<ptr<Expr>> exprs;
607
608 UntypedTupleExpr( const CodeLocation & loc, std::vector<ptr<Expr>> && xs )
609 : Expr( loc ), exprs( std::move(xs) ) {}
610
611 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
612private:
613 UntypedTupleExpr * clone() const override { return new UntypedTupleExpr{ *this }; }
614 MUTATE_FRIEND
615};
616
617/// A tuple expression after resolution, e.g. `[a, b, c]`
618class TupleExpr final : public Expr {
619public:
620 std::vector<ptr<Expr>> exprs;
621
622 TupleExpr( const CodeLocation & loc, std::vector<ptr<Expr>> && xs );
623
624 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
625private:
626 TupleExpr * clone() const override { return new TupleExpr{ *this }; }
627 MUTATE_FRIEND
628};
629
630/// An element selection operation on a tuple value, e.g. `t.3` after analysis
631class TupleIndexExpr final : public Expr {
632public:
633 ptr<Expr> tuple;
634 unsigned index;
635
636 TupleIndexExpr( const CodeLocation & loc, const Expr * t, unsigned i );
637
638 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
639private:
640 TupleIndexExpr * clone() const override { return new TupleIndexExpr{ *this }; }
641 MUTATE_FRIEND
642};
643
644/// A multiple- or mass-assignment operation, or a tuple ctor/dtor expression.
645/// multiple-assignment: both sides of the assignment have tuple type,
646/// e.g. `[a, b, c] = [d, e, f];`
647/// mass-assignment: left-hand side has tuple type and right-hand side does not:
648/// e.g. `[a, b, c] = 42;`
649class TupleAssignExpr final : public Expr {
650public:
651 ptr<StmtExpr> stmtExpr;
652
653 TupleAssignExpr(
654 const CodeLocation & loc, std::vector<ptr<Expr>> && assigns,
655 std::vector<ptr<ObjectDecl>> && tempDecls );
656
657 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
658
659 friend class ::ConverterOldToNew;
660
661private:
662 TupleAssignExpr * clone() const override { return new TupleAssignExpr{ *this }; }
663 TupleAssignExpr( const CodeLocation & loc, const Type * result, const StmtExpr * s );
664
665 MUTATE_FRIEND
666};
667
668/// A GCC "statement expression", e.g. `({ int x = 5; x })`
669class StmtExpr final : public Expr {
670public:
671 ptr<CompoundStmt> stmts;
672 std::vector<ptr<ObjectDecl>> returnDecls; ///< return variable(s) for statement expression
673 std::vector<ptr<Expr>> dtors; ///< destructor(s) for return variable(s)
674
675 StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );
676
677 /// Set the result type of this StmtExpr based on its body
678 void computeResult();
679
680 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
681private:
682 StmtExpr * clone() const override { return new StmtExpr{ *this }; }
683 MUTATE_FRIEND
684};
685
686/// An expression which must only be evaluated once
687class UniqueExpr final : public Expr {
688 static unsigned long long nextId;
689public:
690 ptr<Expr> expr;
691 ptr<ObjectDecl> object;
692 ptr<VariableExpr> var;
693 unsigned long long id;
694
695 UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i = -1 );
696
697 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
698private:
699 UniqueExpr * clone() const override { return new UniqueExpr{ *this }; }
700 MUTATE_FRIEND
701};
702
703/// One option for resolving an initializer expression
704struct InitAlternative {
705 ptr<Type> type;
706 ptr<Designation> designation;
707
708 InitAlternative() = default;
709 InitAlternative( const Type * ty, const Designation * des ) : type( ty ), designation( des ) {}
710};
711
712/// Pre-resolution initializer expression
713class UntypedInitExpr final : public Expr {
714public:
715 ptr<Expr> expr;
716 std::deque<InitAlternative> initAlts;
717
718 UntypedInitExpr( const CodeLocation & loc, const Expr * e, std::deque<InitAlternative> && as )
719 : Expr( loc ), expr( e ), initAlts( std::move(as) ) {}
720
721 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
722private:
723 UntypedInitExpr * clone() const override { return new UntypedInitExpr{ *this }; }
724 MUTATE_FRIEND
725};
726
727/// Post-resolution initializer expression
728class InitExpr final : public Expr {
729public:
730 ptr<Expr> expr;
731 ptr<Designation> designation;
732
733 InitExpr( const CodeLocation & loc, const Expr * e, const Designation * des )
734 : Expr( loc, e->result ), expr( e ), designation( des ) {}
735
736 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
737private:
738 InitExpr * clone() const override { return new InitExpr{ *this }; }
739 MUTATE_FRIEND
740};
741
742/// Expression containing a deleted identifier.
743/// Internal to resolver.
744class DeletedExpr final : public Expr {
745public:
746 ptr<Expr> expr;
747 readonly<Node> deleteStmt;
748
749 DeletedExpr( const CodeLocation & loc, const Expr * e, const Node * del )
750 : Expr( loc, e->result ), expr( e ), deleteStmt( del ) { assert( expr->result ); }
751
752 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
753private:
754 DeletedExpr * clone() const override { return new DeletedExpr{ *this }; }
755 MUTATE_FRIEND
756};
757
758/// Use of a default argument.
759/// Internal to resolver.
760class DefaultArgExpr final : public Expr {
761public:
762 ptr<Expr> expr;
763
764 DefaultArgExpr( const CodeLocation & loc, const Expr * e )
765 : Expr( loc, e->result ), expr( e ) { assert( e->result ); }
766
767 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
768private:
769 DefaultArgExpr * clone() const override { return new DefaultArgExpr{ *this }; }
770 MUTATE_FRIEND
771};
772
773/// C11 _Generic expression
774class GenericExpr final : public Expr {
775public:
776 /// One arm of the _Generic expr
777 struct Association {
778 ptr<Type> type;
779 ptr<Expr> expr;
780
781 Association() = default;
782 // default case
783 Association( const Expr * e ) : type(), expr( e ) {}
784 // non-default case
785 Association( const Type * t, const Expr * e ) : type( t ), expr( e ) {}
786 };
787
788 ptr<Expr> control;
789 std::vector<Association> associations;
790
791 GenericExpr( const CodeLocation & loc, const Expr * ctrl, std::vector<Association> && assns )
792 : Expr( loc ), control( ctrl ), associations( std::move(assns) ) {}
793
794 const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
795private:
796 GenericExpr * clone() const override { return new GenericExpr{ *this }; }
797 MUTATE_FRIEND
798};
799
800
801}
802
803#undef MUTATE_FRIEND
804
805// Local Variables: //
806// tab-width: 4 //
807// mode: c++ //
808// compile-command: "make install" //
809// End: //
Note: See TracBrowser for help on using the repository browser.